able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/snapin/wsecmgr/cookie.cpp

1940 lines
53 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+--------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1994 - 2001.
//
// File: cookie.cpp
//
// Contents: Functions for handling SCE cookies for the scope and
// result panes
//
// History:
//
//---------------------------------------------------------------------------
#include "stdafx.h"
#include "cookie.h"
#include "snapmgr.h"
#include "wrapper.h"
#include <sceattch.h>
#include "precdisp.h"
#include "util.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
CFolder::~CFolder()
{
if (m_pScopeItem)
{
delete m_pScopeItem;
m_pScopeItem = NULL;
}
CoTaskMemFree(m_pszName);
CoTaskMemFree(m_pszDesc);
while (!m_resultItemList.IsEmpty () )
{
CResult* pResult = m_resultItemList.RemoveHead ();
if ( pResult )
pResult->Release ();
}
}
//+--------------------------------------------------------------------------
//
// Method: SetDesc
//
// Synopsis: Sets the description of the folder
//
// Arguments: [szDesc] - [in] the new description of the folder
//
// Returns: TRUE if successfull, FALSE otherwise
//
// Modifies: m_pszDesc
//
// History:
//
//---------------------------------------------------------------------------
BOOL CFolder::SetDesc(LPCTSTR szDesc)
{
UINT uiByteLen = 0;
LPOLESTR psz = 0;
if (szDesc != NULL)
{
uiByteLen = (lstrlen(szDesc) + 1) * sizeof(OLECHAR);
psz = (LPOLESTR)::CoTaskMemAlloc(uiByteLen);
if (psz != NULL)
{
lstrcpy(psz, szDesc);
CoTaskMemFree(m_pszDesc);
m_pszDesc = psz;
}
else
return FALSE;
}
else
return FALSE;
return TRUE;
}
// --------------------------------------------------------------------------
// Method: SetViewUpdate
//
// Synopsis: Sets and gets update flag of this folder
//
// History: Raid #258237, 4/12/2001
//
//---------------------------------------------------------------------------
void CFolder::SetViewUpdate(BOOL fUpdate)
{
m_ViewUpdate = fUpdate;
}
BOOL CFolder::GetViewUpdate() const
{
return m_ViewUpdate;
}
//+--------------------------------------------------------------------------
//
// Method: SetMode
//
// Synopsis: Sets the SCE Mode that this folder is operating under and
// calculates the "Mode Bits" appropriate for that mode
//
// Arguments: [dwMode] - The mode to set
//
// Returns: TRUE if the mode is valid, FALSE otherwise
//
// Modifies: m_dwMode
// m_ModeBits
//
// History: 20-Jan-1998 Robcap created
//
//---------------------------------------------------------------------------
BOOL CFolder::SetMode(DWORD dwMode)
{
//
// Make sure this is a legitimate mode
//
switch (dwMode)
{
case SCE_MODE_RSOP_COMPUTER:
case SCE_MODE_RSOP_USER:
case SCE_MODE_LOCALSEC:
case SCE_MODE_COMPUTER_MANAGEMENT:
case SCE_MODE_DC_MANAGEMENT:
case SCE_MODE_LOCAL_USER:
case SCE_MODE_LOCAL_COMPUTER:
case SCE_MODE_REMOTE_USER:
case SCE_MODE_REMOTE_COMPUTER:
case SCE_MODE_DOMAIN_USER:
case SCE_MODE_DOMAIN_COMPUTER:
case SCE_MODE_OU_USER:
case SCE_MODE_OU_COMPUTER:
case SCE_MODE_EDITOR:
case SCE_MODE_VIEWER:
case SCE_MODE_DOMAIN_COMPUTER_ERROR:
m_dwMode = dwMode;
break;
default:
return FALSE;
break;
}
//
// Calculate the mode bits for this mode
//
m_ModeBits = 0;
//
// Directory Services not avalible in NT4
//
if ((dwMode == SCE_MODE_DOMAIN_COMPUTER) ||
(dwMode == SCE_MODE_DC_MANAGEMENT))
{
m_ModeBits |= MB_DS_OBJECTS_SECTION;
}
if ((dwMode == SCE_MODE_OU_USER) ||
(dwMode == SCE_MODE_DOMAIN_USER) ||
(dwMode == SCE_MODE_REMOTE_COMPUTER) ||
(dwMode == SCE_MODE_REMOTE_USER) ||
(dwMode == SCE_MODE_RSOP_USER) ||
(dwMode == SCE_MODE_DOMAIN_COMPUTER_ERROR) ||
(dwMode == SCE_MODE_LOCAL_USER))
{
m_ModeBits |= MB_NO_NATIVE_NODES |
MB_NO_TEMPLATE_VERBS |
MB_WRITE_THROUGH;
}
if ((dwMode == SCE_MODE_OU_COMPUTER) ||
(dwMode == SCE_MODE_DOMAIN_COMPUTER) )
{
m_ModeBits |= MB_SINGLE_TEMPLATE_ONLY |
MB_NO_TEMPLATE_VERBS |
MB_GROUP_POLICY |
MB_WRITE_THROUGH;
}
if (dwMode == SCE_MODE_RSOP_COMPUTER)
{
m_ModeBits |= MB_SINGLE_TEMPLATE_ONLY |
MB_NO_TEMPLATE_VERBS |
MB_WRITE_THROUGH;
}
if (dwMode == SCE_MODE_RSOP_COMPUTER ||
dwMode == SCE_MODE_RSOP_USER)
{
m_ModeBits |= MB_READ_ONLY |
MB_RSOP;
}
if (SCE_MODE_LOCAL_COMPUTER == dwMode)
{
m_ModeBits |= MB_LOCAL_POLICY |
MB_LOCALSEC |
MB_NO_TEMPLATE_VERBS |
MB_SINGLE_TEMPLATE_ONLY |
MB_WRITE_THROUGH;
if (!IsAdmin()) {
m_ModeBits |= MB_READ_ONLY;
}
if (IsDomainController())
{
m_ModeBits |= MB_DS_OBJECTS_SECTION;
}
}
if ( dwMode == SCE_MODE_EDITOR )
{
m_ModeBits |= MB_TEMPLATE_EDITOR;
m_ModeBits |= MB_DS_OBJECTS_SECTION;
}
else if ( dwMode == SCE_MODE_VIEWER )
{
m_ModeBits |= MB_ANALYSIS_VIEWER;
if (IsDomainController())
{
m_ModeBits |= MB_DS_OBJECTS_SECTION;
}
}
else if (dwMode == SCE_MODE_LOCALSEC)
{
m_ModeBits |= MB_LOCALSEC;
if (!IsAdmin())
{
m_ModeBits |= MB_READ_ONLY;
}
if (IsDomainController())
{
m_ModeBits |= MB_DS_OBJECTS_SECTION;
}
}
return TRUE;
}
//+--------------------------------------------------------------------------
//
// Method: Create
//
// Synopsis: Initialize a CFolder Object
//
//
// Arguments: [szName] - The folder's display name
// [szDesc] - The folder's discription
// [infName] - The inf file associated with the folder (optional)
// [nImage] - The folder's closed icon index
// [nOpenImage] - the folder's open icon index
// [type] - The folder' type
// [bHasChildren] - True if the folder has children folders
// [dwMode] - The Mode the folder operates under
// [pData] - Extra data to associate with the folder
//
//
// History:
//
//---------------------------------------------------------------------------
HRESULT CFolder::Create(LPCTSTR szName, // Name
LPCTSTR szDesc, // Description
LPCTSTR infName, // inf file name
int nImage, // closed icon index
int nOpenImage, // open icon index
FOLDER_TYPES type, // folder type
BOOL bHasChildren, // has children
DWORD dwMode, // mode
PVOID pData) // data
{
UINT uiByteLen = 0;
LPOLESTR psz = 0;
HRESULT hr = S_OK;
ASSERT(m_pScopeItem == NULL); // Calling create twice on this item?
CString str;
//
// Two-stage construction
//
m_pScopeItem = new SCOPEDATAITEM;
if (!m_pScopeItem)
return E_OUTOFMEMORY;
ZeroMemory(m_pScopeItem,sizeof(m_pScopeItem));
//
// Set folder type
//
m_type = type;
//
// Add node name
//
if (szName != NULL || szDesc != NULL )
{
m_pScopeItem->mask = SDI_STR;
//
// Displayname is a callback (unsigned short*)(-1)
m_pScopeItem->displayname = MMC_CALLBACK;
}
if ( szName != NULL )
{
uiByteLen = (lstrlen(szName) + 1) * sizeof(OLECHAR);
psz = (LPOLESTR)::CoTaskMemAlloc(uiByteLen);
if (psz != NULL)
lstrcpy(psz, szName);
else
hr = E_OUTOFMEMORY;
CoTaskMemFree(m_pszName);
m_pszName = psz;
}
if (szDesc != NULL)
{
uiByteLen = (lstrlen(szDesc) + 1) * sizeof(OLECHAR);
psz = (LPOLESTR)::CoTaskMemAlloc(uiByteLen);
if (psz != NULL)
lstrcpy(psz, szDesc);
else
hr = E_OUTOFMEMORY;
CoTaskMemFree(m_pszDesc);
m_pszDesc = psz;
}
if (infName != NULL)
{
uiByteLen = (lstrlen(infName) + 1) * sizeof(OLECHAR);
psz = (LPOLESTR)::CoTaskMemAlloc(uiByteLen);
if (psz != NULL)
lstrcpy(psz, infName);
else
hr = E_OUTOFMEMORY;
CoTaskMemFree(m_infName);
m_infName = psz;
}
//
// Add close image
//
m_pScopeItem->mask |= SDI_IMAGE; // no close image for now
// m_pScopeItem->nImage = (int)MMC_CALLBACK;
m_pScopeItem->nImage = nImage;
//
// Add open image
//
if (nOpenImage != -1)
{
m_pScopeItem->mask |= SDI_OPENIMAGE;
m_pScopeItem->nOpenImage = nOpenImage;
}
//
// Add button to node if the folder has children
//
if (bHasChildren == TRUE)
{
m_pScopeItem->mask |= SDI_CHILDREN;
//
// The number of children doesn't make any difference now,
// so pick 1 until the node is expanded and the true value
// is known
//
m_pScopeItem->cChildren = 1;
}
//
// Set the SCE Mode and calculate the mode bits
//
if (dwMode)
SetMode(dwMode);
m_pData = pData;
return hr;
}
//+------------------------------------------------------------------------------------------------
// CFolder::SetDesc
//
// Translate dwStatus and dwNumChildren to a string and sets m_szDesc
//
// Argumens: [dwStats] - Object status.
// [dwNumChildren] - Number of children for the object.
//
// Returns: TRUE - If successful
// FALSE - If no more memory is available (or dwStatus is greater then 999)
//-------------------------------------------------------------------------------------------------
BOOL CFolder::SetDesc( DWORD dwStatus, DWORD dwNumChildren )
{
if(dwStatus > 999)
return FALSE;
TCHAR szText[256];
swprintf(szText, L"%03d%d", dwStatus, dwNumChildren);
SetDesc(szText);
return TRUE;
}
//+------------------------------------------------------------------------------------------------
// CFolder::GetObjectInfo
//
// Translate m_szDesc into dwStatus and dwNumChildren
//
// Argumens: [pdwStats] - Object status.
// [pdwNumChildren] - Number of children for the object.
//
// Returns: TRUE - If successful
// FALSE - m_szDesc is NULL
//-------------------------------------------------------------------------------------------------
BOOL CFolder::GetObjectInfo( DWORD *pdwStatus, DWORD *pdwNumChildren )
{
if(!m_pszDesc)
return FALSE;
if( lstrlen(m_pszDesc) < 4)
return FALSE;
if(pdwStatus )
*pdwStatus = (m_pszDesc[0]-L'0')*100 + (m_pszDesc[1]-L'0')*10+ (m_pszDesc[2]-L'0');
if(pdwNumChildren)
*pdwNumChildren = _wtol( m_pszDesc + 3 );
return TRUE;
}
/*--------------------------------------------------------------------------------------------------
Method: GetResultItemHandle()
Synopisi: This function must be called to retreive a valid handle to this folders result items.
The handle must be freed by a call to ReleaseResultItemHandle(). If these two functions
are not called in conjunction. The behavior fo the result items will be strange.
Arguments: [handle] - [out] The handle value to use for any other functions that require a
handle.
Returns: ERROR_SUCCESS - A valid result item was returned
ERROR_INVALID_PARAMETER - [handle] is NULL
--------------------------------------------------------------------------------------------------*/
DWORD CFolder::GetResultItemHandle(
HANDLE *handle)
{
if(!handle)
return ERROR_INVALID_PARAMETER;
m_iRefCount++;
*handle = (HANDLE)&m_resultItemList;
return ERROR_SUCCESS;
}
/*--------------------------------------------------------------------------------------------------
Method: GetResultItem()
Synopisi: Returns the result item pointed to by position and sets [pos] to the next item.
Arguments: [handle] - [in] A valid handle returns by GetResultItemHandle()
[pos] - [in|out] The position of the result. If this value is NULL, the first result
item in the list is returned.
[pResult] - [out] A pointer to a result item pointer
Returns: ERROR_SUCCESS - A result item was found for the position.
ERROR_INVALID_PARAMETER - [handle] is invalid, or [pResult] is NULL
--------------------------------------------------------------------------------------------------*/
DWORD CFolder::GetResultItem(
HANDLE handle,
POSITION &pos,
CResult **pResult)
{
if(!handle || handle != (HANDLE)&m_resultItemList || !pResult)
return ERROR_INVALID_PARAMETER;
if(!pos)
{
pos = m_resultItemList.GetHeadPosition();
if(!pos)
{
*pResult = NULL;
return ERROR_SUCCESS;
}
}
*pResult = m_resultItemList.GetNext(pos);
return ERROR_SUCCESS;
}
/*--------------------------------------------------------------------------------------------------
Method: GetResultItemPosition()
Synopisi: Returns the position of the result item in the result item list for this folder item.
Arguments: [handle] - A valid handle returns by GetResultItemHandle()
[pResult] - The retult item position to return.
Returns: NULL - Invalid handle or the result item is not part of this folder.
POSITION - A valid position value that can be used in other calls that require the
position of the result item.
--------------------------------------------------------------------------------------------------*/
POSITION CFolder::GetResultItemPosition(
HANDLE handle,
CResult *pResult)
{
if(handle != (HANDLE)&m_resultItemList)
return NULL;
POSITION pos = m_resultItemList.GetHeadPosition();
while(pos)
{
if(pResult == m_resultItemList.GetNext(pos))
break;
}
return pos;
}
/*--------------------------------------------------------------------------------------------------
Method: RemoveAllResultItems()
Synopisi: Removes all result items from the list. This call sets the ref count to 0 so it could
be a very damaging call.
--------------------------------------------------------------------------------------------------*/
void CFolder::RemoveAllResultItems()
{
//
// Very Very dangerous call.
//
m_iRefCount = 1;
HANDLE handle = (HANDLE)&m_resultItemList;
ReleaseResultItemHandle (handle);
}
DWORD CFolder::GetDisplayName( CString &str, int iCol )
{
int npos;
DWORD dwRet = ERROR_INVALID_PARAMETER;
if(!iCol)
{
str = GetName();
dwRet = ERROR_SUCCESS;
}
switch(m_type)
{
case PROFILE:
case REG_OBJECTS:
if(!iCol)
{
npos = str.ReverseFind(L'\\');
str = GetName() + npos + 1;
dwRet = ERROR_SUCCESS;
}
break;
case FILE_OBJECTS:
if (0 == iCol)
{
npos = str.ReverseFind(L'\\');
if (str.GetLength() > npos + 1)
{
str=GetName() + npos + 1;
}
dwRet = ERROR_SUCCESS;
}
break;
case STATIC:
if(iCol == 2)
{
str = GetDesc();
dwRet = ERROR_SUCCESS;
}
break;
}
if(dwRet != ERROR_SUCCESS)
{
if( ((m_type >= ANALYSIS && m_type <=AREA_FILESTORE_ANALYSIS) ||
(m_type >= LOCALPOL_ACCOUNT && m_type <= LOCALPOL_LAST))
&& iCol == 1)
{
str = GetDesc();
dwRet = ERROR_SUCCESS;
}
else if(iCol <= 3 && GetDesc() != NULL)
{
LPTSTR szDesc = GetDesc();
switch(iCol)
{
case 1:
// first 3 digits of m_pszDesc
dwRet = 0;
GetObjectInfo( &dwRet, NULL );
ObjectStatusToString(dwRet, &str);
dwRet = ERROR_SUCCESS;
break;
case 2:
// first 2 digits of m_pszDesc
dwRet = 0;
GetObjectInfo( &dwRet, NULL );
dwRet &= (~SCE_STATUS_PERMISSION_MISMATCH | 0x0F);
ObjectStatusToString(dwRet, &str);
dwRet = ERROR_SUCCESS;
break;
case 3:
str = szDesc+3;
dwRet = ERROR_SUCCESS;
break;
default:
break;
}
}
}
return dwRet;
}
/*--------------------------------------------------------------------------------------------------
Method: AddResultItem()
Synopisi: Adds a result item to the list.
Arguments: [handle] - [in] A handle returned by GetResultItemHandle().
[pResult] - [in] The result item to add.
Returns: ERROR_SUCCESS - The result item was added.
ERROR_INVALID_PARAMETER - [handle] is invalid, or pResult is NULL.
--------------------------------------------------------------------------------------------------*/
DWORD CFolder::AddResultItem(
HANDLE handle,
CResult *pResult)
{
if(!pResult || handle != (HANDLE)&m_resultItemList)
return ERROR_INVALID_PARAMETER;
m_resultItemList.AddHead(pResult);
return ERROR_SUCCESS;
}
/*--------------------------------------------------------------------------------------------------
Method: RemoveResultItem()
Synopisi: Removes a result item from the list..
Arguments: [handle] - [in] A handle returned by GetResultItemHandle().
[pResult] - [in] The result item to remove.
Returns: ERROR_SUCCESS - The item was removed
ERROR_INVALID_PARAMETER - [handle] is invalid, or pResult is NULL.
ERROR_RESOURCE_NOT_FOUND - The result item does not exist withen this folder.
--------------------------------------------------------------------------------------------------*/
DWORD CFolder::RemoveResultItem (
HANDLE handle,
CResult *pItem)
{
if(!pItem || handle != (HANDLE)&m_resultItemList)
return ERROR_INVALID_PARAMETER;
POSITION posCur;
POSITION pos = m_resultItemList.GetHeadPosition();
while(pos)
{
posCur = pos;
if ( m_resultItemList.GetNext(pos) == pItem )
{
m_resultItemList.RemoveAt(posCur);
return ERROR_SUCCESS;
}
}
return ERROR_RESOURCE_NOT_FOUND;
}
/*--------------------------------------------------------------------------------------------------
Method: ReleaseResultItemHandle()
Synopisi: Release associated data with the handle. If the ref count goes to zero then
all result items are removed from the list.
Arguments: [handle] - [in] A handle returned by GetResultItemHandle().
Returns: ERROR_SUCCESS - The function succeded
ERROR_INVALID_PARAMETER - [handle] is invalid.
--------------------------------------------------------------------------------------------------*/
DWORD CFolder::ReleaseResultItemHandle(
HANDLE &handle)
{
if(handle != (HANDLE)&m_resultItemList)
return ERROR_INVALID_PARAMETER;
if( !m_iRefCount )
return ERROR_SUCCESS;
m_iRefCount--;
if(!m_iRefCount)
{
while (!m_resultItemList.IsEmpty () )
{
CResult* pResult = m_resultItemList.RemoveHead ();
if ( pResult )
pResult->Release ();
}
}
handle = NULL;
return ERROR_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
// CResult
//
//+--------------------------------------------------------------------------
//
// Method: Create
//
// Synopsis: Initialize a CResult Object
//
//
// Arguments: [szAttr] - The result item's display name
// [dwBase] - The item's template setting
// [dwSetting] - The item's last inspected setting
// [type] - The type of the item's setting
// [status] - The matched status of the item
// [cookie] - The MMC cookie for this item
// [szUnits] - The units this item's setting is measured in
// [nID] - An identifier for the item, dependant on the type
// [pBaseInfo] - The template object this item belongs to
// [pDataObj] - The data object of the scope pane this item belongs to
// [pNotify] - Object to pass notifications through
// History:
//
//---------------------------------------------------------------------------
HRESULT CResult::Create(LPCTSTR szAttr, // attribute's display name
LONG_PTR dwBase, // template setting
LONG_PTR dwSetting, // last inspected setting
RESULT_TYPES type, // type of the item's setting
int status, // matched status of the item
MMC_COOKIE cookie, // the MMC cookie for this item
LPCTSTR szUnits, // units the setting is measured in
LONG_PTR nID, // An identifier for the item, dependant on the type
PEDITTEMPLATE pBaseInfo, // The template object this item belongs to
LPDATAOBJECT pDataObj, // The data object of the scope pane this item belongs to
LPNOTIFY pNotify, // Notification object
CSnapin *pSnapin) // Snapin window which owns this object
{
HRESULT hr = S_OK;
m_type = type;
m_status = status;
m_cookie = cookie;
m_dwBase = dwBase;
m_dwSetting = dwSetting;
m_nID = nID;
m_profBase = pBaseInfo;
//m_pDataObj = pDataObj;
m_pNotify = pNotify;
m_pSnapin = pSnapin;
UINT uiByteLen = 0;
LPTSTR psz = 0;
if ( szAttr != NULL )
{
uiByteLen = (lstrlen(szAttr) + 1);
psz = new TCHAR[uiByteLen];
if (psz != NULL)
{
lstrcpy(psz, szAttr);
}
else
{
hr = E_OUTOFMEMORY;
}
if (m_szAttr)
{
delete [] m_szAttr;
}
m_szAttr = psz;
}
if ( szUnits != NULL )
{
SetUnits( szUnits );
if(!m_szUnits){
hr = E_OUTOFMEMORY;
}
}
return hr;
}
void CResult::SetUnits(
LPCTSTR sz)
{
if (ITEM_GROUP == GetType())
{
//
// we shouldn't be storing this in a string storage
// This isn't actually a string and shouldn't be copied. Yuck.
//
m_szUnits = (LPTSTR)sz;
}
else
{
if(m_szUnits)
{
LocalFree(m_szUnits);
}
m_szUnits = NULL;
if(sz)
{
int iLen = lstrlen(sz);
m_szUnits = (LPTSTR) LocalAlloc(0, (iLen + 1) * sizeof(TCHAR));
if(!m_szUnits)
return;
lstrcpy(m_szUnits, sz);
}
}
}
//+--------------------------------------------------------------------------
//
// Method: Update
//
// Synopsis: Updates a changed result item and broadcasts
// that change appropriately
//
// History:
//
//---------------------------------------------------------------------------
void CResult::Update(CSnapin *pSnapin, BOOL bEntirePane)
{
LPARAM hint = 0;
//
// Set the appropriate template section as needing to be saved
//
if (m_profBase)
{
//
// m_profBase will only be set for Configuation templates.
// It will not be set for Analysis items
//
if (m_cookie && ((CFolder *)m_cookie)->GetType() < AREA_POLICY_ANALYSIS )
{
switch ( ((CFolder *)m_cookie)->GetType())
{
case POLICY_ACCOUNT:
case POLICY_LOCAL:
case POLICY_EVENTLOG:
case POLICY_PASSWORD:
case POLICY_KERBEROS:
case POLICY_LOCKOUT:
case POLICY_AUDIT:
case POLICY_OTHER:
case POLICY_LOG:
m_profBase->SetDirty(AREA_SECURITY_POLICY);
break;
case AREA_PRIVILEGE:
m_profBase->SetDirty(AREA_PRIVILEGES);
break;
case AREA_GROUPS:
m_profBase->SetDirty(AREA_GROUP_MEMBERSHIP);
break;
case AREA_SERVICE:
m_profBase->SetDirty(AREA_SYSTEM_SERVICE);
break;
case AREA_REGISTRY:
m_profBase->SetDirty(AREA_REGISTRY_SECURITY);
break;
case AREA_FILESTORE:
m_profBase->SetDirty(AREA_FILE_SECURITY);
break;
}
}
}
//
// Query the snap in data.
//
LPDATAOBJECT pDataObj;
if( pSnapin->QueryDataObject( m_cookie, CCT_RESULT, &pDataObj ) != S_OK){
return;
}
if(!m_pNotify){
return;
}
//
// Update all views.
//
if(bEntirePane)
{
if(!pSnapin->GetSelectedFolder())
{
return;
}
if( pDataObj && m_pNotify ) //Raid #357968, #354861, 4/25/2001
{
LPNOTIFY pNotify = m_pNotify;
pSnapin->GetSelectedFolder()->RemoveAllResultItems();
pNotify->UpdateAllViews(
pDataObj,
(LPARAM)pSnapin->GetSelectedFolder(),
UAV_RESULTITEM_UPDATEALL
);
}
}
else
{
if (pDataObj && m_pNotify)
{
m_pNotify->UpdateAllViews(
pDataObj,
NULL,
pSnapin->GetSelectedFolder(),
this,
UAV_RESULTITEM_UPDATE
);
pDataObj->Release();
}
}
}
//+--------------------------------------------------------------------------
//
// Method: GetAttrPretty
//
// Synopsis: Get the Attribute's display name as it should be displayed
// in the result pane
//
// History:
//
//---------------------------------------------------------------------------
LPCTSTR CResult::GetAttrPretty()
{
return GetAttr();
}
//+--------------------------------------------------------------------------
//
// Method: CResult::GetStatusErrorString
//
// Synopsis: This function caclulates the error status string to display
// for the CResult item. In LPO mode it always returns
// IDS_NOT_DEFINED, and for MB_TEMPLATE_EDITOR mode it always
// Loads IDS_NOT_CONFIGURED
//
// Arguments: [pStr] - [Optional] CString object to load resource with.
//
// Returns: The resource ID to load. else zero if the error is not
// defined.
//
// History: a-mthoge 11/17/1998
//
//---------------------------------------------------------------------------
DWORD CResult::GetStatusErrorString( CString *pStr )
{
DWORD nRes = 0;
if( m_cookie )
{
if( ((CFolder *)m_cookie)->GetModeBits() & MB_LOCALSEC )
{
if (GetType() ==ITEM_LOCALPOL_REGVALUE)
{
nRes = IDS_NOT_DEFINED;
}
else
{
nRes = IDS_NOT_APPLICABLE;
}
}
else if ( ((CFolder *)m_cookie)->GetModeBits() & MB_RSOP )
{
nRes = IDS_NO_POLICY;
}
else if (((CFolder *)m_cookie)->GetModeBits() & MB_ANALYSIS_VIEWER)
{
nRes = IDS_NOT_ANALYZED;
}
else if( ((CFolder *)m_cookie)->GetModeBits() & (MB_TEMPLATE_EDITOR | MB_SINGLE_TEMPLATE_ONLY) )
{
nRes = IDS_NOT_CONFIGURED;
}
}
if(!nRes)
{
nRes = GetStatus();
if(!nRes)
{
nRes = GetStatus();
}
nRes = ObjectStatusToString( nRes, pStr );
}
else if(pStr)
{
pStr->LoadString( nRes );
}
return nRes;
}
LPCTSTR CResult::GetSourceGPOString()
{
// ASSERT(pFolder->GetModeBits() & RSOP);
vector<PPRECEDENCEDISPLAY>* vppd = GetPrecedenceDisplays();
if (vppd && !vppd->empty())
{
PPRECEDENCEDISPLAY ppd = vppd->front();
return ppd->m_szGPO;
}
return NULL;
}
//+--------------------------------------------------------------------------
//
// Method: CResult::GetDisplayName
//
// Synopsis: Gets the display name for the result item.
//
// Arguments: [pFolder] - [Optional] If this parameter is NULL, m_Cookie
// is used as the CFolder object.
// [str] - [out] On exit this function will contain the
// string to display.
// [iCol] - [in] The column you want to retrieve the string
// for.
//
// Returns: ERROR_SUCCESS - [str] is a valid string for the column.
//
// History: a-mthoge 11/17/1998
//
//---------------------------------------------------------------------------
DWORD
CResult::GetDisplayName(
CFolder *pFolder,
CString &str,
int iCol
)
{
DWORD dwRet = ERROR_INVALID_PARAMETER;
//
// If pFolder is not passed in then use the cookie as the CFolder
// object.
//
if ( pFolder )
{
// bogus assertion?
// ASSERT(pFolder != (CFolder *)GetCookie());
} else {
pFolder = (CFolder *)GetCookie();
}
LPTSTR pszAlloc = NULL;
int npos = 0;
if (iCol == 0) {
//
// First column strings.
//
str = GetAttr();
if (pFolder &&
(pFolder->GetType() < AREA_POLICY || pFolder->GetType() > REG_OBJECTS) ) {
//
// SCE Object strings
//
npos = str.ReverseFind(L'\\');
} else {
npos = 0;
}
//
// All other strings.
//
if ( npos > 0 ) {
str = GetAttr() + npos + 1;
}
return ERROR_SUCCESS;
}
if ( pFolder ) {
//
// Items that are defined by the folder type.
//
if ((pFolder->GetType() == AREA_REGISTRY ||
pFolder->GetType() == AREA_FILESTORE) &&
((pFolder->GetModeBits() & MB_RSOP) == MB_RSOP) &&
iCol == 1) {
str = GetSourceGPOString();
}
switch (pFolder->GetType()) {
case AREA_REGISTRY:
case AREA_FILESTORE:
//
// profile objects area
//
switch (GetStatus()) {
case SCE_STATUS_IGNORE:
str.LoadString(IDS_OBJECT_IGNORE);
break;
case SCE_STATUS_OVERWRITE:
str.LoadString(IDS_OBJECT_OVERWRITE);
break;
}
dwRet = ERROR_SUCCESS;
break;
}
if ( pFolder->GetType() >= AREA_REGISTRY_ANALYSIS && pFolder->GetType() < AREA_LOCALPOL ) {
switch ( iCol ) {
case 1:
// permission status
dwRet = GetStatus() & (~SCE_STATUS_AUDIT_MISMATCH | 0x0F);
ObjectStatusToString(dwRet, &str);
break;
case 2:
// auditing status
dwRet = GetStatus() & (~SCE_STATUS_PERMISSION_MISMATCH | 0x0F);
ObjectStatusToString(dwRet, &str);
break;
default:
str = TEXT("0");
break;
}
dwRet = ERROR_SUCCESS;
}
if (dwRet == ERROR_SUCCESS) {
return dwRet;
}
}
//
// Items determined by result type.
//
switch ( GetType () ) {
case ITEM_PROF_GROUP:
if ( GetID() ) {
//
// Group member ship strings.
//
PSCE_GROUP_MEMBERSHIP pgm;
pgm = (PSCE_GROUP_MEMBERSHIP)( GetID() );
if ( iCol == 1) {
//
// Members string.
//
ConvertNameListToString(pgm->pMembers, &pszAlloc);
} else if (iCol == 2){
//
// Members of string.
//
ConvertNameListToString(pgm->pMemberOf, &pszAlloc);
} else if (iCol == 3) {
ASSERT(m_pSnapin->GetModeBits() & MB_RSOP);
str = GetSourceGPOString();
} else {
ASSERT(0 && "Illegal column");
}
if (pszAlloc) {
str = pszAlloc;
delete [] pszAlloc;
}
}
dwRet = ERROR_SUCCESS;
break;
case ITEM_GROUP:
if ( GetID() ) {
PSCE_GROUP_MEMBERSHIP pgm;
pgm = (PSCE_GROUP_MEMBERSHIP)(GetID());
if (iCol == 1) {
TranslateSettingToString(
GetGroupStatus( pgm->Status, STATUS_GROUP_MEMBERS ),
NULL,
GetType(),
&pszAlloc
);
} else if (iCol == 2) {
TranslateSettingToString(
GetGroupStatus(pgm->Status, STATUS_GROUP_MEMBEROF),
NULL,
GetType(),
&pszAlloc
);
} else {
ASSERT(0 && "Illegal column");
}
//
// Test to see if the result item already has a string, if it does then
// we will delete the old string.
//
if (pszAlloc) {
str = pszAlloc;
delete [] pszAlloc;
}
}
dwRet = ERROR_SUCCESS;
break;
case ITEM_PROF_REGVALUE:
if (iCol == 2 && (m_pSnapin->GetModeBits() & MB_RSOP) == MB_RSOP) {
str = GetSourceGPOString();
break;
}
case ITEM_REGVALUE:
case ITEM_LOCALPOL_REGVALUE:
{
PSCE_REGISTRY_VALUE_INFO prv = NULL;
if (iCol == 1) {
prv = (PSCE_REGISTRY_VALUE_INFO)(GetBase());
} else if (iCol == 2) {
prv = (PSCE_REGISTRY_VALUE_INFO)(GetSetting());
} else {
ASSERT(0 && "Illegal column");
}
if ( prv ) {
if ( iCol > 1 && !(prv->Value)) {
//
// Determine status fron analysis.
//
GetStatusErrorString( &str );
dwRet = ERROR_SUCCESS;
break;
}
//
// Determine string by the item value.
//
if ( dwRet != ERROR_SUCCESS ) {
pszAlloc = NULL;
switch ( GetID() ) {
case SCE_REG_DISPLAY_NUMBER:
if ( prv->Value ) {
TranslateSettingToString(
_wtol(prv->Value),
GetUnits(),
ITEM_DW,
&pszAlloc
);
}
break;
case SCE_REG_DISPLAY_CHOICE:
if ( prv->Value ) {
TranslateSettingToString(_wtol(prv->Value),
NULL,
ITEM_REGCHOICE,
&pszAlloc);
}
break;
case SCE_REG_DISPLAY_FLAGS:
if ( prv->Value ) {
TranslateSettingToString(_wtol(prv->Value),
NULL,
ITEM_REGFLAGS,
&pszAlloc);
if( pszAlloc == NULL ) //Raid #286697, 4/4/2001
{
str.LoadString(IDS_NO_MIN);
dwRet = ERROR_SUCCESS;
}
}
break;
case SCE_REG_DISPLAY_MULTISZ:
case SCE_REG_DISPLAY_STRING:
if (prv && prv->Value) {
str = prv->Value;
dwRet = ERROR_SUCCESS;
}
break;
default: // boolean
if ( prv->Value ) {
long val;
val = _wtol(prv->Value);
TranslateSettingToString( val,
NULL,
ITEM_BOOL,
&pszAlloc
);
}
break;
}
}
if (dwRet != ERROR_SUCCESS) {
if ( pszAlloc ) {
str = pszAlloc;
delete [] pszAlloc;
} else {
GetStatusErrorString(&str);
}
}
}
dwRet = ERROR_SUCCESS;
}
break;
}
if (dwRet != ERROR_SUCCESS) {
//
// Other areas.
//
if (iCol == 1) {
if( GetBase() == (LONG_PTR)ULongToPtr(SCE_NO_VALUE)){
if( m_pSnapin->GetModeBits() & MB_LOCALSEC){
str.LoadString(IDS_NOT_APPLICABLE);
} else {
str.LoadString(IDS_NOT_CONFIGURED);
}
} else {
//
// Edit template
//
GetBase(pszAlloc);
}
} else if (iCol == 2) {
if ((m_pSnapin->GetModeBits() & MB_RSOP) == MB_RSOP) {
//
// RSOP Mode
//
str = GetSourceGPOString();
} else {
//
// Analysis Template.
//
GetSetting(pszAlloc);
}
} else {
ASSERT(0 && "Illegal column");
}
if (pszAlloc) {
str = pszAlloc;
delete [] pszAlloc;
}
dwRet = ERROR_SUCCESS;
}
return dwRet;
}
//+--------------------------------------------------------------------------
//
// Function: TranslateSettingToString
//
// Synopsis: Convert a result pane setting into a string
//
// Arguments: [setting] - [in] The value to be converted
// [unit] - [in, optiona] The string for the units to use
// [type] - [in] The type of the setting to be converted
// [LPTSTR] - [in|out] the address to store the string at
//
// Returns: *[LPTSTR] - the translated string
//
//---------------------------------------------------------------------------
void CResult::TranslateSettingToString(LONG_PTR setting,
LPCTSTR unit,
RESULT_TYPES type,
LPTSTR* pTmpstr)
{
DWORD nRes = 0;
if (!pTmpstr)
{
ASSERT(pTmpstr);
return;
}
*pTmpstr = NULL;
switch ( setting )
{
case SCE_KERBEROS_OFF_VALUE:
nRes = IDS_OFF;
break;
case SCE_FOREVER_VALUE:
nRes = IDS_FOREVER;
break;
case SCE_ERROR_VALUE:
nRes = IDS_ERROR_VALUE;
break;
case SCE_NO_VALUE:
nRes = GetStatusErrorString( NULL );
break;
case SCE_NOT_ANALYZED_VALUE:
nRes = GetStatusErrorString( NULL );
break;
default:
switch ( type )
{
case ITEM_SZ:
case ITEM_PROF_SZ:
case ITEM_LOCALPOL_SZ:
if (setting && setting != (LONG_PTR)ULongToPtr(SCE_NO_VALUE))
{
*pTmpstr = new TCHAR[lstrlen((LPTSTR)setting)+1];
if (*pTmpstr)
wcscpy(*pTmpstr,(LPTSTR)setting);
}
else
nRes = GetStatusErrorString(NULL);
break;
case ITEM_PROF_BOOL:
case ITEM_LOCALPOL_BOOL:
case ITEM_BOOL:
if ( setting )
nRes = IDS_ENABLED;
else
nRes = IDS_DISABLED;
break;
case ITEM_PROF_BON:
case ITEM_LOCALPOL_BON:
case ITEM_BON:
if ( setting )
nRes = IDS_ON;
else
nRes = IDS_OFF;
break;
case ITEM_PROF_B2ON:
case ITEM_LOCALPOL_B2ON:
case ITEM_B2ON:
{
CString strAudit;
CString strFailure;
if ( setting & AUDIT_SUCCESS )
strAudit.LoadString(IDS_SUCCESS);
if ( setting & AUDIT_FAILURE )
{
if (setting & AUDIT_SUCCESS)
strAudit += TEXT(", ");
strFailure.LoadString(IDS_FAILURE);
strAudit += strFailure;
}
if (strAudit.IsEmpty())
strAudit.LoadString(IDS_DO_NOT_AUDIT);
*pTmpstr = new TCHAR [ strAudit.GetLength()+1 ];
if (*pTmpstr)
wcscpy(*pTmpstr, (LPCTSTR) strAudit);
}
break;
case ITEM_PROF_RET:
case ITEM_LOCALPOL_RET:
case ITEM_RET:
switch(setting)
{
case SCE_RETAIN_BY_DAYS:
nRes = IDS_BY_DAYS;
break;
case SCE_RETAIN_AS_NEEDED:
nRes = IDS_AS_NEEDED;
break;
case SCE_RETAIN_MANUALLY:
nRes = IDS_MANUALLY;
break;
default:
break;
}
break;
case ITEM_PROF_REGCHOICE:
case ITEM_REGCHOICE:
{
PREGCHOICE pRegChoice = m_pRegChoices;
while(pRegChoice)
{
if (pRegChoice->dwValue == (DWORD)setting)
{
*pTmpstr = new TCHAR[lstrlen(pRegChoice->szName)+1];
if (*pTmpstr)
wcscpy(*pTmpstr, (LPCTSTR) pRegChoice->szName);
break;
}
pRegChoice = pRegChoice->pNext;
}
break;
}
case ITEM_REGFLAGS:
{
TCHAR *pStr = NULL;
PREGFLAGS pRegFlags = m_pRegFlags;
while(pRegFlags)
{
if ((pRegFlags->dwValue & (DWORD) setting) == pRegFlags->dwValue)
{
pStr = *pTmpstr;
*pTmpstr = new TCHAR[(pStr?lstrlen(pStr):0)+lstrlen(pRegFlags->szName)+2];
if (*pTmpstr)
{
if (pStr)
{
lstrcpy(*pTmpstr, (LPCTSTR) pStr);
lstrcat(*pTmpstr,L",");
lstrcat(*pTmpstr, pRegFlags->szName);
}
else
lstrcpy(*pTmpstr, pRegFlags->szName);
}
if (pStr)
delete [] pStr;
}
pRegFlags = pRegFlags->pNext;
}
break;
}
case ITEM_PROF_GROUP:
case ITEM_PROF_PRIVS:
if (NULL != setting && (LONG_PTR)ULongToPtr(SCE_NO_VALUE) != setting )
ConvertNameListToString((PSCE_NAME_LIST) setting,pTmpstr);
break;
case ITEM_LOCALPOL_PRIVS:
if (NULL != setting && (LONG_PTR)ULongToPtr(SCE_NO_VALUE) != setting )
ConvertNameListToString(((PSCE_PRIVILEGE_ASSIGNMENT) setting)->AssignedTo,pTmpstr);
break;
case ITEM_PRIVS:
if (NULL != setting && (LONG_PTR)ULongToPtr(SCE_NO_VALUE) != setting )
ConvertNameListToString(((PSCE_PRIVILEGE_ASSIGNMENT) setting)->AssignedTo,pTmpstr);
else
nRes = GetStatusErrorString(NULL);
break;
case ITEM_GROUP:
//nRes = GetStatusErrorString(NULL);
nRes = ObjectStatusToString((DWORD) setting, NULL);
if ( setting == MY__SCE_MEMBEROF_NOT_APPLICABLE )
nRes = IDS_NOT_APPLICABLE;
break;
case ITEM_PROF_DW:
case ITEM_LOCALPOL_DW:
case ITEM_DW:
nRes = 0;
if ( unit )
{
*pTmpstr = new TCHAR[wcslen(unit)+20];
if (*pTmpstr)
swprintf(*pTmpstr, L"%d %s", setting, unit);
}
else
{
*pTmpstr = new TCHAR[20];
if (*pTmpstr)
swprintf(*pTmpstr, L"%d", setting);
}
break;
default:
*pTmpstr = NULL;
break;
}
break;
}
if (nRes)
{
CString strRes;
if (strRes.LoadString(nRes))
{
*pTmpstr = new TCHAR[strRes.GetLength()+1];
if (*pTmpstr)
wcscpy(*pTmpstr, (LPCTSTR) strRes);
else
{
//
// Couldn't allocate string so display will be blank.
//
}
}
else
{
//
// Couldn't load string so display will be blank.
//
}
}
}
//+--------------------------------------------------------------------------
//
// Function: GetProfileDefault()
//
// Synopsis: Find the default values for undefined policies
//
// Returns: The value to assign as the default value for the policy.
//
// SCE_NO_VALUE is returned on error.
//
//+--------------------------------------------------------------------------
DWORD_PTR
CResult::GetProfileDefault() {
PEDITTEMPLATE pet = NULL;
SCE_PROFILE_INFO *pspi = NULL;
if (!m_pSnapin) {
return (DWORD_PTR)ULongToPtr(SCE_NO_VALUE);
}
pet = m_pSnapin->GetTemplate(GT_DEFAULT_TEMPLATE);
if (pet && pet->pTemplate) {
pspi = pet->pTemplate;
}
#define PROFILE_DEFAULT(X,Y) ((pspi && (pspi->X != SCE_NO_VALUE)) ? pspi->X : Y)
#define PROFILE_KERB_DEFAULT(X,Y) ((pspi && pspi->pKerberosInfo && (pspi->pKerberosInfo->X != SCE_NO_VALUE)) ? pspi->pKerberosInfo->X : Y)
switch (m_nID) {
// L"Maximum passage age", L"Days"
case IDS_MAX_PAS_AGE:
return PROFILE_DEFAULT(MaximumPasswordAge,42);
// L"Minimum passage age", L"Days"
case IDS_MIN_PAS_AGE:
return PROFILE_DEFAULT(MinimumPasswordAge,0);
// L"Minimum passage length", L"Characters"
case IDS_MIN_PAS_LEN:
return PROFILE_DEFAULT(MinimumPasswordLength,0);
// L"Password history size", L"Passwords"
case IDS_PAS_UNIQUENESS:
return PROFILE_DEFAULT(PasswordHistorySize,0);
// L"Password complexity", L""
case IDS_PAS_COMPLEX:
return PROFILE_DEFAULT(PasswordComplexity,0);
// L"Clear Text Password", L""
case IDS_CLEAR_PASSWORD:
return PROFILE_DEFAULT(ClearTextPassword,0);
// L"Require logon to change password", L""
case IDS_REQ_LOGON:
return PROFILE_DEFAULT(RequireLogonToChangePassword,0);
case IDS_KERBEROS_MAX_SERVICE:
return PROFILE_KERB_DEFAULT(MaxServiceAge,600);
case IDS_KERBEROS_MAX_CLOCK:
return PROFILE_KERB_DEFAULT(MaxClockSkew,5);
case IDS_KERBEROS_RENEWAL:
return PROFILE_KERB_DEFAULT(MaxRenewAge,10);
case IDS_KERBEROS_MAX_AGE:
return PROFILE_KERB_DEFAULT(MaxTicketAge,7);
case IDS_KERBEROS_VALIDATE_CLIENT:
return PROFILE_KERB_DEFAULT(TicketValidateClient,1);
// L"Account lockout count", L"Attempts"
case IDS_LOCK_COUNT:
return PROFILE_DEFAULT(LockoutBadCount,0);
// L"Reset lockout count after", L"Minutes"
case IDS_LOCK_RESET_COUNT:
return PROFILE_DEFAULT(ResetLockoutCount,30);
// L"Lockout duration", L"Minutes"
case IDS_LOCK_DURATION:
return PROFILE_DEFAULT(LockoutDuration,30);
// L"Event Auditing Mode",
case IDS_EVENT_ON:
return 0;
// L"Audit system events"
case IDS_SYSTEM_EVENT:
return PROFILE_DEFAULT(AuditSystemEvents,0);
// L"Audit logon events"
case IDS_LOGON_EVENT:
return PROFILE_DEFAULT(AuditLogonEvents,0);
// L"Audit Object Access"
case IDS_OBJECT_ACCESS:
return PROFILE_DEFAULT(AuditObjectAccess,0);
// L"Audit Privilege Use"
case IDS_PRIVILEGE_USE:
return PROFILE_DEFAULT(AuditPrivilegeUse,0);
// L"Audit policy change"
case IDS_POLICY_CHANGE:
return PROFILE_DEFAULT(AuditPolicyChange,0);
// L"Audit Account Manage"
case IDS_ACCOUNT_MANAGE:
return PROFILE_DEFAULT(AuditAccountManage,0);
// L"Audit process tracking"
case IDS_PROCESS_TRACK:
return PROFILE_DEFAULT(AuditProcessTracking,0);
// L"Audit directory service access"
case IDS_DIRECTORY_ACCESS:
return PROFILE_DEFAULT(AuditDSAccess,0);
// L"Audit Account Logon"
case IDS_ACCOUNT_LOGON:
return PROFILE_DEFAULT(AuditAccountLogon,0);
// L"Network access: Allow anonymous SID/Name translation"
case IDS_LSA_ANON_LOOKUP:
return PROFILE_DEFAULT(LSAAnonymousNameLookup,0);
// L"Force logoff when logon hour expire", L""
case IDS_FORCE_LOGOFF:
return PROFILE_DEFAULT(ForceLogoffWhenHourExpire,0);
// L"Accounts: Administrator account status"
case IDS_ENABLE_ADMIN:
return PROFILE_DEFAULT(EnableAdminAccount,1);
// L"Accounts: Guest account status"
case IDS_ENABLE_GUEST:
return PROFILE_DEFAULT(EnableGuestAccount,0);
// L"... Log Maximum Size", L"KBytes"
case IDS_SYS_LOG_MAX:
return PROFILE_DEFAULT(MaximumLogSize[0],512);
case IDS_SEC_LOG_MAX:
return PROFILE_DEFAULT(MaximumLogSize[0],512);
case IDS_APP_LOG_MAX:
return PROFILE_DEFAULT(MaximumLogSize[0],512);
return 512;
// L"... Log Retention Method",
case IDS_SYS_LOG_RET:
return PROFILE_DEFAULT(AuditLogRetentionPeriod[0],1);
case IDS_SEC_LOG_RET:
return PROFILE_DEFAULT(AuditLogRetentionPeriod[0],1);
case IDS_APP_LOG_RET:
return PROFILE_DEFAULT(AuditLogRetentionPeriod[0],1);
return 1;
// L"... Log Retention days", "days"
case IDS_SYS_LOG_DAYS:
return PROFILE_DEFAULT(RetentionDays[0],7);
case IDS_SEC_LOG_DAYS:
return PROFILE_DEFAULT(RetentionDays[0],7);
case IDS_APP_LOG_DAYS:
return PROFILE_DEFAULT(RetentionDays[0],7);
// L"RestrictGuestAccess", L""
case IDS_SYS_LOG_GUEST:
return PROFILE_DEFAULT(RestrictGuestAccess[0],1);
case IDS_SEC_LOG_GUEST:
return PROFILE_DEFAULT(RestrictGuestAccess[0],1);
case IDS_APP_LOG_GUEST:
return PROFILE_DEFAULT(RestrictGuestAccess[0],1);
}
return (DWORD_PTR)ULongToPtr(SCE_NO_VALUE);
}
//+--------------------------------------------------------------------------
//
// Function: GetRegDefault()
//
// Synopsis: Find the default values for undefined policies
//
// Returns: The value to assign as the default value for the policy.
//
// SCE_NO_VALUE is returned on error.
//
//+--------------------------------------------------------------------------
DWORD_PTR
CResult::GetRegDefault() {
SCE_PROFILE_INFO *pspi = NULL;
LPTSTR szValue = NULL;
DWORD_PTR dwValue = SCE_NO_VALUE;
if (!m_pSnapin) {
return (DWORD_PTR)ULongToPtr(SCE_NO_VALUE);
}
PEDITTEMPLATE pet = m_pSnapin->GetTemplate(GT_DEFAULT_TEMPLATE);
if (!pet || !pet->pTemplate) {
return (DWORD_PTR)ULongToPtr(SCE_NO_VALUE);
}
if (pet && pet->pTemplate) {
pspi = pet->pTemplate;
}
PSCE_REGISTRY_VALUE_INFO regArrayThis = (PSCE_REGISTRY_VALUE_INFO)m_dwBase;
if (pspi != NULL)
{
PSCE_REGISTRY_VALUE_INFO regArray = pspi->aRegValues;
DWORD nCount = pspi->RegValueCount;
for(DWORD i=0;i<nCount;i++)
{
if (0 == lstrcmpi(regArray[i].FullValueName,
regArrayThis->FullValueName))
{
szValue = regArray[i].Value;
break;
}
}
}
switch (regArrayThis->ValueType)
{
case SCE_REG_DISPLAY_ENABLE:
if (szValue)
{
dwValue = (DWORD)StrToLong(szValue); //Raid #413311, 6/11/2001, Yanggao
}
if (dwValue == SCE_NO_VALUE)
{
// default: enable
dwValue = 1;
}
break;
case SCE_REG_DISPLAY_NUMBER:
if (szValue) {
dwValue = (DWORD)StrToLong(szValue); //Raid #413311, 6/11/2001, Yanggao
}
if (dwValue == SCE_NO_VALUE) {
dwValue = 1;
}
break;
case SCE_REG_DISPLAY_STRING:
if( szValue )
{
dwValue = (DWORD_PTR)szValue;
}
break;
case SCE_REG_DISPLAY_CHOICE:
if (szValue)
{
dwValue = (DWORD)StrToLong(szValue); //Raid #413311, 6/11/2001, Yanggao
}
if (dwValue == SCE_NO_VALUE)
{
dwValue = 0;
}
break;
case REG_MULTI_SZ: //Raid #413311, 6/11/2001, Yanggao
if (szValue)
{
dwValue = (DWORD_PTR)szValue; //Raid #367756, 4/13/2001
}
break;
default:
if (szValue)
{
dwValue = (DWORD)StrToLong(szValue); //Raid #413311, 6/11/2001, Yanggao
}
//Some security option in group policy is not defined. Their property pages should not display
//any item checked. It confuses user and creates inconsistence.
break;
}
return dwValue;
}
//+--------------------------------------------------------------------------
//
// Function: GetSnapin()
//
// Synopsis: Find current snapin of result item.
//
// Returns: Pointer of snapin
//
//+--------------------------------------------------------------------------
CSnapin* CResult::GetSnapin()
{
return m_pSnapin;
}
Reference in a new issue Copy permalink