1935 lines
63 KiB
C++
1935 lines
63 KiB
C++
// This is a part of the Microsoft Management Console.
|
|
// Copyright (C) 1995-2001 Microsoft Corporation
|
|
// All rights reserved.
|
|
//
|
|
// This source code is only intended as a supplement to the
|
|
// Microsoft Management Console and related
|
|
// electronic documentation provided with the interfaces.
|
|
|
|
#include "stdafx.h"
|
|
#include "afxdlgs.h"
|
|
#include "cookie.h"
|
|
#include "snapmgr.h"
|
|
#include "util.h"
|
|
#include "AString.h"
|
|
#include "ANumber.h"
|
|
#include "AEnable.h"
|
|
#include "AAudit.h"
|
|
#include "ARet.h"
|
|
#include "ARight.h"
|
|
#include "CAudit.h"
|
|
#include "CNumber.h"
|
|
#include "CEnable.h"
|
|
#include "CName.h"
|
|
#include "CPrivs.h"
|
|
#include "CGroup.h"
|
|
#include "Cret.h"
|
|
#include "chklist.h"
|
|
#include "servperm.h"
|
|
#include "aobject.h"
|
|
#include "cobject.h"
|
|
|
|
#include "UIThread.h"
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Event handlers for IFrame::Notify
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT CSnapin::OnFolder(MMC_COOKIE cookie, LPARAM arg, LPARAM param)
|
|
{
|
|
ASSERT(FALSE);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CSnapin::OnShow(LPDATAOBJECT pDataObj, MMC_COOKIE cookie, LPARAM arg, LPARAM param)
|
|
{
|
|
// Note - arg is TRUE when it is time to enumerate
|
|
if (arg == TRUE)
|
|
{
|
|
m_ShowCookie = cookie;
|
|
|
|
// Show the headers for this nodetype
|
|
InitializeHeaders(cookie);
|
|
// Show data
|
|
EnumerateResultPane(cookie, param, pDataObj);
|
|
|
|
// BUBBUG - Demonstration to should how you can attach
|
|
// and a toolbar when a particular nodes gets focus.
|
|
// warning this needs to be here as the toolbars are
|
|
// currently hidden when the previous node looses focus.
|
|
// This should be update to show the user how to hide
|
|
// and show toolbars. (Detach and Attach).
|
|
|
|
//m_pControlbar->Attach(TOOLBAR, (LPUNKNOWN) m_pToolbar1);
|
|
//m_pControlbar->Attach(TOOLBAR, (LPUNKNOWN) m_pToolbar2);
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
// Free data associated with the result pane items, because
|
|
// your node is no longer being displayed.
|
|
// Note: The console will remove the items from the result pane
|
|
m_ShowCookie = 0;
|
|
|
|
DeleteServiceResultList(cookie);
|
|
DeleteList(FALSE);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CSnapin::OnActivate(MMC_COOKIE cookie, LPARAM arg, LPARAM param)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
BOOL CALLBACK MyPropSheetDlgProc(HWND hwnd, UINT uMsg, WPARAM wp, LPARAM lp)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
HRESULT CSnapin::OnMinimize(MMC_COOKIE cookie, LPARAM arg, LPARAM param)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CSnapin::OnPropertyChange(LPDATAOBJECT lpDataObject)
|
|
{
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Method: InitializeHeaders
|
|
//
|
|
// Synopsis: Set the result item headers appropriate for the area
|
|
//
|
|
// Arguments: [cookie] - [in] the folder whose result item to setting headers for
|
|
//
|
|
// Returns:
|
|
//
|
|
// History:
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
SCE_COLUMNINFO g_columnInfo[] = {
|
|
|
|
{ AREA_REGISTRY_ANALYSIS, 5, 0 },
|
|
{ IDS_COL_OBJECT, LVCFMT_LEFT, 220 },
|
|
{ IDS_PERMISSION, LVCFMT_LEFT, 80 },
|
|
{ IDS_AUDITING, LVCFMT_LEFT, 70 },
|
|
{ IDS_COL_BAD_COUNT, LVCFMT_LEFT, 60 },
|
|
{ IDS_RSOP_GPO, LVCFMT_LEFT, 100 },
|
|
{ AREA_REGISTRY, 2, 0 },
|
|
{ IDS_COL_OBJECT, LVCFMT_LEFT, 220 },
|
|
{ IDS_RSOP_GPO, LVCFMT_LEFT, 100 },
|
|
{ AREA_GROUPS, 4, 0 },
|
|
{ IDS_GROUP_NAME, LVCFMT_LEFT, 200 },
|
|
{ IDS_COL_MEMBERSHIP, LVCFMT_LEFT, 120 },
|
|
{ IDS_COL_MEMBEROF, LVCFMT_LEFT, 120 },
|
|
{ IDS_RSOP_GPO, LVCFMT_LEFT, 100 },
|
|
{ AREA_SERVICE, 4, 0 },
|
|
{ IDS_COL_SERVICE, LVCFMT_LEFT, 170 },
|
|
{ IDS_STARTUP, LVCFMT_LEFT, 80 },
|
|
{ IDS_PERMISSION, LVCFMT_LEFT, 80 },
|
|
{ IDS_RSOP_GPO, LVCFMT_LEFT, 100 },
|
|
{ POLICY_PASSWORD, 3, 0 },
|
|
{ IDS_ATTR, LVCFMT_LEFT, 250 },
|
|
{ IDS_BASE_TEMPLATE, LVCFMT_LEFT, 190 },
|
|
{ IDS_RSOP_GPO, LVCFMT_LEFT, 100 },
|
|
{ POLICY_PASSWORD_ANALYSIS, 4, 0 },
|
|
{ IDS_ATTR, LVCFMT_LEFT, 200 },
|
|
{ IDS_BASE_ANALYSIS, LVCFMT_LEFT, 120 },
|
|
{ IDS_SETTING, LVCFMT_LEFT, 120 },
|
|
{ IDS_RSOP_GPO, LVCFMT_LEFT, 100 },
|
|
{ LOCALPOL_PASSWORD, 3, 0 },
|
|
{ IDS_ATTR, LVCFMT_LEFT, 200 },
|
|
{ IDS_LOCAL_POLICY_COLUMN, LVCFMT_LEFT, 120 },
|
|
{ IDS_RSOP_GPO, LVCFMT_LEFT, 100 },
|
|
{ NONE, 2, 0 },
|
|
{ IDS_NAME, LVCFMT_LEFT, 180 },
|
|
{ IDS_DESC, LVCFMT_LEFT, 270 },
|
|
};
|
|
|
|
HRESULT CSnapin::InitializeHeaders(MMC_COOKIE cookie)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
ASSERT(m_pHeader);
|
|
|
|
// Create a new array of column sizes. We just need to copy the static buffer
|
|
// g_columnInfo.
|
|
FOLDER_TYPES type;
|
|
CFolder* pFolder = (CFolder *)cookie;
|
|
if ( NULL == cookie)
|
|
{
|
|
// the root
|
|
type = NONE;
|
|
}
|
|
else
|
|
type = pFolder->GetType();
|
|
|
|
PSCE_COLUMNINFO pCur = NULL;
|
|
CString str;
|
|
int i = 0;
|
|
int iDesc = 0;
|
|
int iInsert = 0;
|
|
|
|
PSCE_COLINFOARRAY pHeader = NULL;
|
|
if(m_pComponentData){
|
|
pHeader = reinterpret_cast<CComponentDataImpl *>(m_pComponentData)->GetColumnInfo( type );
|
|
}
|
|
if( !pHeader )
|
|
{
|
|
// Create new header look up.
|
|
switch(type){
|
|
case AREA_REGISTRY:
|
|
case AREA_FILESTORE:
|
|
type = AREA_REGISTRY;
|
|
break;
|
|
|
|
case AREA_REGISTRY_ANALYSIS:
|
|
case AREA_FILESTORE_ANALYSIS:
|
|
case REG_OBJECTS:
|
|
case FILE_OBJECTS:
|
|
type = AREA_REGISTRY_ANALYSIS;
|
|
break;
|
|
|
|
case AREA_GROUPS:
|
|
case AREA_GROUPS_ANALYSIS:
|
|
type = AREA_GROUPS;
|
|
break;
|
|
|
|
case AREA_SERVICE:
|
|
case AREA_SERVICE_ANALYSIS:
|
|
type = AREA_SERVICE;
|
|
break;
|
|
|
|
default:
|
|
if ( type >= POLICY_PASSWORD &&
|
|
type <= AREA_FILESTORE )
|
|
{
|
|
type = POLICY_PASSWORD;
|
|
}
|
|
else if ( type >= POLICY_PASSWORD_ANALYSIS &&
|
|
type <= REG_OBJECTS )
|
|
{
|
|
type = POLICY_PASSWORD_ANALYSIS;
|
|
}
|
|
else if (type >= LOCALPOL_PASSWORD &&
|
|
type <= LOCALPOL_LAST)
|
|
{
|
|
type = LOCALPOL_PASSWORD;
|
|
}
|
|
else
|
|
{
|
|
type = NONE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
pCur = g_columnInfo;
|
|
for( i = 0; i < sizeof(g_columnInfo)/sizeof(SCE_COLUMNINFO);i++)
|
|
{
|
|
if(pCur[i].colID == type)
|
|
{
|
|
iInsert = pCur[i].nCols;
|
|
i++;
|
|
break;
|
|
}
|
|
i += pCur[i].nCols;
|
|
}
|
|
|
|
//
|
|
// RSOP Mode has an extra column for the GPO source
|
|
// If we're not in RSOP mode then ignore that column
|
|
//
|
|
if (((GetModeBits() & MB_RSOP) != MB_RSOP) && (NONE != type))
|
|
{
|
|
iInsert--;
|
|
}
|
|
|
|
if(pFolder)
|
|
{
|
|
type = pFolder->GetType();
|
|
}
|
|
|
|
iDesc = i;
|
|
pCur += iDesc;
|
|
pHeader = (PSCE_COLINFOARRAY)LocalAlloc(0, sizeof(SCE_COLINFOARRAY) + (sizeof(int) * iInsert) );
|
|
if(pHeader)
|
|
{
|
|
pHeader->iIndex = i;
|
|
pHeader->nCols = iInsert;
|
|
|
|
for(i = 0; i < iInsert; i++)
|
|
{
|
|
pHeader->nWidth[i] = pCur[i].nWidth;
|
|
}
|
|
|
|
reinterpret_cast<CComponentDataImpl *>(m_pComponentData)->SetColumnInfo( type, pHeader );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iDesc = pHeader->iIndex;
|
|
iInsert = pHeader->nCols;
|
|
}
|
|
|
|
// Insert the columns.
|
|
m_nColumns = iInsert;
|
|
|
|
BOOL bGroupPolicy = FALSE;
|
|
|
|
//
|
|
// special case Group Policy mode since "Policy Setting" has
|
|
// to be displayed instead of "Computer Setting"
|
|
//
|
|
|
|
if (GetModeBits() & MB_GROUP_POLICY)
|
|
{
|
|
bGroupPolicy = TRUE;
|
|
}
|
|
|
|
pCur = g_columnInfo + iDesc;
|
|
for(i = 0; i < iInsert; i++)
|
|
{
|
|
if (bGroupPolicy && pCur->colID == IDS_BASE_TEMPLATE)
|
|
{
|
|
str.LoadString( IDS_POLICY_SETTING );
|
|
}
|
|
else
|
|
{
|
|
str.LoadString( pCur->colID );
|
|
}
|
|
|
|
if(pHeader)
|
|
{
|
|
m_pHeader->InsertColumn( i, str, pCur->nCols, pHeader->nWidth[i] );
|
|
}
|
|
else
|
|
{
|
|
m_pHeader->InsertColumn( i, str, pCur->nCols, pCur->nWidth );
|
|
}
|
|
pCur++;
|
|
}
|
|
|
|
switch(type) {
|
|
case STATIC:
|
|
case ROOT:
|
|
case ANALYSIS:
|
|
case CONFIGURATION:
|
|
case LOCATIONS:
|
|
case PROFILE:
|
|
case LOCALPOL:
|
|
case POLICY_LOCAL:
|
|
case POLICY_ACCOUNT:
|
|
case POLICY_LOCAL_ANALYSIS:
|
|
case POLICY_ACCOUNT_ANALYSIS:
|
|
case LOCALPOL_ACCOUNT:
|
|
case LOCALPOL_LOCAL:
|
|
m_pResult->ModifyViewStyle(MMC_NOSORTHEADER,(MMC_RESULT_VIEW_STYLE)0);
|
|
break;
|
|
default:
|
|
m_pResult->ModifyViewStyle((MMC_RESULT_VIEW_STYLE)0,MMC_NOSORTHEADER);
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CSnapin::InitializeBitmaps(MMC_COOKIE cookie)
|
|
{
|
|
ASSERT(m_pImageResult != NULL);
|
|
|
|
CBitmap bmp16x16;
|
|
CBitmap bmp32x32;
|
|
|
|
// Load the bitmaps from the dll
|
|
|
|
bmp16x16.LoadBitmap(IDB_ICON16 /*IDB_16x16 */);
|
|
bmp32x32.LoadBitmap(IDB_ICON32 /*IDB_32x32 */);
|
|
|
|
// Set the images
|
|
m_pImageResult->ImageListSetStrip(reinterpret_cast<LONG_PTR*>(static_cast<HBITMAP>(bmp16x16)),
|
|
reinterpret_cast<LONG_PTR*>(static_cast<HBITMAP>(bmp32x32)),
|
|
0, RGB(255, 0, 255));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Function: CComponentDataImpl::SerializeColumnInfo
|
|
//
|
|
// Synopsis: Saves or loads column information contained in m_mapColumns.
|
|
// The function saves out the information in char format.
|
|
// SCECOLUMNS:%d - number of column information structures.
|
|
// T:%d, - type of column (key)
|
|
// I:%d, - Index into [g_columnInfo]
|
|
// C:%d, - Number of columns
|
|
// W:%d, - Width of a column.
|
|
//
|
|
// Arguments: [pStm] - Stream to read or write to.
|
|
// [pTotalWrite] - [Optional] Total number of bytes written.
|
|
// [bRead] - If True then we should read from the stream.
|
|
//
|
|
// Returns: ERROR_SUCCESS - Everything was successful.
|
|
// E_OUTOFMEMORY - Out of memory.
|
|
//
|
|
// History:
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
DWORD CComponentDataImpl::SerializeColumnInfo(
|
|
IStream *pStm,
|
|
ULONG *pTotalWrite,
|
|
BOOL bRead)
|
|
{
|
|
ULONG nBytesWritten = 0;
|
|
POSITION pos = NULL;
|
|
FOLDER_TYPES fType;
|
|
PSCE_COLINFOARRAY pData = 0;
|
|
ULONG totalWrite = 0;
|
|
int i = 0;
|
|
|
|
LPCTSTR pszHeader = TEXT("SCECOLUMNS:%d{");
|
|
LPCTSTR pszColHead = TEXT("{T:%d,I:%d,C:%d,");
|
|
if(!bRead)
|
|
{
|
|
// Write columns. Save the information in text format so that we will be
|
|
// independent of sizeof stuff.
|
|
pos = m_mapColumns.GetStartPosition();
|
|
totalWrite = 0;
|
|
if(pos)
|
|
{
|
|
char szWrite[256];
|
|
// Write header.
|
|
totalWrite += WriteSprintf(pStm, pszHeader, m_mapColumns.GetCount());
|
|
while(pos)
|
|
{
|
|
m_mapColumns.GetNextAssoc(pos, fType, pData);
|
|
if(pData)
|
|
{
|
|
// write out the type.
|
|
totalWrite += WriteSprintf(pStm, pszColHead, fType, g_columnInfo[pData->iIndex - 1].colID, pData->nCols);
|
|
|
|
// write out each column width.
|
|
for(i = 0; i < pData->nCols; i++)
|
|
{
|
|
if( i + 1 < pData->nCols)
|
|
{
|
|
totalWrite += WriteSprintf(pStm, TEXT("W:%d,"), pData->nWidth[i]);
|
|
}
|
|
else
|
|
{
|
|
totalWrite += WriteSprintf(pStm, TEXT("W:%d}"), pData->nWidth[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
totalWrite += WriteSprintf(pStm, TEXT("}"));
|
|
}
|
|
|
|
if(pTotalWrite)
|
|
{
|
|
*pTotalWrite = totalWrite;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int iTotalTypes = 0;
|
|
int iIndex = 0;
|
|
int nCols = 0;
|
|
|
|
if( ReadSprintf( pStm, pszHeader, &iTotalTypes) != -1)
|
|
{
|
|
for( i = 0; i < iTotalTypes; i++)
|
|
{
|
|
if( ReadSprintf(pStm, pszColHead, &fType, &iIndex, &nCols) == - 1)
|
|
{
|
|
break;
|
|
}
|
|
|
|
// find index of column information.
|
|
for(int k = 0; k < sizeof(g_columnInfo)/sizeof(SCE_COLUMNINFO); k++)
|
|
{
|
|
if( g_columnInfo[k].colID == iIndex )
|
|
{
|
|
iIndex = k + 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
pData = (PSCE_COLINFOARRAY)LocalAlloc(0, sizeof(SCE_COLINFOARRAY) + (sizeof(int) * nCols) );
|
|
|
|
if(pData)
|
|
{
|
|
pData->iIndex = iIndex;
|
|
pData->nCols = nCols;
|
|
|
|
for( iIndex = 0; iIndex < nCols; iIndex++)
|
|
{
|
|
if( iIndex + 1 < nCols)
|
|
ReadSprintf(pStm, TEXT("W:%d,"), &(pData->nWidth[ iIndex ]) );
|
|
else
|
|
ReadSprintf(pStm, TEXT("W:%d}"), &(pData->nWidth[ iIndex ]) );
|
|
}
|
|
|
|
SetColumnInfo( fType, pData );
|
|
}
|
|
else
|
|
return (DWORD)E_OUTOFMEMORY;
|
|
}
|
|
ReadSprintf(pStm, TEXT("}"));
|
|
}
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Method: EnumerateResultPane
|
|
//
|
|
// Synopsis: Create the result pane items for the result pane that MMC
|
|
// is displaying
|
|
//
|
|
// Arguments: [cookie] - The cookie representing the node's who we
|
|
// are enumerating
|
|
// [pParent] - The scope node whose result pane we are showing
|
|
// [pDataObj] - The data object for the scope node we are showing
|
|
//
|
|
// Returns: none
|
|
//
|
|
// Modifies: m_resultItemList
|
|
//
|
|
// History: 12-15-1997 Robcap
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
void CSnapin::EnumerateResultPane(MMC_COOKIE cookie, HSCOPEITEM pParent, LPDATAOBJECT pDataObj)
|
|
{
|
|
PEDITTEMPLATE pTemplateInfo = 0;
|
|
PEDITTEMPLATE pProfileTemplate = 0;
|
|
PEDITTEMPLATE pBaseTemplate = 0;
|
|
PSCE_PROFILE_INFO pProfileInfo = 0;
|
|
PSCE_PROFILE_INFO pBaseInfo = 0;
|
|
DWORD idErr = 0;
|
|
CComponentDataImpl *pccDataImpl = 0;
|
|
|
|
ASSERT(m_pResult != NULL); // make sure we QI'ed for the interface
|
|
ASSERT(m_pComponentData != NULL);
|
|
|
|
pccDataImpl = (CComponentDataImpl *)m_pComponentData;
|
|
//
|
|
// This may take a while; let the user have some warning rather than
|
|
// just going blank on them
|
|
//
|
|
CWaitCursor wc;
|
|
|
|
//
|
|
// cookie is the scope pane item for which to enumerate.
|
|
// for safety, we should find the object in m_pComponentData
|
|
// CFolder* pFolder = dynamic_cast<CComponentDataImpl*>(m_pComponentData)->FindObject(cookie, NULL);
|
|
// but for performance (and hopes nothing mess up), we could
|
|
// cast the cookie to scope item type (CFolder)
|
|
//
|
|
|
|
CFolder* pFolder = 0;
|
|
CString sErr;
|
|
SCESTATUS rc = 0;
|
|
|
|
PSCE_ERROR_LOG_INFO ErrBuf=NULL;
|
|
AREA_INFORMATION area=0;
|
|
CString StrErr;
|
|
PVOID pHandle=NULL;
|
|
|
|
if ( cookie )
|
|
pFolder = (CFolder *)cookie;
|
|
else
|
|
pFolder = ((CComponentDataImpl *)m_pComponentData)->FindObject(cookie, NULL);
|
|
|
|
|
|
//
|
|
// pFolder could be NULL for the root.
|
|
//
|
|
if ( pFolder == NULL )
|
|
return;
|
|
|
|
FOLDER_TYPES type = pFolder->GetType();
|
|
if( pFolder == m_pSelectedFolder &&
|
|
m_pSelectedFolder &&
|
|
m_pSelectedFolder->GetResultListCount() )
|
|
{
|
|
//
|
|
// Do nothing.
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if( m_pSelectedFolder && m_resultItemHandle )
|
|
{
|
|
m_pSelectedFolder->ReleaseResultItemHandle( m_resultItemHandle );
|
|
}
|
|
|
|
pFolder->GetResultItemHandle( &m_resultItemHandle );
|
|
m_pSelectedFolder = pFolder;
|
|
if( pFolder->GetResultListCount() )
|
|
{
|
|
goto AddToResultPane;
|
|
}
|
|
}
|
|
//
|
|
// If this is the top Analysis folder and it hasn't been enumerated yet then
|
|
// Make sure we do so and put back any folders that we've removed from there,
|
|
// Since MMC won't give us a second expand event to do it on
|
|
//
|
|
|
|
//
|
|
// The Analysis Pane isn't available now; let the user know why
|
|
//
|
|
if (type == ANALYSIS)
|
|
{
|
|
if (((CComponentDataImpl *) m_pComponentData)->m_bIsLocked)
|
|
{
|
|
//
|
|
// should print more informative messages as to why the info isn't available
|
|
//
|
|
AddResultItem(IDS_ERROR_ANALYSIS_LOCKED, NULL, NULL, ITEM_OTHER, SCE_STATUS_ERROR_NOT_AVAILABLE, cookie);
|
|
goto AddToResultPane;
|
|
}
|
|
if (!(((CComponentDataImpl *) m_pComponentData)->SadHandle))
|
|
{
|
|
//
|
|
// should print more informative messages as to why the info isn't available
|
|
//
|
|
FormatDBErrorMessage(
|
|
((CComponentDataImpl *)m_pComponentData)->SadErrored,
|
|
((CComponentDataImpl *)m_pComponentData)->SadName,
|
|
sErr);
|
|
|
|
sErr.TrimLeft();
|
|
sErr.TrimRight();
|
|
|
|
AddResultItem(sErr, NULL, NULL, ITEM_OTHER, SCE_STATUS_ERROR_NOT_AVAILABLE, cookie);
|
|
|
|
goto AddToResultPane;
|
|
}
|
|
}
|
|
if (type == ANALYSIS ||
|
|
(type >= AREA_POLICY_ANALYSIS && type <= REG_OBJECTS))
|
|
{
|
|
CString strDBName;
|
|
CString strDBFmt;
|
|
CString strDB;
|
|
LPTSTR szDBName;
|
|
strDB = ((CComponentDataImpl *)m_pComponentData)->SadName;
|
|
if (strDB.IsEmpty() || IsSystemDatabase(strDB))
|
|
strDBFmt.LoadString(IDS_SYSTEM_DB_NAME_FMT);
|
|
else
|
|
strDBFmt.LoadString(IDS_PRIVATE_DB_NAME_FMT);
|
|
|
|
strDBName.Format(strDBFmt,strDB);
|
|
szDBName = strDBName.GetBuffer(1);
|
|
m_pResult->SetDescBarText(szDBName);
|
|
//AddResultItem(strDBFmt,NULL,NULL,ITEM_OTHER,SCE_STATUS_GOOD,cookie);
|
|
}
|
|
|
|
if (type >= CONFIGURATION && type <= AREA_FILESTORE)
|
|
{
|
|
//
|
|
// We're in the Profile area, so we don't need to keep the Analysis area
|
|
// open. Close it to save memory:
|
|
//
|
|
((CComponentDataImpl *)m_pComponentData)->CloseAnalysisPane();
|
|
}
|
|
|
|
if ( type == PROFILE )
|
|
{
|
|
//
|
|
// Do not display the error message if we do not implement native modes.
|
|
//
|
|
if( pFolder->GetState() & CFolder::state_InvalidTemplate &&
|
|
!(pFolder->GetMode() & MB_NO_NATIVE_NODES ))
|
|
{
|
|
StrErr.LoadString( IDS_ERROR_CANT_OPEN_PROFILE );
|
|
AddResultItem(StrErr, NULL, NULL, ITEM_OTHER, SCE_STATUS_ERROR_NOT_AVAILABLE, cookie);
|
|
goto AddToResultPane;
|
|
}
|
|
else if (pFolder->GetMode() == SCE_MODE_DOMAIN_COMPUTER_ERROR)
|
|
{
|
|
StrErr.LoadString( IDS_ERROR_NOT_ON_PDC );
|
|
AddResultItem(StrErr, NULL, NULL, ITEM_OTHER, SCE_STATUS_ERROR_NOT_AVAILABLE, cookie);
|
|
goto AddToResultPane;
|
|
}
|
|
}
|
|
|
|
if ( (type < AREA_POLICY) ||
|
|
(type > AREA_LAST))
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
switch (type)
|
|
{
|
|
case AREA_PRIVILEGE:
|
|
case AREA_PRIVILEGE_ANALYSIS:
|
|
case LOCALPOL_PRIVILEGE:
|
|
area = AREA_PRIVILEGES;
|
|
break;
|
|
|
|
case AREA_GROUPS:
|
|
case AREA_GROUPS_ANALYSIS:
|
|
area = AREA_GROUP_MEMBERSHIP;
|
|
break;
|
|
|
|
case AREA_SERVICE:
|
|
case AREA_SERVICE_ANALYSIS:
|
|
area = AREA_SYSTEM_SERVICE;
|
|
break;
|
|
|
|
case AREA_REGISTRY:
|
|
case AREA_REGISTRY_ANALYSIS:
|
|
case REG_OBJECTS:
|
|
area = AREA_REGISTRY_SECURITY;
|
|
break;
|
|
|
|
case AREA_FILESTORE:
|
|
case AREA_FILESTORE_ANALYSIS:
|
|
case FILE_OBJECTS:
|
|
area = AREA_FILE_SECURITY;
|
|
break;
|
|
|
|
default:
|
|
// case AREA_POLICY:
|
|
// case AREA_POLICY_ANALYSIS:
|
|
// case AREA_LOCALPOL_POLICY:
|
|
area = AREA_SECURITY_POLICY;
|
|
break;
|
|
}
|
|
|
|
if ( type >= AREA_POLICY &&
|
|
type <= AREA_FILESTORE )
|
|
{
|
|
//
|
|
// inf profiles
|
|
//
|
|
ASSERT(pFolder->GetInfFile());
|
|
if ( pFolder->GetInfFile() == NULL )
|
|
return;
|
|
|
|
//
|
|
// Get the Profile info from the cache
|
|
//
|
|
pTemplateInfo = GetTemplate(pFolder->GetInfFile(),AREA_ALL,&idErr);
|
|
if (!pTemplateInfo)
|
|
{
|
|
AddResultItem(idErr,NULL,NULL,ITEM_OTHER,SCE_STATUS_ERROR_NOT_AVAILABLE,cookie);
|
|
}
|
|
else
|
|
{
|
|
CreateProfileResultList(cookie,
|
|
type,
|
|
pTemplateInfo,
|
|
pDataObj);
|
|
}
|
|
}
|
|
else if ((type >= LOCALPOL_ACCOUNT) &&
|
|
(type <= LOCALPOL_LAST))
|
|
{
|
|
if (!((CComponentDataImpl*)m_pComponentData)->SadHandle &&
|
|
(ERROR_SUCCESS != ((CComponentDataImpl*)m_pComponentData)->SadErrored))
|
|
{
|
|
((CComponentDataImpl*)m_pComponentData)->LoadSadInfo(FALSE);
|
|
}
|
|
pHandle = ((CComponentDataImpl*)m_pComponentData)->SadHandle;
|
|
//
|
|
// Get the Computer and Last Inspection Templates
|
|
//
|
|
pTemplateInfo = GetTemplate(GT_EFFECTIVE_POLICY,area,&idErr);
|
|
|
|
if (!pTemplateInfo)
|
|
{
|
|
AddResultItem(idErr, NULL, NULL, ITEM_OTHER, SCE_STATUS_ERROR_NOT_AVAILABLE, cookie);
|
|
goto AddToResultPane;
|
|
}
|
|
pBaseTemplate = pTemplateInfo;
|
|
|
|
pTemplateInfo = GetTemplate(GT_LOCAL_POLICY,area,&idErr);
|
|
if (!pTemplateInfo)
|
|
{
|
|
AddResultItem(idErr, NULL, NULL, ITEM_OTHER, SCE_STATUS_ERROR_NOT_AVAILABLE, cookie);
|
|
goto AddToResultPane;
|
|
}
|
|
pProfileTemplate = pTemplateInfo;
|
|
|
|
CreateLocalPolicyResultList(cookie, type, pProfileTemplate, pBaseTemplate, pDataObj);
|
|
}
|
|
else if ( area != AREA_REGISTRY_SECURITY &&
|
|
area != AREA_FILE_SECURITY &&
|
|
area != AREA_DS_OBJECTS )
|
|
{
|
|
//
|
|
// SadName and SadHandle should already been populated
|
|
//
|
|
if (!((CComponentDataImpl*)m_pComponentData)->SadHandle &&
|
|
((CComponentDataImpl*)m_pComponentData)->SadErrored != SCESTATUS_SUCCESS)
|
|
{
|
|
((CComponentDataImpl*)m_pComponentData)->LoadSadInfo(TRUE);
|
|
}
|
|
pHandle = ((CComponentDataImpl*)m_pComponentData)->SadHandle;
|
|
if ( NULL == pHandle )
|
|
{
|
|
AddResultItem(IDS_ERROR_NO_ANALYSIS_INFO, NULL, NULL, ITEM_OTHER, SCE_STATUS_ERROR_NOT_AVAILABLE, cookie);
|
|
goto AddToResultPane;
|
|
}
|
|
//
|
|
// Get the Computer and Last Inspection Templates
|
|
//
|
|
pTemplateInfo = GetTemplate(GT_COMPUTER_TEMPLATE,area,&idErr);
|
|
if (!pTemplateInfo)
|
|
{
|
|
AddResultItem(idErr, NULL, NULL, ITEM_OTHER, SCE_STATUS_ERROR_NOT_AVAILABLE, cookie);
|
|
goto AddToResultPane;
|
|
}
|
|
pBaseTemplate = pTemplateInfo;
|
|
|
|
pTemplateInfo = GetTemplate(GT_LAST_INSPECTION,area,&idErr);
|
|
if (!pTemplateInfo)
|
|
{
|
|
AddResultItem(idErr, NULL, NULL, ITEM_OTHER, SCE_STATUS_ERROR_NOT_AVAILABLE, cookie);
|
|
goto AddToResultPane;
|
|
}
|
|
pProfileTemplate = pTemplateInfo;
|
|
|
|
CreateAnalysisResultList(cookie, type, pProfileTemplate, pBaseTemplate,pDataObj);
|
|
}
|
|
else if (AREA_FILE_SECURITY == area)
|
|
{
|
|
// registry and file objects
|
|
// SadName and SadHandle should already been populated
|
|
pHandle = ((CComponentDataImpl*)m_pComponentData)->SadHandle;
|
|
if ( NULL == pHandle )
|
|
{
|
|
return;
|
|
}
|
|
PSCE_OBJECT_CHILDREN ObjectList=NULL;
|
|
|
|
if ( type == FILE_OBJECTS )
|
|
{
|
|
// get next level objects
|
|
rc = SceGetObjectChildren(pHandle,
|
|
SCE_ENGINE_SAP,
|
|
area,
|
|
pFolder->GetName(),
|
|
&ObjectList,
|
|
&ErrBuf);
|
|
}
|
|
|
|
CreateObjectResultList(cookie, type, area, ObjectList, pHandle, pDataObj);
|
|
|
|
if ( (type == REG_OBJECTS || type == FILE_OBJECTS) && ObjectList )
|
|
{
|
|
SceFreeMemory((PVOID)ObjectList, SCE_STRUCT_OBJECT_CHILDREN);
|
|
}
|
|
|
|
}
|
|
|
|
// free memory buffers
|
|
if ( ErrBuf )
|
|
SceFreeMemory((PVOID)ErrBuf, SCE_STRUCT_ERROR_LOG_INFO);
|
|
|
|
|
|
AddToResultPane:
|
|
if (m_pResult)
|
|
{
|
|
//
|
|
// Prepare the result window.
|
|
//
|
|
m_pResult->SetItemCount(
|
|
m_pSelectedFolder->GetResultListCount( ),
|
|
MMCLV_UPDATE_NOINVALIDATEALL);
|
|
|
|
RESULTDATAITEM resultItem;
|
|
|
|
ZeroMemory(&resultItem,sizeof(resultItem));
|
|
resultItem.mask = RDI_STR | RDI_IMAGE | RDI_PARAM;
|
|
resultItem.str = MMC_CALLBACK;
|
|
resultItem.nImage = -1; // equivalent to: MMC_CALLBACK;
|
|
|
|
|
|
// Set the result as the cookie
|
|
POSITION pos = NULL;
|
|
do {
|
|
if( m_pSelectedFolder->GetResultItem(
|
|
m_resultItemHandle,
|
|
pos,
|
|
(CResult **)&(resultItem.lParam)
|
|
) == ERROR_SUCCESS)
|
|
{
|
|
if(resultItem.lParam)
|
|
{
|
|
m_pResult->InsertItem(&resultItem);
|
|
}
|
|
}
|
|
else
|
|
break;
|
|
} while(pos);
|
|
m_pResult->Sort(0, 0, 0);
|
|
}
|
|
}
|
|
|
|
void ConvertNameListToString(PSCE_NAME_LIST pList, LPTSTR *sz)
|
|
{
|
|
LPTSTR pszNew;
|
|
if (NULL == sz)
|
|
return;
|
|
|
|
|
|
if (NULL == pList)
|
|
return;
|
|
|
|
//
|
|
// Get Total size for buffer.
|
|
//
|
|
int iSize = 0;
|
|
PSCE_NAME_LIST pTemp = 0;
|
|
for( pTemp=pList;pTemp != NULL; pTemp=pTemp->Next)
|
|
{
|
|
if ( !(pTemp->Name) )
|
|
continue;
|
|
|
|
iSize += lstrlen(pTemp->Name) + 1;
|
|
}
|
|
|
|
//
|
|
// Allocate buffer.
|
|
//
|
|
pszNew = new TCHAR[iSize + 1];
|
|
if (!pszNew)
|
|
return;
|
|
|
|
|
|
*sz = pszNew;
|
|
//
|
|
// Copy the strings.
|
|
//
|
|
for (pTemp=pList; pTemp != NULL; pTemp=pTemp->Next)
|
|
{
|
|
if (!(pTemp->Name))
|
|
continue;
|
|
|
|
iSize = lstrlen(pTemp->Name);
|
|
memcpy(pszNew, pTemp->Name, iSize * sizeof(TCHAR));
|
|
pszNew += iSize;
|
|
*pszNew = L',';
|
|
pszNew++;
|
|
}
|
|
*(pszNew - 1) = 0;
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Method: CreateProfileResultList
|
|
//
|
|
// Synopsis: Create the result pane items for profile section
|
|
//
|
|
// Arguments: [cookie] - The cookie representing the folder which we
|
|
// are enumerating
|
|
// [type] - The type of the folder we are enumerating
|
|
// [pSceInfo] - The overall template that we are enumerating
|
|
// [pDataObj] - The data object for this folder
|
|
//
|
|
// Returns: none
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
void
|
|
CSnapin::CreateProfileResultList(MMC_COOKIE cookie,
|
|
FOLDER_TYPES type,
|
|
PEDITTEMPLATE pSceInfo,
|
|
LPDATAOBJECT pDataObj)
|
|
{
|
|
bool bVerify=false;
|
|
CString listStr;
|
|
PSCE_PRIVILEGE_ASSIGNMENT pPriv=NULL;
|
|
PSCE_GROUP_MEMBERSHIP pGroup=NULL;
|
|
PSCE_OBJECT_ARRAY pObject = 0;
|
|
UINT i = 0;
|
|
|
|
switch (type)
|
|
{
|
|
case POLICY_KERBEROS:
|
|
case POLICY_PASSWORD:
|
|
case POLICY_LOCKOUT:
|
|
case POLICY_AUDIT:
|
|
case POLICY_OTHER:
|
|
case POLICY_LOG:
|
|
CreateProfilePolicyResultList(cookie,
|
|
type,
|
|
pSceInfo,
|
|
pDataObj);
|
|
break;
|
|
|
|
case AREA_POLICY:
|
|
//
|
|
// Policy folder only contains other folders, no actual result items
|
|
//
|
|
break;
|
|
|
|
case AREA_PRIVILEGE:
|
|
{
|
|
CString strDisp;
|
|
LPTSTR szDisp;
|
|
DWORD cbDisp;
|
|
szDisp = new TCHAR [255];
|
|
|
|
if (!szDisp)
|
|
break;
|
|
|
|
LPTSTR szPriv = new TCHAR [255];
|
|
if ( !szPriv )
|
|
{
|
|
delete[] szDisp;
|
|
break;
|
|
}
|
|
|
|
for ( int i2=0; i2<cPrivCnt; i2++ )
|
|
{
|
|
cbDisp = 255;
|
|
if ( SCESTATUS_SUCCESS == SceLookupPrivRightName(i2,szPriv, (PINT)&cbDisp) )
|
|
{
|
|
for (pPriv=pSceInfo->pTemplate->OtherInfo.smp.pPrivilegeAssignedTo;
|
|
pPriv!=NULL;
|
|
pPriv=pPriv->Next)
|
|
{
|
|
if ( _wcsicmp(szPriv, pPriv->Name) == 0 )
|
|
break;
|
|
}
|
|
|
|
cbDisp = 255;
|
|
if ( pPriv )
|
|
{
|
|
//
|
|
// find it in the template
|
|
//
|
|
GetRightDisplayName(NULL,(LPCTSTR)pPriv->Name,szDisp,&cbDisp);
|
|
|
|
AddResultItem(szDisp, // The name of the attribute being added
|
|
(LONG_PTR)(i2>=cPrivW2k), // Raid #382263, The last inspected setting of the attribute
|
|
(LONG_PTR)pPriv->AssignedTo, // The template setting of the attribute
|
|
ITEM_PROF_PRIVS, // The type of of the attribute's data
|
|
-1, // The mismatch status of the attribute
|
|
cookie, // The cookie for the result item pane
|
|
FALSE, // Copy last inspected from template
|
|
NULL, // The units the attribute is set in
|
|
(LONG_PTR) pPriv, // An id to let us know where to save this attribute
|
|
pSceInfo, // The template to save this attribute in
|
|
pDataObj // The data object for the scope note who owns the result pane
|
|
);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// a not configured privilege
|
|
//
|
|
GetRightDisplayName(NULL,(LPCTSTR)szPriv,szDisp,&cbDisp);
|
|
|
|
AddResultItem(szDisp, // The name of the attribute being added
|
|
(LONG_PTR)(i2>=cPrivW2k), // Raid #382263, The last inspected setting of the attribute
|
|
(LONG_PTR)ULongToPtr(SCE_NO_VALUE), // The template setting of the attribute
|
|
ITEM_PROF_PRIVS, // The type of of the attribute's data
|
|
-1, // The mismatch status of the attribute
|
|
cookie, // The cookie for the result item pane
|
|
FALSE, // Copy last inspected from template
|
|
szPriv, // Save the privilege name in this buffer
|
|
0, // An id to let us know where to save this attribute
|
|
pSceInfo, // The template to save this attribute in
|
|
pDataObj // The data object for the scope note who owns the result pane
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// impossible, just continue
|
|
}
|
|
|
|
}
|
|
|
|
delete[] szDisp;
|
|
delete[] szPriv;
|
|
}
|
|
break;
|
|
|
|
case AREA_GROUPS:
|
|
for (pGroup=pSceInfo->pTemplate->pGroupMembership;
|
|
pGroup!=NULL;
|
|
pGroup=pGroup->Next)
|
|
{
|
|
AddResultItem((LPCTSTR)pGroup->GroupName, // The name of the attribute being added
|
|
0, // The last inspection
|
|
(LONG_PTR)pGroup, // The template info
|
|
ITEM_PROF_GROUP, // The type of of the attribute's data
|
|
-1, // The mismatch status of the attribute
|
|
cookie, // The cookie for the result item pane
|
|
FALSE, // Copy last inspected from template
|
|
NULL, // The units the attribute is set in
|
|
(LONG_PTR)pGroup, // An id to let us know where to save this attribute
|
|
pSceInfo, // The template to save this attribute in
|
|
pDataObj); // The data object for the scope note who owns the result pane
|
|
}
|
|
break;
|
|
|
|
case AREA_SERVICE:
|
|
CreateProfServiceResultList(cookie,
|
|
type,
|
|
pSceInfo,
|
|
pDataObj);
|
|
break;
|
|
|
|
case AREA_REGISTRY:
|
|
pObject = pSceInfo->pTemplate->pRegistryKeys.pAllNodes;
|
|
if ( pObject!=NULL )
|
|
{
|
|
for (i=0; i<pObject->Count; i++)
|
|
{
|
|
|
|
AddResultItem(pObject->pObjectArray[i]->Name, // The name of the attribute being added
|
|
NULL, // The last inspected setting of the attribute
|
|
(LONG_PTR)pObject->pObjectArray[i]->pSecurityDescriptor, // The template setting of the attribute
|
|
ITEM_PROF_REGSD, // The type of of the attribute's data
|
|
pObject->pObjectArray[i]->Status, // The mismatch status of the attribute
|
|
cookie, // The cookie for the result item pane
|
|
FALSE, // Copy last inspected from template
|
|
NULL, // The units the attribute is set in
|
|
(LONG_PTR)pObject->pObjectArray[i], // An id to let us know where to save this attribute
|
|
pSceInfo, // The template to save this attribute in
|
|
pDataObj); // The data object for the scope note who owns the result pane
|
|
}
|
|
}
|
|
break;
|
|
|
|
case AREA_FILESTORE:
|
|
pObject = pSceInfo->pTemplate->pFiles.pAllNodes;
|
|
if ( pObject!=NULL )
|
|
{
|
|
for (i=0; i<pObject->Count; i++)
|
|
{
|
|
|
|
AddResultItem(pObject->pObjectArray[i]->Name, // The name of the attribute being added
|
|
NULL, // The last inspected setting of the attribute
|
|
(LONG_PTR)pObject->pObjectArray[i]->pSecurityDescriptor, // The template setting of the attribute
|
|
ITEM_PROF_FILESD, // The type of of the attribute's data
|
|
pObject->pObjectArray[i]->Status, // The mismatch status of the attribute
|
|
cookie, // The cookie for the result item pane
|
|
FALSE, // Copy last inspected from template
|
|
NULL, // The units the attribute is set in
|
|
(LONG_PTR)pObject->pObjectArray[i], // An id to let us know where to save this attribute
|
|
pSceInfo, // The template to save this attribute in
|
|
pDataObj // The data object for the scope note who owns the result pane
|
|
);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Method: CreateAnalysisResultList
|
|
//
|
|
// Synopsis: Create the result pane items for the analysis section
|
|
//
|
|
// Arguments: [cookie] - The cookie representing the folder which we
|
|
// are enumerating
|
|
// [type] - The type of the folder we are enumerating
|
|
// [pSceInfo] - The last inspection template that we are enumerating
|
|
// [pSceBase] - The computer template that we are enumerating
|
|
// [pDataObj] - The data object for this folder
|
|
//
|
|
// Returns: none
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
void CSnapin::CreateAnalysisResultList(MMC_COOKIE cookie,
|
|
FOLDER_TYPES type,
|
|
PEDITTEMPLATE pSceInfo,
|
|
PEDITTEMPLATE pBase,
|
|
LPDATAOBJECT pDataObj )
|
|
{
|
|
bool bVerify=true;
|
|
CString listStr;
|
|
CString listBase;
|
|
PSCE_PRIVILEGE_ASSIGNMENT pPriv = 0;
|
|
PSCE_PRIVILEGE_ASSIGNMENT pPrivBase = 0;
|
|
UINT i = 0;
|
|
|
|
switch (type)
|
|
{
|
|
case POLICY_KERBEROS_ANALYSIS:
|
|
case POLICY_PASSWORD_ANALYSIS:
|
|
case POLICY_LOCKOUT_ANALYSIS:
|
|
case POLICY_AUDIT_ANALYSIS:
|
|
case POLICY_OTHER_ANALYSIS:
|
|
case POLICY_LOG_ANALYSIS:
|
|
CreateAnalysisPolicyResultList(cookie,
|
|
type,
|
|
pSceInfo,
|
|
pBase,
|
|
pDataObj);
|
|
break;
|
|
|
|
case AREA_POLICY_ANALYSIS:
|
|
break;
|
|
|
|
case AREA_PRIVILEGE_ANALYSIS:
|
|
{
|
|
// find in the current setting list
|
|
TCHAR szDisp[255];
|
|
DWORD cbDisp = 0;
|
|
for (pPriv=pSceInfo->pTemplate->OtherInfo.sap.pPrivilegeAssignedTo;
|
|
pPriv!=NULL;
|
|
pPriv=pPriv->Next)
|
|
{
|
|
|
|
// find in the base setting list
|
|
for (pPrivBase=pBase->pTemplate->OtherInfo.smp.pPrivilegeAssignedTo;
|
|
pPrivBase!=NULL;
|
|
pPrivBase=pPrivBase->Next)
|
|
{
|
|
|
|
if ( pPrivBase->Value == pPriv->Value )
|
|
break;
|
|
}
|
|
|
|
|
|
cbDisp = 255;
|
|
GetRightDisplayName(NULL,(LPCTSTR)pPriv->Name,szDisp,&cbDisp);
|
|
|
|
if (pPrivBase == NULL)
|
|
{
|
|
pPrivBase = (PSCE_PRIVILEGE_ASSIGNMENT)ULongToPtr(SCE_NO_VALUE);
|
|
}
|
|
AddResultItem(szDisp, // The name of the attribute being added
|
|
(LONG_PTR)pPriv, // The last inspected setting of the attribute
|
|
(LONG_PTR)pPrivBase, // The template setting of the attribute
|
|
ITEM_PRIVS, // The type of of the attribute's data
|
|
pPriv->Status, // The mismatch status of the attribute
|
|
cookie, // The cookie for the result item pane
|
|
FALSE, // True if the setting is set only if it differs from base (so copy the data)
|
|
NULL, // The units the attribute is set in
|
|
0, // An id to let us know where to save this attribute
|
|
pBase, // The template to save this attribute in
|
|
pDataObj); // The data object for the scope note who owns the result pane
|
|
}
|
|
}
|
|
break;
|
|
|
|
case AREA_GROUPS_ANALYSIS:
|
|
{
|
|
PSCE_GROUP_MEMBERSHIP pGroup = 0;
|
|
PSCE_GROUP_MEMBERSHIP grpBase = 0;
|
|
|
|
//
|
|
// it is OK to start with pSceInfo because each group at least has
|
|
// PrivilegesHeld field not null.
|
|
//
|
|
bVerify = FALSE;
|
|
for (pGroup=pSceInfo->pTemplate->pGroupMembership; pGroup!=NULL; pGroup=pGroup->Next)
|
|
{
|
|
//
|
|
// find the base to compare with
|
|
//
|
|
|
|
if ( NULL == pGroup->GroupName )
|
|
continue;
|
|
|
|
for (grpBase=pBase->pTemplate->pGroupMembership; grpBase!=NULL;
|
|
grpBase=grpBase->Next)
|
|
{
|
|
if ( grpBase->GroupName &&
|
|
_wcsicmp(pGroup->GroupName, grpBase->GroupName) == 0 )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
AddResultItem((LPCTSTR)pGroup->GroupName, // The name of the attribute being added
|
|
GetGroupStatus(pGroup->Status, STATUS_GROUP_MEMBEROF), // The last inspected setting of the attribute
|
|
GetGroupStatus(pGroup->Status, STATUS_GROUP_MEMBERS), // The template setting of the attribute
|
|
ITEM_GROUP, // The type of of the attribute's data
|
|
GetGroupStatus(pGroup->Status, STATUS_GROUP_RECORD), // status // The mismatch status of the attribute
|
|
cookie, // The cookie for the result item pane
|
|
FALSE, // Copy last inspected from template
|
|
(LPTSTR)grpBase, //NULL, // The units the attribute is set in
|
|
(LONG_PTR)pGroup, // An id to let us know where to save this attribute
|
|
pBase, //pSceInfo, // The template to save this attribute in
|
|
pDataObj); // The data object for the scope note who owns the result pane
|
|
}
|
|
}
|
|
break;
|
|
|
|
case AREA_SERVICE_ANALYSIS:
|
|
// AddResultItem(L"Not Implemented", NULL, NULL, ITEM_OTHER, -1, cookie);
|
|
CreateAnalysisServiceResultList(cookie,
|
|
type,
|
|
pSceInfo,
|
|
pBase,
|
|
pDataObj);
|
|
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Method: CreateObjectResultList
|
|
//
|
|
// Synopsis: Create the result pane items for an Object section
|
|
//
|
|
// Arguments: [cookie] - The cookie representing the folder which we
|
|
// are enumerating
|
|
// [type] - The type of the folder we are enumerating
|
|
// [Area] - The SCE Area we're enumerating
|
|
// [pObjList] - The array of object to enumerate
|
|
// [pHandle] -
|
|
// [pDataObj] - The data object for the folder we're enumerating
|
|
//
|
|
// Returns: none
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
void CSnapin::CreateObjectResultList(MMC_COOKIE cookie,
|
|
FOLDER_TYPES type,
|
|
AREA_INFORMATION Area,
|
|
PSCE_OBJECT_CHILDREN pObjList,
|
|
PVOID pHandle,
|
|
LPDATAOBJECT pDataObj )
|
|
{
|
|
if ( pObjList == NULL )
|
|
{
|
|
//
|
|
// no object to add
|
|
//
|
|
return;
|
|
}
|
|
|
|
PWSTR ObjSetting=NULL;
|
|
PWSTR ObjBase=NULL;
|
|
CString tmpstr;
|
|
LPTSTR szPath = NULL;
|
|
|
|
RESULT_TYPES rsltType;
|
|
if ( Area == AREA_REGISTRY_SECURITY)
|
|
rsltType = ITEM_REGSD;
|
|
else if ( Area == AREA_FILE_SECURITY )
|
|
rsltType = ITEM_FILESD;
|
|
else
|
|
{
|
|
ASSERT(FALSE);
|
|
return;
|
|
}
|
|
|
|
PSCE_OBJECT_CHILDREN_NODE *pObjNode=&(pObjList->arrObject);
|
|
|
|
for (DWORD i=0; i<pObjList->nCount; i++)
|
|
{
|
|
BOOL bContainer = FALSE;
|
|
CString strName;
|
|
|
|
if ( pObjNode[i] == NULL ||
|
|
pObjNode[i]->Name == NULL )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (AREA_FILE_SECURITY == Area)
|
|
{
|
|
DWORD dw = (DWORD)-1;
|
|
|
|
strName = ((CFolder *)cookie)->GetName();
|
|
if (strName.Right(1) != L"\\")
|
|
{
|
|
strName += L"\\";
|
|
}
|
|
strName += pObjNode[i]->Name;
|
|
dw = GetFileAttributes(strName);
|
|
if ((DWORD)-1 == dw)
|
|
{
|
|
//
|
|
// GetFileAttributes should never fail, but in case it does assume
|
|
// that this isn't a container (this matches CreateFolderList)
|
|
//
|
|
bContainer = FALSE;
|
|
}
|
|
else
|
|
{
|
|
bContainer = dw & FILE_ATTRIBUTE_DIRECTORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bContainer = FALSE;
|
|
}
|
|
if ( !bContainer )
|
|
{
|
|
//
|
|
// only add the leaf objects in result pane.
|
|
// non-leaf objects are added to the scope pane already
|
|
//
|
|
PEDITTEMPLATE pBaseObject=NULL;
|
|
|
|
if ( type == REG_OBJECTS ||
|
|
type == FILE_OBJECTS )
|
|
{
|
|
tmpstr = ((CFolder*)cookie)->GetName();
|
|
if (tmpstr.Right(1) != L"\\")
|
|
{
|
|
tmpstr += L"\\";
|
|
}
|
|
tmpstr += pObjNode[i]->Name;
|
|
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// shouldn't get here
|
|
//
|
|
tmpstr = TEXT("");
|
|
}
|
|
|
|
szPath = (LPTSTR) malloc((tmpstr.GetLength()+1) * sizeof(TCHAR));
|
|
if (szPath)
|
|
{
|
|
lstrcpy(szPath,tmpstr.GetBuffer(2));
|
|
|
|
AddResultItem(pObjNode[i]->Name, // The name of the attribute being added
|
|
NULL, // The last inspected setting of the attribute
|
|
NULL, // The template setting of the attribute
|
|
rsltType, // The type of of the attribute's data
|
|
pObjNode[i]->Status,// The mismatch status of the attribute
|
|
cookie, // The cookie for the result item pane
|
|
FALSE, // True if the setting is set only if it differs from base (so copy the data)
|
|
szPath, // The units the attribute is set in
|
|
(LONG_PTR)pHandle, // An id to let us know where to save this attribute
|
|
pBaseObject, // The template to save this attribute in
|
|
pDataObj); // The data object for the scope note who owns the result pane
|
|
}
|
|
else
|
|
{
|
|
// Out of memory
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Method: AddResultItem
|
|
//
|
|
// Synopsis: Add an item to the result pane from a string resource
|
|
//
|
|
// Arguments: [rID] - The resource id of name of the attribute being added
|
|
// [setting] - The last inspected setting of the attribute
|
|
// [base] - The template setting of the attribute
|
|
// [type] - The type of of the attribute's data
|
|
// [status] - The mismatch status of the attribute
|
|
// [cookie] - The cookie for the result item pane
|
|
// [bVerify] - True if the setting is set only if it differs
|
|
// from base (so copy the data)
|
|
// [pBaseInfo] - The template to save this attribute in
|
|
// [pDataObj] - The data object for the scope note who owns the result pane
|
|
//
|
|
// Returns: a pointer to the CResult created to hold the item
|
|
//
|
|
// History:
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
CResult* CSnapin::AddResultItem(UINT rID,
|
|
LONG_PTR setting,
|
|
LONG_PTR base,
|
|
RESULT_TYPES type,
|
|
int status,
|
|
MMC_COOKIE cookie,
|
|
BOOL bVerify,
|
|
PEDITTEMPLATE pBaseInfo,
|
|
LPDATAOBJECT pDataObj)
|
|
{
|
|
CString strRes;
|
|
strRes.LoadString(rID);
|
|
|
|
if (!strRes)
|
|
return NULL;
|
|
|
|
|
|
LPCTSTR Attrib = 0;
|
|
LPCTSTR unit=NULL;
|
|
|
|
//
|
|
// The unit for the attribute is stored in the resource after a \n
|
|
//
|
|
int npos = strRes.ReverseFind(L'\n');
|
|
if ( npos > 0 )
|
|
{
|
|
Attrib = strRes.GetBufferSetLength(npos);
|
|
unit = (LPCTSTR)strRes+npos+1;
|
|
}
|
|
else
|
|
{
|
|
Attrib = (LPCTSTR)strRes;
|
|
}
|
|
|
|
return AddResultItem(Attrib,setting,base,type,status,cookie,bVerify,unit,rID,pBaseInfo,pDataObj);
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Method: AddResultItem
|
|
//
|
|
// Synopsis: Add an item to the result pane
|
|
//
|
|
// Arguments: [Attrib] - The name of the attribute being added
|
|
// [setting] - The last inspected setting of the attribute
|
|
// [base] - The template setting of the attribute
|
|
// [type] - The type of of the attribute's data
|
|
// [status] - The mismatch status of the attribute
|
|
// [cookie] - The cookie for the result item pane
|
|
// [bVerify] - True if the setting is set only if it differs
|
|
// from base (so copy the data)
|
|
// [unit] - The units the attribute is set in
|
|
// [nID] - An id to let us know where to save this attribute
|
|
// [pBaseInfo] - The template to save this attribute in
|
|
// [pDataObj] - The data object for the scope note who owns the result pane
|
|
//
|
|
// Returns: a pointer to the CResult created to hold the item
|
|
//
|
|
// History:
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
CResult* CSnapin::AddResultItem(LPCTSTR Attrib,
|
|
LONG_PTR setting,
|
|
LONG_PTR base,
|
|
RESULT_TYPES type,
|
|
int status,
|
|
MMC_COOKIE cookie,
|
|
BOOL bVerify,
|
|
LPCTSTR unit,
|
|
LONG_PTR nID,
|
|
PEDITTEMPLATE pBaseInfo,
|
|
LPDATAOBJECT pDataObj,
|
|
CResult *pResult)
|
|
{
|
|
if ( bVerify )
|
|
{
|
|
if ( (LONG_PTR)SCE_NOT_ANALYZED_VALUE == setting )
|
|
{
|
|
//
|
|
// The setting was changed but has not been analyzed.
|
|
//
|
|
status = SCE_STATUS_NOT_ANALYZED;
|
|
}
|
|
else if ( base == (LONG_PTR)ULongToPtr(SCE_NO_VALUE) ||
|
|
(BYTE)base == (BYTE)SCE_NO_VALUE )
|
|
{
|
|
//
|
|
// The setting is no longer configured.
|
|
//
|
|
status = SCE_STATUS_NOT_CONFIGURED;
|
|
|
|
}
|
|
else if ( !(m_pSelectedFolder->GetModeBits() & MB_LOCAL_POLICY) &&
|
|
(setting == (LONG_PTR)ULongToPtr(SCE_NO_VALUE) ||
|
|
(BYTE)setting == (BYTE)SCE_NO_VALUE ))
|
|
{
|
|
// add the base for current setting
|
|
setting = base;
|
|
status = SCE_STATUS_GOOD; // a good item
|
|
|
|
}
|
|
else if ( setting != base )
|
|
status = SCE_STATUS_MISMATCH;
|
|
else
|
|
status = SCE_STATUS_GOOD;
|
|
}
|
|
|
|
CResult* pNewResult = pResult;
|
|
if (!pNewResult)
|
|
{
|
|
pNewResult = new CResult();
|
|
// refCount is already 1 // result->AddRef();
|
|
}
|
|
|
|
ASSERT(pNewResult);
|
|
|
|
if ( pNewResult )
|
|
{
|
|
pNewResult->Create(Attrib,
|
|
base,
|
|
setting,
|
|
type,
|
|
status,
|
|
cookie,
|
|
unit,
|
|
nID,
|
|
pBaseInfo,
|
|
pDataObj,
|
|
m_pNotifier,
|
|
this);
|
|
|
|
if (!pResult)
|
|
{
|
|
m_pSelectedFolder->AddResultItem (
|
|
m_resultItemHandle,
|
|
pNewResult);
|
|
}
|
|
}
|
|
return pNewResult;
|
|
}
|
|
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Method: AddResultItem
|
|
//
|
|
// Synopsis: Add a group item to the analysis section result pane.
|
|
// This adds three actual result pane items:
|
|
// 1) The actual name of the group
|
|
// 2) The members of the group
|
|
// 3) The groups this group is a member of
|
|
//
|
|
// Arguments: [szName] - The name of the group being added
|
|
// [grpTemplate] - The last inspected setting of the attribute
|
|
// [grpInspecte] - The template setting of the attribute
|
|
// [cookie] - The cookie IDing the result pane item
|
|
// [pDataObj] - The data object for the scope pane item
|
|
//
|
|
// History:
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
void CSnapin::AddResultItem(LPCTSTR szName,
|
|
PSCE_GROUP_MEMBERSHIP grpTemplate,
|
|
PSCE_GROUP_MEMBERSHIP grpInspect,
|
|
MMC_COOKIE cookie,
|
|
LPDATAOBJECT pDataObj)
|
|
{
|
|
//
|
|
// This area contains MAX_ITEM_ID_INDEX(3) linked result lines:
|
|
// Group Name
|
|
// Members: Template Last Inspected
|
|
// Membership: Template Last Inspected
|
|
//comment out Privileges: Template Last Inspected
|
|
//
|
|
if ( !grpInspect || !szName || !cookie )
|
|
{
|
|
ASSERT(FALSE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// pResults & hResultItems are needed to link the lines together
|
|
//
|
|
typedef CResult *PRESULT;
|
|
PRESULT pResults[3];
|
|
HRESULTITEM hResultItems[3];
|
|
int status = 0;
|
|
|
|
|
|
//
|
|
// add one entry for the group name
|
|
//
|
|
if ( grpInspect->Status & SCE_GROUP_STATUS_NOT_ANALYZED )
|
|
status = SCE_STATUS_NOT_CONFIGURED;
|
|
else
|
|
status = -1;
|
|
|
|
pResults[0]= AddResultItem(szName, // The name of the attribute being added
|
|
(LONG_PTR)grpInspect, // The last inspected setting of the attribute
|
|
(LONG_PTR)grpTemplate, // The template setting of the attribute
|
|
ITEM_GROUP, // The type of of the attribute's data
|
|
status, // The mismatch status of the attribute
|
|
cookie, // The cookie for the result item pane
|
|
FALSE, // True if the setting is set only if it differs from base (so copy the data)
|
|
NULL, // The units the attribute is set in
|
|
NULL, // An id to let us know where to save this attribute
|
|
(CEditTemplate *)szName, // The template to save this attribute in
|
|
pDataObj); // The data object for the scope note who owns the result pane
|
|
|
|
//
|
|
// L" -- Members"
|
|
//
|
|
status = grpInspect->Status;
|
|
if ( status & SCE_GROUP_STATUS_NOT_ANALYZED ||
|
|
status & SCE_GROUP_STATUS_NC_MEMBERS )
|
|
{
|
|
status = SCE_STATUS_NOT_CONFIGURED;
|
|
}
|
|
else if ( status & SCE_GROUP_STATUS_MEMBERS_MISMATCH )
|
|
{
|
|
status = SCE_STATUS_MISMATCH;
|
|
}
|
|
else
|
|
status = SCE_STATUS_GOOD;
|
|
|
|
pResults[1] = AddResultItem(IDS_GRP_MEMBERS,
|
|
(LONG_PTR)grpInspect,
|
|
(LONG_PTR)grpTemplate,
|
|
ITEM_GROUP_MEMBERS,
|
|
status,
|
|
cookie,
|
|
false,
|
|
(PEDITTEMPLATE)szName,
|
|
pDataObj);
|
|
|
|
//
|
|
// L" -- Membership"
|
|
//
|
|
status = grpInspect->Status;
|
|
if ( status & SCE_GROUP_STATUS_NOT_ANALYZED ||
|
|
status & SCE_GROUP_STATUS_NC_MEMBEROF )
|
|
{
|
|
status = SCE_STATUS_NOT_CONFIGURED;
|
|
}
|
|
else if ( status & SCE_GROUP_STATUS_MEMBEROF_MISMATCH )
|
|
{
|
|
status = SCE_STATUS_MISMATCH;
|
|
}
|
|
else
|
|
status = SCE_STATUS_GOOD;
|
|
|
|
pResults[2] = AddResultItem(IDS_GRP_MEMBEROF,
|
|
(LONG_PTR)grpInspect,
|
|
(LONG_PTR)grpTemplate,
|
|
ITEM_GROUP_MEMBEROF,
|
|
status,
|
|
cookie,
|
|
false,
|
|
(PEDITTEMPLATE)szName,
|
|
pDataObj);
|
|
//
|
|
// save the relative cookies
|
|
//
|
|
if ( pResults[0] )
|
|
pResults[0]->SetRelativeCookies((MMC_COOKIE)pResults[1], (MMC_COOKIE)pResults[2]);
|
|
|
|
if ( pResults[1] )
|
|
pResults[1]->SetRelativeCookies((MMC_COOKIE)pResults[0], (MMC_COOKIE)pResults[2]);
|
|
|
|
if ( pResults[2] )
|
|
pResults[2]->SetRelativeCookies((MMC_COOKIE)pResults[0], (MMC_COOKIE)pResults[1]);
|
|
|
|
}
|
|
|
|
void CSnapin::DeleteList (BOOL bDeleteResultItem)
|
|
{
|
|
POSITION pos = NULL;
|
|
if (m_pSelectedFolder && m_resultItemHandle)
|
|
{
|
|
CResult *pResult = 0;
|
|
|
|
do {
|
|
if( m_pSelectedFolder->GetResultItem(
|
|
m_resultItemHandle,
|
|
pos,
|
|
&pResult) != ERROR_SUCCESS)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if ( pResult )
|
|
{
|
|
if ( bDeleteResultItem )
|
|
{
|
|
HRESULTITEM hItem = NULL;
|
|
if( S_OK == m_pResult->FindItemByLParam((LPARAM)m_pResult, &hItem ))
|
|
{
|
|
if(hItem)
|
|
{
|
|
m_pResult->DeleteItem(hItem, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
break;
|
|
} while( pos );
|
|
|
|
//
|
|
// Release the hold on this object.
|
|
//
|
|
m_pSelectedFolder->ReleaseResultItemHandle( m_resultItemHandle );
|
|
m_resultItemHandle = NULL;
|
|
m_pSelectedFolder = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Function: OnUpdateView
|
|
//
|
|
// Synopsis: If the updated view is being shown by this CSnapin then
|
|
// clear out the old view and redisplay it with the new info
|
|
//
|
|
// Arguments: [lpDataObject] - unused
|
|
// [data] - the cookie for the folder being updated
|
|
// [hint] - unused
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
HRESULT
|
|
CSnapin::OnUpdateView(LPDATAOBJECT lpDataObject,LPARAM data, LPARAM hint )
|
|
{
|
|
if (lpDataObject == (LPDATAOBJECT)this)
|
|
return S_OK;
|
|
|
|
CResult *pResult = (CResult *)data;
|
|
HRESULTITEM hRItem = NULL;
|
|
RESULTDATAITEM resultItem;
|
|
HRESULT hr = m_pResult->FindItemByLParam( (LPARAM)pResult, &hRItem );
|
|
POSITION pos = NULL;
|
|
|
|
switch(hint)
|
|
{
|
|
case UAV_RESULTITEM_UPDATEALL:
|
|
//
|
|
// The caller is responsible for clearing the result items from this
|
|
// this will invalidate all references to the folder object. Because of
|
|
// this we have to make sure the reference counter is updated correctly,
|
|
// so for every CSnapin object GetResultITemHandle is called so that we
|
|
// don't delete the list when it is still needed.
|
|
//
|
|
if(data != (LPARAM)m_pSelectedFolder && (CFolder*)data != NULL)
|
|
{
|
|
//Raid #258237, 4/12/2001
|
|
CFolder* pCurFolder = (CFolder*)data;
|
|
if( !pCurFolder->GetViewUpdate() )
|
|
return S_OK;
|
|
CFolder* pOldFolder = m_pSelectedFolder;
|
|
pCurFolder->SetViewUpdate(FALSE);
|
|
if( !pCurFolder->GetResultListCount() )
|
|
{
|
|
EnumerateResultPane(
|
|
(MMC_COOKIE)pCurFolder,
|
|
pCurFolder->GetScopeItem()->ID,
|
|
NULL
|
|
);
|
|
m_pSelectedFolder = pOldFolder;
|
|
}
|
|
}
|
|
if( m_pSelectedFolder->GetViewUpdate() )
|
|
m_pSelectedFolder->SetViewUpdate(FALSE);
|
|
|
|
m_pResult->DeleteAllRsltItems();
|
|
|
|
if( !m_pSelectedFolder->GetResultListCount() )
|
|
{
|
|
//
|
|
// This should only be called by the first CSnapin who recieves this message.
|
|
//
|
|
EnumerateResultPane(
|
|
(MMC_COOKIE)m_pSelectedFolder,
|
|
m_pSelectedFolder->GetScopeItem()->ID,
|
|
NULL
|
|
);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
m_pSelectedFolder->GetResultItemHandle(
|
|
&m_resultItemHandle);
|
|
}
|
|
break;
|
|
|
|
case UAV_RESULTITEM_REDRAWALL:
|
|
if( data != (LPARAM)m_pSelectedFolder )
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
m_pResult->DeleteAllRsltItems();
|
|
|
|
ZeroMemory(&resultItem,sizeof(resultItem));
|
|
resultItem.mask = RDI_STR | RDI_IMAGE | RDI_PARAM;
|
|
resultItem.str = MMC_CALLBACK;
|
|
resultItem.nImage = -1; // equivalent to: MMC_CALLBACK;
|
|
|
|
pos = NULL;
|
|
|
|
m_pResult->SetItemCount(
|
|
m_pSelectedFolder->GetResultListCount( ),
|
|
MMCLV_UPDATE_NOINVALIDATEALL);
|
|
|
|
do {
|
|
m_pSelectedFolder->GetResultItem(
|
|
m_resultItemHandle,
|
|
pos,
|
|
(CResult **)&(resultItem.lParam));
|
|
if(resultItem.lParam)
|
|
{
|
|
m_pResult->InsertItem( &resultItem );
|
|
}
|
|
} while(pos);
|
|
|
|
m_pResult->Sort(0, 0, 0);
|
|
break;
|
|
|
|
case UAV_RESULTITEM_ADD:
|
|
//
|
|
// This adds a CResult item to the result pane, if and only if the item
|
|
// does not already exist withen the pane.
|
|
//
|
|
if(!m_pSelectedFolder ||
|
|
!m_pSelectedFolder->GetResultItemPosition(
|
|
m_resultItemHandle,
|
|
pResult) ||
|
|
hRItem )
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
ZeroMemory(&resultItem,sizeof(resultItem));
|
|
resultItem.mask = RDI_STR | RDI_IMAGE | RDI_PARAM;
|
|
resultItem.str = MMC_CALLBACK;
|
|
resultItem.nImage = -1; // equivalent to: MMC_CALLBACK;
|
|
|
|
resultItem.lParam = (LPARAM)pResult;
|
|
m_pResult->InsertItem( &resultItem );
|
|
m_pResult->Sort(0, 0, 0);
|
|
break;
|
|
|
|
case UAV_RESULTITEM_REMOVE:
|
|
//
|
|
// This removes the HRESULTITEM associated with the CResult item passed in
|
|
// through the data member.
|
|
//
|
|
if(hRItem)
|
|
m_pResult->DeleteItem( hRItem, 0 );
|
|
break;
|
|
|
|
default:
|
|
//
|
|
// By default we just repaint the item.
|
|
//
|
|
m_pResult->UpdateItem( hRItem );
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
} |