dubey/WindowsXP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
WindowsXP/admin/wmi/wbem/sdk/activex/other/schemavalwiz/schemavalwizctl.cpp
Tanishq Dubey cb60ae51e5
Initial Commit
2025-04-27 07:49:33 -04:00

3483 lines
91 KiB
C++
Raw Blame History

// SchemaValWizCtl.cpp : Implementation of the CSchemaValWizCtrl ActiveX Control class.
// Copyright (c) 1997-2001 Microsoft Corporation, All Rights Reserved
#include "precomp.h"
#include "SchemaValWiz.h"
#include "Page.h"
#include "progress.h"
#include "Validation.h"
#include "WizardSheet.h"
#include "SchemaValWizCtl.h"
#include "SchemaValWizPpg.h"
#include "MsgDlgExterns.h"
//#include "htmlhelp.h"
//#include "HTMTopics.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
void ErrorMsg(CString *pcsUserMsg, SCODE sc, IWbemClassObject *pErrorObject, BOOL bLog,
CString *pcsLogMsg, char *szFile, int nLine, BOOL bNotification)
{
if(pcsUserMsg){
#ifndef _ERIC_PRIVATE
HWND hFocus = ::GetFocus();
CString csCaption = _T("Validation Wizard Message");
BOOL bErrorObject = sc != S_OK;
BSTR bstrTemp1 = csCaption.AllocSysString();
BSTR bstrTemp2 = pcsUserMsg->AllocSysString();
#endif //#ifdef _ERIC_PRIVATE
#ifdef _ERIC_PRIVATE
TCHAR cBuf[100];
#ifdef _UNICODE
AfxMessageBox(*pcsUserMsg + _T(": 0x") + _ltow(sc, cBuf, 16));
#else
AfxMessageBox(*pcsUserMsg + _T(": 0x") + _ltoa(sc, cBuf, 16));
#endif
#endif //#ifndef _ERIC_PRIVATE
#ifndef _ERIC_PRIVATE
DisplayUserMessage(bstrTemp1, bstrTemp2, sc, bErrorObject);
SysFreeString(bstrTemp1);
SysFreeString(bstrTemp2);
SendMessage(hFocus,WM_SETFOCUS,0,0);
if(bLog)LogMsg(pcsLogMsg, szFile, nLine);
#endif //#ifdef _ERIC_PRIVATE
}
}
void LogMsg(CString *pcsLogMsg, char *szFile, int nLine)
{
}
IMPLEMENT_DYNCREATE(CSchemaValWizCtrl, COleControl)
//////////////////////////////////////////////////////////////////////////////
// Global variables
long gCountWizards = 0;
extern CSchemaValWizApp NEAR theApp;
/////////////////////////////////////////////////////////////////////////////
// Message map
BEGIN_MESSAGE_MAP(CSchemaValWizCtrl, COleControl)
//{{AFX_MSG_MAP(CSchemaValWizCtrl)
ON_WM_CREATE()
ON_WM_LBUTTONDBLCLK()
ON_WM_LBUTTONDOWN()
ON_WM_LBUTTONUP()
ON_WM_MOUSEMOVE()
//}}AFX_MSG_MAP
ON_OLEVERB(AFX_IDS_VERB_EDIT, OnEdit)
ON_OLEVERB(AFX_IDS_VERB_PROPERTIES, OnProperties)
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// Dispatch map
BEGIN_DISPATCH_MAP(CSchemaValWizCtrl, COleControl)
//{{AFX_DISPATCH_MAP(CSchemaValWizCtrl)
DISP_PROPERTY_EX(CSchemaValWizCtrl, "SchemaTargets", GetSchemaTargets, SetSchemaTargets, VT_VARIANT)
//}}AFX_DISPATCH_MAP
DISP_FUNCTION_ID(CSchemaValWizCtrl, "AboutBox", DISPID_ABOUTBOX, AboutBox, VT_EMPTY, VTS_NONE)
END_DISPATCH_MAP()
/////////////////////////////////////////////////////////////////////////////
// Event map
BEGIN_EVENT_MAP(CSchemaValWizCtrl, COleControl)
//{{AFX_EVENT_MAP(CSchemaValWizCtrl)
EVENT_CUSTOM("GetIWbemServices", FireGetIWbemServices, VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT)
EVENT_CUSTOM("ValidateSchema", FireValidateSchema, VTS_NONE)
//}}AFX_EVENT_MAP
END_EVENT_MAP()
/////////////////////////////////////////////////////////////////////////////
// Property pages
// TODO: Add more property pages as needed. Remember to increase the count!
BEGIN_PROPPAGEIDS(CSchemaValWizCtrl, 1)
PROPPAGEID(CSchemaValWizPropPage::guid)
END_PROPPAGEIDS(CSchemaValWizCtrl)
/////////////////////////////////////////////////////////////////////////////
// Initialize class factory and guid
IMPLEMENT_OLECREATE_EX(CSchemaValWizCtrl, "SCHEMAVALWIZ.SchemaValWizCtrl.1",
0xe0112e2, 0xaf14, 0x11d2, 0xb2, 0xe, 0, 0xa0, 0xc9, 0x95, 0x49, 0x21)
/////////////////////////////////////////////////////////////////////////////
// Type library ID and version
IMPLEMENT_OLETYPELIB(CSchemaValWizCtrl, _tlid, _wVerMajor, _wVerMinor)
/////////////////////////////////////////////////////////////////////////////
// Interface IDs
const IID BASED_CODE IID_DSchemaValWiz =
{ 0xe0112e0, 0xaf14, 0x11d2, { 0xb2, 0xe, 0, 0xa0, 0xc9, 0x95, 0x49, 0x21 } };
const IID BASED_CODE IID_DSchemaValWizEvents =
{ 0xe0112e1, 0xaf14, 0x11d2, { 0xb2, 0xe, 0, 0xa0, 0xc9, 0x95, 0x49, 0x21 } };
/////////////////////////////////////////////////////////////////////////////
// Control type information
static const DWORD BASED_CODE _dwSchemaValWizOleMisc =
OLEMISC_ACTIVATEWHENVISIBLE |
OLEMISC_SETCLIENTSITEFIRST |
OLEMISC_INSIDEOUT |
OLEMISC_CANTLINKINSIDE |
OLEMISC_RECOMPOSEONRESIZE;
IMPLEMENT_OLECTLTYPE(CSchemaValWizCtrl, IDS_SCHEMAVALWIZ, _dwSchemaValWizOleMisc)
/////////////////////////////////////////////////////////////////////////////
// CSchemaValWizCtrl::CSchemaValWizCtrlFactory::UpdateRegistry -
// Adds or removes system registry entries for CSchemaValWizCtrl
BOOL CSchemaValWizCtrl::CSchemaValWizCtrlFactory::UpdateRegistry(BOOL bRegister)
{
// TODO: Verify that your control follows apartment-model threading rules.
// Refer to MFC TechNote 64 for more information.
// If your control does not conform to the apartment-model rules, then
// you must modify the code below, changing the 6th parameter from
// afxRegInsertable | afxRegApartmentThreading to afxRegInsertable.
if (bRegister)
return AfxOleRegisterControlClass(
AfxGetInstanceHandle(),
m_clsid,
m_lpszProgID,
IDS_SCHEMAVALWIZ,
IDB_SCHEMAVALWIZ,
afxRegInsertable | afxRegApartmentThreading,
_dwSchemaValWizOleMisc,
_tlid,
_wVerMajor,
_wVerMinor);
else
return AfxOleUnregisterClass(m_clsid, m_lpszProgID);
}
/////////////////////////////////////////////////////////////////////////////
// CSchemaValWizCtrl::CSchemaValWizCtrl - Constructor
CSchemaValWizCtrl::CSchemaValWizCtrl()
{
InitializeIIDs(&IID_DSchemaValWiz, &IID_DSchemaValWizEvents);
SetInitialSize (18, 16);
m_bInitDraw = TRUE;
m_pcilImageList = NULL;
m_nImage = 0;
m_pNamespace = NULL;
m_bOpeningNamespace = false;
m_pWizardSheet = NULL;
// m_pcgsPropertySheet = NULL;
// m_pcsaInstances = NULL;
// m_csEndl = _T("\n");
// m_bUnicode = FALSE;
// m_pfOut = NULL;
}
/////////////////////////////////////////////////////////////////////////////
// CSchemaValWizCtrl::~CSchemaValWizCtrl - Destructor
CSchemaValWizCtrl::~CSchemaValWizCtrl()
{
m_csaAssociations.RemoveAll();
m_csaRootObjects.RemoveAll();
m_csaClassNames.RemoveAll();
}
/////////////////////////////////////////////////////////////////////////////
// CSchemaValWizCtrl::OnDraw - Drawing function
void CSchemaValWizCtrl::OnDraw(
CDC* pdc, const CRect& rcBounds, const CRect& rcInvalid)
{
if (m_bInitDraw){
m_bInitDraw = FALSE;
HICON m_hSchemaWiz = theApp.LoadIcon(IDI_SCHEMAVAL16);
HICON m_hSchemaWizSel = theApp.LoadIcon(IDI_SCHEMAVALSEL16);
m_pcilImageList = new CImageList();
m_pcilImageList->Create(32, 32, TRUE, 2, 2);
m_pcilImageList->Add(m_hSchemaWiz);
m_pcilImageList->Add(m_hSchemaWizSel);
}
POINT pt;
pt.x=0;
pt.y=0;
m_pcilImageList -> Draw(pdc, m_nImage, pt, ILD_TRANSPARENT);
// TODO: Replace the following code with your own drawing code.
// pdc->FillRect(rcBounds, CBrush::FromHandle((HBRUSH)GetStockObject(WHITE_BRUSH)));
// pdc->Ellipse(rcBounds);
}
/////////////////////////////////////////////////////////////////////////////
// CSchemaValWizCtrl::DoPropExchange - Persistence support
void CSchemaValWizCtrl::DoPropExchange(CPropExchange* pPX)
{
ExchangeVersion(pPX, MAKELONG(_wVerMinor, _wVerMajor));
COleControl::DoPropExchange(pPX);
// TODO: Call PX_ functions for each persistent custom property.
}
/////////////////////////////////////////////////////////////////////////////
// CSchemaValWizCtrl::OnResetState - Reset control to default state
void CSchemaValWizCtrl::OnResetState()
{
COleControl::OnResetState(); // Resets defaults found in DoPropExchange
// TODO: Reset any other control state here.
}
/////////////////////////////////////////////////////////////////////////////
// CSchemaValWizCtrl::AboutBox - Display an "About" box to the user
void CSchemaValWizCtrl::AboutBox()
{
CDialog dlgAbout(IDD_ABOUTBOX_SCHEMAVALWIZ);
dlgAbout.DoModal();
}
/////////////////////////////////////////////////////////////////////////////
// CSchemaValWizCtrl message handlers
VARIANT CSchemaValWizCtrl::GetSchemaTargets()
{
VARIANT vaResult;
VariantInit(&vaResult);
// TODO: Add your property handler here
return vaResult;
}
void CSchemaValWizCtrl::SetSchemaTargets(const VARIANT FAR& newValue)
{
m_bComplianceChecks = true;
m_bW2K = true;
m_bDeviceManagement = false;
m_bComputerSystemManagement = false;
m_bLocalizationChecks = true;
m_bAssociators = false;
m_bDescendents = false;
m_bList = false;
m_bSchema = false;
int n = m_csaClassNames.GetSize();
m_csaClassNames.RemoveAt(0,n);
CString csPath;
WORD test = VT_ARRAY|VT_BSTR;
if(V_VT(&newValue) == test){
long ix[2] = {0,0};
long lLower, lUpper;
int iDim = SafeArrayGetDim(newValue.parray);
HRESULT hr = SafeArrayGetLBound(newValue.parray, 1, &lLower);
hr = SafeArrayGetUBound(newValue.parray, 1, &lUpper);
if(lUpper == 0) m_bList = false;
else m_bList = true;
ix[0] = lLower++;
GetStringFromSafeArray(newValue.parray, &m_csNamespace, ix[0]);
if(m_csNamespace.GetLength() <= 0)
{
CString csUserMsg = _T("To use this tool you must first log into a namespace.");
ErrorMsg(&csUserMsg, NULL, NULL, TRUE, &csUserMsg, __FILE__, __LINE__ - 8);
SetFocus();
return;
}
m_pNamespace = InitServices(&m_csNamespace);
if(!m_pNamespace){
CString csUserMsg = _T("ConnectServer failure for ") + m_csNamespace;
ErrorMsg(&csUserMsg, m_hr, NULL, TRUE, &csUserMsg, __FILE__, __LINE__ - 8);
SetFocus();
return;
}
for(ix[0] = lLower; ix[0] <= lUpper; ix[0]++){
GetStringFromSafeArray(newValue.parray, &csPath, ix[0]);
IWbemClassObject *pObj = NULL;
IWbemClassObject *pErrorObj = NULL;
BSTR bstrTemp = csPath.AllocSysString();
HRESULT hr = m_pNamespace->GetObject(bstrTemp, 0, NULL, &pObj, NULL);
SysFreeString(bstrTemp);
if(SUCCEEDED(hr)){
CString csClass = GetClassName(pObj);
m_csaClassNames.Add(csClass);
pObj->Release();
ReleaseErrorObject(pErrorObj);
}else{
CString csUserMsg = _T("Cannot get object ") + csPath;
ErrorMsg(&csUserMsg, hr, pErrorObj, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObj);
}
}
}
BOOL bReturn = FALSE;
if((bReturn = OnWizard(&m_csaClassNames)) == FALSE){
if(m_pNamespace){
m_pNamespace->Release();
m_pNamespace = NULL;
}
SetFocus();
return;
}else{
FinishValidateTargets();
SetFocus();
}
SetFocus();
// SetModifiedFlag();
}
BOOL CSchemaValWizCtrl::OnWizard(CStringArray *pcsaClasses)
{
if(InterlockedIncrement(&gCountWizards) > 1){
CString csUserMsg = _T("Only one \"MOF Generator Wizard\" can run at a time.");
ErrorMsg(&csUserMsg, S_OK, NULL, TRUE, &csUserMsg, __FILE__, __LINE__);
InterlockedDecrement(&gCountWizards);
return FALSE;
}
if(m_pWizardSheet){
delete m_pWizardSheet;
m_pWizardSheet = NULL;
}
m_pWizardSheet = new CWizardSheet(this);
PreModalDialog();
int nReturn = m_pWizardSheet->DoModal();
PostModalDialog();
InterlockedDecrement(&gCountWizards);
if (nReturn == ID_WIZFINISH) return TRUE;
else{
delete m_pWizardSheet;
m_pWizardSheet = NULL;
return FALSE;
}
}
HRESULT CSchemaValWizCtrl::GetSDKDirectory(CString &sHmomWorkingDir)
{
sHmomWorkingDir.Empty();
HKEY hkeyLocalMachine;
LONG lResult;
lResult = RegConnectRegistry(NULL, HKEY_LOCAL_MACHINE, &hkeyLocalMachine);
if (lResult != ERROR_SUCCESS) {
return E_FAIL;
}
HKEY hkeyHmomCwd;
lResult = RegOpenKeyEx(
hkeyLocalMachine,
_T("SOFTWARE\\Microsoft\\WBEM"),
0,
KEY_READ | KEY_QUERY_VALUE,
&hkeyHmomCwd);
if (lResult != ERROR_SUCCESS) {
RegCloseKey(hkeyLocalMachine);
return E_FAIL;
}
unsigned long lcbValue = 1024;
LPTSTR pszWorkingDir = sHmomWorkingDir.GetBuffer(lcbValue);
unsigned long lType;
lResult = RegQueryValueEx(
hkeyHmomCwd,
_T("SDK Directory"),
NULL,
&lType,
(unsigned char*) (void*) pszWorkingDir,
&lcbValue);
sHmomWorkingDir.ReleaseBuffer();
RegCloseKey(hkeyHmomCwd);
RegCloseKey(hkeyLocalMachine);
if (lResult != ERROR_SUCCESS) {
sHmomWorkingDir.Empty();
return E_FAIL;
}
return S_OK;
}
void CSchemaValWizCtrl::RelayEvent(UINT message, WPARAM wParam, LPARAM lParam)
{
if (NULL != m_ttip.m_hWnd)
{
MSG msg;
msg.hwnd= m_hWnd;
msg.message= message;
msg.wParam= wParam;
msg.lParam= lParam;
msg.time= 0;
msg.pt.x= LOWORD (lParam);
msg.pt.y= HIWORD (lParam);
m_ttip.RelayEvent(&msg);
}
}
void CSchemaValWizCtrl::OnMouseMove(UINT nFlags, CPoint point)
{
RelayEvent(WM_MOUSEMOVE, (WPARAM)nFlags,
MAKELPARAM(LOWORD(point.x), LOWORD(point.y)));
COleControl::OnMouseMove(nFlags, point);
}
int CSchemaValWizCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (COleControl::OnCreate(lpCreateStruct) == -1)
return -1;
if (AmbientUserMode( ))
{
m_pNamespace = NULL;
if (m_ttip.Create(this))
{
m_ttip.Activate(TRUE);
m_ttip.AddTool(this, _T("Schema Validation Tool"));
}
}
return 0;
return 0;
}
void CSchemaValWizCtrl::OnLButtonDblClk(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
FireValidateSchema();
COleControl::OnLButtonDblClk(nFlags, point);
}
void CSchemaValWizCtrl::OnLButtonDown(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
// RelayEvent(WM_LBUTTONDOWN, (WPARAM)nFlags, MAKELPARAM(LOWORD(point.x), LOWORD(point.y)));
COleControl::OnLButtonDown(nFlags, point);
}
void CSchemaValWizCtrl::OnLButtonUp(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
// SetFocus();
// OnActivateInPlace(TRUE,NULL);
// RelayEvent(WM_LBUTTONUP, (WPARAM)nFlags, MAKELPARAM(LOWORD(point.x), LOWORD(point.y)));
COleControl::OnLButtonUp(nFlags, point);
}
IWbemServices * CSchemaValWizCtrl::InitServices(CString *pcsNameSpace)
{
IWbemServices *pSession = 0;
IWbemServices *pChild = 0;
CString csObjectPath;
// hook up to default namespace
if(pcsNameSpace == NULL) csObjectPath = _T("root\\cimv2");
else csObjectPath = *pcsNameSpace;
CString csUser = _T("");
pSession = GetIWbemServices(csObjectPath);
return pSession;
}
void CSchemaValWizCtrl::PassThroughGetIWbemServices
(LPCTSTR lpctstrNamespace, VARIANT FAR* pvarUpdatePointer, VARIANT FAR* pvarServices, VARIANT FAR* pvarSC, VARIANT FAR* pvarUserCancel)
{
FireGetIWbemServices
(lpctstrNamespace,
pvarUpdatePointer,
pvarServices,
pvarSC,
pvarUserCancel);
}
IWbemServices * CSchemaValWizCtrl::GetIWbemServices(CString &rcsNamespace)
{
IUnknown *pServices = NULL;
BOOL bUpdatePointer= FALSE;
m_hr = S_OK;
m_bUserCancel = FALSE;
VARIANT varUpdatePointer;
VariantInit(&varUpdatePointer);
varUpdatePointer.vt = VT_I4;
if(bUpdatePointer == TRUE) varUpdatePointer.lVal = 1;
else varUpdatePointer.lVal = 0;
VARIANT varService;
VariantInit(&varService);
VARIANT varSC;
VariantInit(&varSC);
VARIANT varUserCancel;
VariantInit(&varUserCancel);
FireGetIWbemServices((LPCTSTR)rcsNamespace, &varUpdatePointer, &varService, &varSC, &varUserCancel);
if(varService.vt & VT_UNKNOWN) pServices = reinterpret_cast<IWbemServices*>(varService.punkVal);
varService.punkVal = NULL;
VariantClear(&varService);
if (varSC.vt == VT_I4) m_hr = varSC.lVal;
else m_hr = WBEM_E_FAILED;
VariantClear(&varSC);
if (varUserCancel.vt == VT_BOOL) m_bUserCancel = varUserCancel.boolVal;
VariantClear(&varUserCancel);
VariantClear(&varUpdatePointer);
IWbemServices *pRealServices = NULL;
if (m_hr == S_OK && !m_bUserCancel) pRealServices = reinterpret_cast<IWbemServices *>(pServices);
return pRealServices;
}
HRESULT CSchemaValWizCtrl::MakeSafeArray(SAFEARRAY FAR ** pRet, VARTYPE vt, int iLen)
{
SAFEARRAYBOUND rgsabound[1];
rgsabound[0].lLbound = 0;
rgsabound[0].cElements = iLen;
*pRet = SafeArrayCreate(vt,1, rgsabound);
return (*pRet == NULL) ? 0x80000001 : S_OK;
}
HRESULT CSchemaValWizCtrl::PutStringInSafeArray(SAFEARRAY FAR * psa,CString *pcs, int iIndex)
{
long ix[2];
ix[1] = 0;
ix[0] = iIndex;
HRESULT hr = SafeArrayPutElement(psa,ix,pcs -> AllocSysString());
return hr;
}
HRESULT CSchemaValWizCtrl::GetStringFromSafeArray(SAFEARRAY FAR * psa,CString *pcs, int iIndex)
{
BSTR String;
long ix[2];
ix[1] = 0;
ix[0] = iIndex;
HRESULT hr = SafeArrayGetElement(psa,ix,&String);
*pcs = String;
SysFreeString(String);
return hr;
}
void CSchemaValWizCtrl::FinishValidateTargets()
{
m_pNamespace->Release();
m_pNamespace = NULL;
SetModifiedFlag();
}
HRESULT CSchemaValWizCtrl::ValidateSchema(CProgress *pProgress)
{
LONG lType;
HRESULT hr;
IWbemClassObject *pErrorObject = NULL;
m_iSubGraphs = 0;
m_iRootObjects = 0;
//display an hourglass
CWaitCursor *pCur = new CWaitCursor();
int iClasses = m_csaClassNames.GetSize();
//clear any previous log entries
g_ReportLog.DeleteAll();
m_csaAssociations.RemoveAll();
m_csaRootObjects.RemoveAll();
ClearQualifierArrays();
InitQualifierArrays();
m_pProgress = pProgress;
m_pProgress->ResetProgress(iClasses);
//Validation variable declarations
VARIANT v;
bool bUUID, bLocale, bDescription, bFound;
CString csRoot;
IWbemClassObject *pClass;
CString csClass;
BSTR bstrName;
CClass *pTheClass;
IWbemClassObject *pClassObj;
IWbemQualifierSet *pQualSet;
CString csClassQualName;
CQualifier *pClassQual;
BSTR bstrREFName;
LONG lFlavor;
CString csREFName;
CREF *pREF;
IWbemQualifierSet *pREFQualSet;
BSTR bstrREFQualName;
CString csREFQualName;
CQualifier *pREFQual;
BSTR bstrPropName;
CString csPropName;
CProperty *pProp;
IWbemQualifierSet *pPropQualSet;
BSTR bstrPropQualName;
CString csPropQualName;
CQualifier *pPropQual;
IWbemClassObject *pInParams;
IWbemClassObject *pOutParams;
BSTR bstrMethName;
BSTR bstrMethOrigin;
BSTR bstrClassName;
CString csMethodName;
CMethod *pMeth;
IWbemQualifierSet *pMethQualSet;
BSTR bstrMethQualName;
CString csMethQualName;
CQualifier *pMethQual;
IWbemQualifierSet *pMethParamQualSet;
BSTR bstrMethParamQualName;
CString csMethParamQualName;
CQualifier *pMethParamQual;
BSTR bstrParamName;
VariantInit(&v);
//main validation loop
for(int i = 0; i < iClasses; i++){
pClass = NULL;
csClass = m_csaClassNames.GetAt(i);
bstrName = csClass.AllocSysString();
if(FAILED(hr = m_pNamespace->GetObject(bstrName, WBEM_FLAG_USE_AMENDED_QUALIFIERS, NULL, &pClass, NULL))){
CString csUserMsg = _T("Unable to access ") + csClass + _T(" object.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
SysFreeString(bstrName);
ReleaseErrorObject(pErrorObject);
return hr;
}
SysFreeString(bstrName);
pTheClass = new CClass(&csClass, pClass, m_pNamespace);
if(m_bComplianceChecks){
//send the progress message
m_pProgress->SetCurrentProgress(i, &pTheClass->GetPath());
//////////////////////
// Class
//////////////////////
pTheClass->ValidClassName();
pCur->Restore();
pTheClass->VerifyClassType();
pCur->Restore();
if(pTheClass->IsAssociation()){
CString csAssoc = pTheClass->GetName();
m_csaAssociations.Add(csAssoc);
pTheClass->VerifyCompleteAssociation();
pCur->Restore();
pTheClass->ValidAssociationInheritence();
pCur->Restore();
}else{
pTheClass->VerifyNoREF();
pCur->Restore();
pTheClass->ValidAssociationInheritence();
pCur->Restore();
}
//////////////////////
// Class Qualifiers
//////////////////////
pClassObj = NULL;
pQualSet = NULL;
bstrName = NULL;
bUUID = bLocale = bDescription = false;
VariantClear(&v);
pClassObj = pTheClass->GetClassObject();
hr = pClassObj->GetQualifierSet(&pQualSet);
if(FAILED(hr = pQualSet->BeginEnumeration(0))){
CString csUserMsg = _T("A fatal error occurred while evaluating this schema.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
while((hr = pQualSet->Next(0, &bstrName, &v, &lType)) != WBEM_S_NO_MORE_DATA){
if(FAILED(hr)){
CString csUserMsg = _T("Unable to access ") + pTheClass->GetPath() + _T(" object.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
//Package qualifier
csClassQualName = bstrName;
pClassQual = new CQualifier(&csClassQualName, &v, lType, &pTheClass->GetPath());
SysFreeString(bstrName);
pClassQual->ValidScope(SCOPE_CLASS);
pCur->Restore();
if(csClassQualName.CompareNoCase(_T("UUID")) == 0){
ValidUUID(pClassQual);
pCur->Restore();
bUUID = true;
}
if(csClassQualName.CompareNoCase(_T("LOCALE")) == 0){
ValidLocale(pClassQual);
pCur->Restore();
bLocale = true;
}
if(csClassQualName.CompareNoCase(_T("MAPPINGSTRINGS")) == 0){
ValidMappingStrings(pClassQual);
pCur->Restore();
}
if(csClassQualName.CompareNoCase(_T("DESCRIPTION")) == 0){
ValidDescription(pClassQual, &pTheClass->GetPath());
pCur->Restore();
bDescription = true;
}
pClassQual->CleanUp();
delete pClassQual;
SysFreeString(bstrName);
VariantClear(&v);
}
if(!bUUID) g_ReportLog.LogEntry(EC_INVALID_CLASS_UUID, &pTheClass->GetPath());
if(!bLocale) g_ReportLog.LogEntry(EC_INVALID_CLASS_LOCALE, &pTheClass->GetPath());
if(!bDescription) g_ReportLog.LogEntry(EC_INADAQUATE_DESCRIPTION, &pTheClass->GetPath());
pQualSet->EndEnumeration();
pQualSet->Release();
pQualSet = NULL;
//////////////////////
// REF
//////////////////////
pClassObj = pTheClass->GetClassObject();
if(FAILED(hr = pClassObj->BeginEnumeration(WBEM_FLAG_REFS_ONLY | WBEM_FLAG_LOCAL_ONLY))){
CString csUserMsg = _T("A fatal error occurred while evaluating this schema.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
while((hr = pClassObj->Next(0, &bstrREFName, &v, &lType, &lFlavor)) != WBEM_S_NO_MORE_DATA){
if(FAILED(hr)){
CString csUserMsg = _T("Unable to access ") + csClass + _T(" object.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
//Here we'll create a REF object that holds everything
// pertaining to a particular REF.
csREFName = bstrREFName;
pREF = new CREF(&csREFName, &v, lType, lFlavor, pTheClass);
//send the progress message
pProgress->SetCurrentProgress(i, &pREF->GetPath());
//do all REF checks;
pREF->ValidReferenceTarget();
pCur->Restore();
pREF->ValidMaxLen();
pCur->Restore();
pREF->VerifyRead();
pCur->Restore();
pREF->ValidREFOverrides();
pCur->Restore();
//////////////////////
// REF Qualifiers
//////////////////////
pREFQualSet = NULL;
BSTR bstrName = NULL;
bDescription = false;
VariantClear(&v);
if(FAILED(hr = pClassObj->GetPropertyQualifierSet(bstrREFName, &pREFQualSet))){
CString csUserMsg = _T("A fatal error occurred while evaluating this schema.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
SysFreeString(bstrREFName);
if(FAILED(hr = pREFQualSet->BeginEnumeration(0))){
CString csUserMsg = _T("A fatal error occurred while evaluating this schema.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
while((hr = pREFQualSet->Next(0, &bstrREFQualName, &v, &lType)) != WBEM_S_NO_MORE_DATA){
if(FAILED(hr)){
CString csUserMsg = _T("Unable to access ") + pREF->GetPath() + _T(" object.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
csREFQualName = bstrREFQualName;
pREFQual = new CQualifier(&csREFQualName, &v, lType, &pREF->GetPath());
SysFreeString(bstrREFQualName);
//do all qualifierchecks;
pREFQual->ValidScope(SCOPE_REF);
pCur->Restore();
if(csREFQualName.CompareNoCase(_T("MAPPINGSTRINGS")) == 0){
ValidMappingStrings(pREFQual);
pCur->Restore();
}
if(csREFQualName.CompareNoCase(_T("DESCRIPTION")) == 0){
ValidDescription(pREFQual, &pREF->GetPath());
pCur->Restore();
bDescription = true;
}
pREFQual->CleanUp();
delete pREFQual;
VariantClear(&v);
}
if(!bDescription) g_ReportLog.LogEntry(EC_INADAQUATE_DESCRIPTION, &pREF->GetPath());
pREFQualSet->EndEnumeration();
pREFQualSet->Release();
pREFQualSet = NULL;
pREF->CleanUp();
delete pREF;
}//for each REF
pClassObj->EndEnumeration();
//////////////////////
// Property
//////////////////////
pClassObj = pTheClass->GetClassObject();
if(FAILED(hr = pClassObj->BeginEnumeration(WBEM_FLAG_LOCAL_ONLY))){
CString csUserMsg = _T("A fatal error occurred while evaluating this schema.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
pPropQualSet = NULL;
bstrPropQualName = NULL;
while((hr = pClassObj->Next(0, &bstrPropName, &v, &lType, &lFlavor)) != WBEM_S_NO_MORE_DATA){
if(FAILED(hr)){
CString csUserMsg = _T("Unable to access ") + csClass + _T(" object.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
if(lType != CIM_REFERENCE){
csPropName = bstrPropName;
pProp = new CProperty(&csPropName, &v, lType, lFlavor, pTheClass);
//send the progress message
pProgress->SetCurrentProgress(i, &pProp->GetPath());
pProp->ValidPropOverrides();
pCur->Restore();
pProp->ValidMaxLen();
pCur->Restore();
pProp->VerifyRead();
pCur->Restore();
pProp->ValueValueMapCheck();
pCur->Restore();
pProp->BitMapCheck();
pCur->Restore();
//////////////////////
// Property Qualifiers
//////////////////////
pPropQualSet = NULL;
bstrPropQualName = NULL;
bDescription = false;
VariantClear(&v);
if(FAILED(hr = pClassObj->GetPropertyQualifierSet(bstrPropName, &pPropQualSet))){
CString csUserMsg = _T("A fatal error occurred while evaluating this schema.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrPropName);
return hr;
}
SysFreeString(bstrPropName);
if(FAILED(hr = pPropQualSet->BeginEnumeration(0))){
CString csUserMsg = _T("A fatal error occurred while evaluating this schema.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
while((hr = pPropQualSet->Next(0, &bstrPropQualName, &v, &lType)) != WBEM_S_NO_MORE_DATA){
if(FAILED(hr)){
CString csUserMsg = _T("Unable to access ") + csClass + _T(" object.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
//Package qualifier
csPropQualName = bstrPropQualName;
pPropQual = new CQualifier(&csPropQualName, &v, lType, &pProp->GetPath());
SysFreeString(bstrPropQualName);
//do all qualifierchecks;
pPropQual->ValidScope(SCOPE_PROPERTY);
pCur->Restore();
if(csPropQualName.CompareNoCase(_T("MAPPINGSTRINGS")) == 0){
ValidMappingStrings(pPropQual);
pCur->Restore();
}
if(csPropQualName.CompareNoCase(_T("DESCRIPTION")) == 0){
ValidPropertyDescription(pPropQual, &pProp->GetPath(), &pProp->GetName());
pCur->Restore();
bDescription = true;
}
pPropQual->CleanUp();
delete pPropQual;
VariantClear(&v);
}
if(!bDescription) g_ReportLog.LogEntry(EC_INADAQUATE_DESCRIPTION, &pProp->GetPath());
pPropQualSet->EndEnumeration();
pPropQualSet->Release();
pPropQualSet = NULL;
pProp->CleanUp();
delete pProp;
}
}//for each property
//////////////////////
// Method
//////////////////////
pInParams = NULL;
pOutParams = NULL;
bstrMethName = NULL;
pClassObj = pTheClass->GetClassObject();
if(FAILED(hr = pClassObj->BeginMethodEnumeration(0))){
CString csUserMsg = _T("A fatal error occurred while evaluating this schema.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
while((hr = pClassObj->NextMethod(0, &bstrMethName, &pInParams, &pOutParams)) != WBEM_S_NO_MORE_DATA){
if(FAILED(hr)){
CString csUserMsg = _T("Unable to access ") + csClass + _T(" object.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
bstrMethOrigin = NULL;
bstrClassName = pTheClass->GetName().AllocSysString();
if(FAILED(hr = pClassObj->GetMethodOrigin(bstrMethName, &bstrMethOrigin)) ||
(_wcsicmp(bstrMethOrigin, bstrClassName) != 0)){
SysFreeString(bstrMethOrigin);
SysFreeString(bstrClassName);
}else{
SysFreeString(bstrMethOrigin);
SysFreeString(bstrClassName);
csMethodName = bstrMethName;
pMeth = new CMethod(&csMethodName, pInParams, pOutParams, pTheClass);
SysFreeString(bstrMethName);
//send the progress message
pProgress->SetCurrentProgress(i, &pMeth->GetPath());
//do all method checks;
pMeth->ValidMethodOverrides();
pCur->Restore();
//////////////////////
// Method Qualifiers
//////////////////////
pMethQualSet = NULL;
bstrMethQualName = NULL;
bDescription = false;
VariantClear(&v);
if(FAILED(hr = pClassObj->GetMethodQualifierSet(bstrMethName, &pMethQualSet))){
CString csUserMsg = _T("A fatal error occurred while evaluating this schema.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrMethName);
return hr;
}
SysFreeString(bstrMethName);
if(FAILED(hr = pMethQualSet->BeginEnumeration(0))){
CString csUserMsg = _T("A fatal error occurred while evaluating this schema.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
while((hr = pMethQualSet->Next(0, &bstrMethQualName, &v, &lType)) != WBEM_S_NO_MORE_DATA){
if(FAILED(hr)){
CString csUserMsg = _T("Unable to access ") + csClass + _T(" object.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
//Package qualifier
csMethQualName = bstrMethQualName;
pMethQual = new CQualifier(&csMethQualName, &v, lType, &pMeth->GetPath());
SysFreeString(bstrMethQualName);
//do all qualifierchecks;
pMethQual->ValidScope(SCOPE_METHOD);
if(csMethQualName.CompareNoCase(_T("DESCRIPTION")) == 0){
ValidDescription(pMethQual, &pMeth->GetPath());
pCur->Restore();
bDescription = true;
}
pMethQual->CleanUp();
delete pMethQual;
VariantClear(&v);
}
if(!bDescription) g_ReportLog.LogEntry(EC_INADAQUATE_DESCRIPTION, &pMeth->GetPath());
pMethQualSet->EndEnumeration();
pMethQualSet->Release();
pMethQualSet = NULL;
//////////////////////
// Method Params
//////////////////////
if(pInParams){
BSTR bstrParamName = NULL;
if(FAILED(hr = pInParams->BeginEnumeration(WBEM_FLAG_LOCAL_ONLY))){
CString csUserMsg = _T("A fatal error occurred while evaluating this schema.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
while((hr = pInParams->Next(0, &bstrParamName, &v, &lType, &lFlavor)) != WBEM_S_NO_MORE_DATA){
if(FAILED(hr)){
CString csUserMsg = _T("Unable to access ") + csClass + _T(" object.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
//////////////////////
// Method Param Qualifiers
//////////////////////
pMethParamQualSet = NULL;
bstrMethParamQualName = NULL;
VariantClear(&v);
if(FAILED(hr = pInParams->GetPropertyQualifierSet(bstrParamName, &pMethParamQualSet))){
CString csUserMsg = _T("A fatal error occurred while evaluating this schema.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
if(FAILED(hr = pMethParamQualSet->BeginEnumeration(0))){
CString csUserMsg = _T("A fatal error occurred while evaluating this schema.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
while((hr = pMethParamQualSet->Next(0, &bstrMethParamQualName, &v, &lType)) != WBEM_S_NO_MORE_DATA){
if(FAILED(hr)){
CString csUserMsg = _T("Unable to access ") + csClass + _T(" object.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
//Package qualifier
csMethParamQualName = bstrMethParamQualName;
pMethParamQual = new CQualifier(&csMethParamQualName, &v, lType, &pMeth->GetPath());
SysFreeString(bstrMethParamQualName);
//do all qualifierchecks;
pMethParamQual->ValidScope(SCOPE_METHOD_PARAM);
pCur->Restore();
pMethParamQual->CleanUp();
delete pMethParamQual;
VariantClear(&v);
}
pMethParamQualSet->EndEnumeration();
pMethParamQualSet->Release();
pMethParamQualSet = NULL;
SysFreeString(bstrParamName);
}
}//if(pInParams)
if(pOutParams){
bstrParamName = NULL;
if(FAILED(hr = pOutParams->BeginEnumeration(WBEM_FLAG_LOCAL_ONLY))){
CString csUserMsg = _T("A fatal error occurred while evaluating this schema.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
while((hr = pOutParams->Next(0, &bstrParamName, &v, &lType, &lFlavor)) != WBEM_S_NO_MORE_DATA){
if(FAILED(hr)){
CString csUserMsg = _T("Unable to access ") + csClass + _T(" object.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
//////////////////////
// Method Param Qualifiers
//////////////////////
VariantClear(&v);
if(FAILED(hr = pOutParams->GetPropertyQualifierSet(bstrParamName, &pMethParamQualSet))){
CString csUserMsg = _T("A fatal error occurred while evaluating this schema.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
if(FAILED(hr = pMethParamQualSet->BeginEnumeration(0))){
CString csUserMsg = _T("A fatal error occurred while evaluating this schema.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
while((hr = pMethParamQualSet->Next(0, &bstrMethParamQualName, &v, &lType)) != WBEM_S_NO_MORE_DATA){
if(FAILED(hr)){
CString csUserMsg = _T("Unable to access ") + csClass + _T(" object.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
//Package qualifier
csMethParamQualName = bstrMethParamQualName;
pMethParamQual = new CQualifier(&csMethParamQualName, &v, lType, &pMeth->GetPath());
SysFreeString(bstrMethParamQualName);
//do all qualifierchecks;
pMethParamQual->ValidScope(SCOPE_METHOD_PARAM);
pCur->Restore();
pMethParamQual->CleanUp();
delete pMethParamQual;
VariantClear(&v);
}
pMethParamQualSet->EndEnumeration();
pMethParamQualSet->Release();
pMethParamQualSet = NULL;
SysFreeString(bstrParamName);
}
}//if(pOutParams)
pMeth->CleanUp();
delete pMeth;
}
}//for each method
pClassObj->EndMethodEnumeration();
bFound = false;
csRoot = GetRootObject(m_pNamespace, pTheClass->GetName());
pCur->Restore();
if(csRoot != _T("")){
for(int i = 0; i < m_csaRootObjects.GetSize(); i++){
if(csRoot.CompareNoCase(m_csaRootObjects.GetAt(i)) == 0){
bFound = true;
break;
}
}
if(!bFound) m_csaRootObjects.Add(csRoot);
}
}//if(bComplianceChecks)
//////////////////////
// W2K Logo Requirements
//////////////////////
if(m_bW2K){
//send the progress message
CString csPath = pTheClass->GetPath() + _T(" Logo Requirements");
pProgress->SetCurrentProgress(i, &csPath);
pTheClass->W2K_ValidDerivation();
pCur->Restore();
pTheClass->W2K_ValidPhysicalElementDerivation();
pCur->Restore();
pTheClass->W2K_ValidSettingUsage(&m_csaClassNames);
pCur->Restore();
pTheClass->W2K_ValidStatisticsUsage(&m_csaClassNames);
pCur->Restore();
if(m_bDeviceManagement){
pTheClass->W2K_ValidLogicalDeviceDerivation();
pCur->Restore();
pTheClass->W2K_ValidSettingDeviceUsage(&m_csaClassNames);
pCur->Restore();
}
if(m_bComputerSystemManagement){
pTheClass->W2K_ValidComputerSystemDerivation();
pCur->Restore();
}
}//if(bW2K)
pTheClass->CleanUp();
delete pTheClass;
}//for each class
if(m_bComplianceChecks){
// Overall checks;
//send the progress message
CString csMsg = _T("Checking associations...");
pProgress->SetCurrentProgress(-1, &csMsg);
RedundantAssociationCheck(m_pNamespace, &m_csaAssociations);
pCur->Restore();
//send the progress message
csMsg = _T("Completing correctness checks...");
pProgress->SetCurrentProgress(-1, &csMsg);
NumberOfSubgraphs();
pCur->Restore();
m_iRootObjects = m_csaRootObjects.GetSize();
}
if(m_bLocalizationChecks){
IEnumWbemClassObject *pNamespaceEnum = NULL;
IEnumWbemClassObject *pEnum = NULL;
IWbemClassObject *pObj = NULL;
ULONG uReturned = 0;
BSTR bstrNAMESPACE = SysAllocString(L"__NAMESPACE");
VARIANT v;
VariantInit(&v);
CStringArray csaBadClasses;
csaBadClasses.RemoveAll();
int iProgress = 0;
//enumerate instances of __NAMESPACE
if(FAILED(hr = m_pNamespace->CreateInstanceEnum(bstrNAMESPACE, 0, NULL, &pNamespaceEnum))){
CString csUserMsg = _T("Cannot enumerate sub-namespaces.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
SysFreeString(bstrNAMESPACE);
IWbemServices *pLocalized = NULL;
BSTR bstrName;
CString csNamespace;
CLocalNamespace *pLocalNamespace;
CString csClass;
CClass *pLocalClass;
while(((hr = pNamespaceEnum->Next(INFINITE, 1, &pObj, &uReturned)) == WBEM_S_NO_ERROR) && uReturned > 0){
if(FAILED(hr)){
CString csUserMsg = _T("Cannot enumerate sub-namespaces.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
pProgress->ResetProgress(iClasses);
bstrName = SysAllocString(L"Name");
pObj->Get(bstrName, 0, &v, NULL, NULL);
SysFreeString(bstrName);
pObj->Release();
pObj = NULL;
//check to make sure it's a localization namespace
m_pNamespace->OpenNamespace(V_BSTR(&v), 0, NULL, &pLocalized, NULL);
csNamespace = V_BSTR(&v);
pLocalNamespace = new CLocalNamespace(&csNamespace, pLocalized, m_pNamespace);
VariantClear(&v);
if(FAILED(hr = pLocalized->CreateClassEnum(NULL, NULL, NULL, &pEnum))){
CString csUserMsg = _T("Unable to create localized class enumeration.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
while(((hr = pEnum->Next(INFINITE, 1, &pObj, &uReturned)) == WBEM_S_NO_ERROR) && uReturned > 0){
if(FAILED(hr)){
CString csUserMsg = _T("Unable to enumerate localized classes.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
//make sure we have one of our schemas classes
csClass = GetClassName(pObj);
int iSize = m_csaClassNames.GetSize();
bool bFound = false;
for(int i = 0; i < iSize; i++){
if(csClass.CompareNoCase(m_csaClassNames.GetAt(i)) == 0){
bFound = true;
break;
}
}
if(bFound){
csClass = GetClassName(pObj);
pLocalClass = new CClass(&csClass, pObj);
//send the progress message
pProgress->SetCurrentProgress(++iProgress, &pLocalClass->GetPath());
pLocalClass->Local_ValidLocale();
pCur->Restore();
pLocalNamespace->Local_ValidLocalizedClass(pLocalClass);
pCur->Restore();
pLocalClass->Local_ValidAmendedLocalClass();
pCur->Restore();
pLocalClass->Local_ValidAbstractLocalClass();
pCur->Restore();
if(!Local_CompareClassDerivation(pLocalClass, pLocalNamespace)){
//Add item to the "bad class" list
csaBadClasses.Add(pLocalClass->GetPath());
}
/*
//////////////////////
// Property
//////////////////////
IWbemClassObject *pClassObj = pLocalClass->GetClassObject();
BSTR bstrPropName;
LONG lFlavor;
pClassObj->BeginEnumeration(WBEM_FLAG_NONSYSTEM_ONLY);
while((hr = pClassObj->Next(0, &bstrPropName, &v, &lType, &lFlavor)) != WBEM_S_NO_MORE_DATA){
if(FAILED(hr)){
CString csUserMsg = _T("Unable to access ") + csClass + _T(" object.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
CString csPropName = bstrPropName;
CProperty *pProp = new CProperty(&csPropName, &v, lType, lFlavor);
//send the progress message
pProgress->SetCurrentProgress(i, &pProp->GetPath());
pProp->Local_ValidProperty();
pCur->Restore();
delete pProp;
}
*/
/*
//////////////////////
// Method
//////////////////////
IWbemClassObject *pInParams = NULL;
IWbemClassObject *pOutParams = NULL;
BSTR bstrMethName;
pClassObj = pLocalClass->GetClassObject();
pClassObj->BeginMethodEnumeration(0);
while((hr = pClassObj->NextMethod(0, &bstrMethName, &pInParams, &pOutParams)) != WBEM_S_NO_MORE_DATA){
if(FAILED(hr)){
CString csUserMsg = _T("Unable to access ") + csClass + _T(" object.");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
return hr;
}
CString csMethName = bstrMethName;
CMethod *pMeth = new CMethod(&csMethName, pInParams, pOutParams);
//send the progress message
pProgress->SetCurrentProgress(i, &pMeth->GetPath());
pMeth->Local_ValidMethod();
pCur->Restore();
}
*/
pLocalClass->CleanUp();
delete pLocalClass;
}else{
pObj->Release();
pObj = NULL;
}
}//for each localized class
pEnum->Release();
VerifyAllClassesPresent(pLocalNamespace);
pCur->Restore();
int iBadCount = csaBadClasses.GetSize();
for(int j = 0; j < iBadCount; j++){
//report error with appropriate class;
g_ReportLog.LogEntry(EC_INCONSITANT_LOCALIZED_SCHEMA, &csaBadClasses.GetAt(j));
}
csaBadClasses.RemoveAll();
VariantClear(&v);
pLocalized->Release();
pLocalized = NULL;
delete pLocalNamespace;
}//for each localized namespace
pNamespaceEnum->Release();
}//if(bLocalizationChecks)
ClearQualifierArrays();
ReleaseErrorObject(pErrorObject);
//return the cursor to regular
delete pCur;
return hr;
}
HRESULT CSchemaValWizCtrl::NumberOfSubgraphs()
{
HRESULT hr = WBEM_S_NO_ERROR;
CStringArray csaClassList, csaVisitedList;
csaClassList.Copy(m_csaClassNames);
m_iSubGraphs = 0;
m_iProgressTotal = csaClassList.GetSize();
m_pProgress->ResetProgress(m_iProgressTotal);
csaVisitedList.RemoveAll();
//count the subgraphs
while(csaClassList.GetSize() > 0){
if(SUCCEEDED(ProcessNode(csaClassList.GetAt(0), &csaClassList,
&csaVisitedList))){
m_iSubGraphs++;
}
}
csaClassList.RemoveAll();
csaVisitedList.RemoveAll();
return hr;
}
/*
HRESULT CSchemaValWizCtrl::ProcessNode(CString csNodeName,
CStringArray *pcsaClassList,
CStringArray *pcsaVisitedList)
{
TRACE(_T("Entered ProcessNode(") + csNodeName + _T(")\n"));
HRESULT hr = WBEM_S_NO_ERROR;
if(csNodeName == "") return hr;
// Check the visited list to make sure we haven't already been
//to this class
bool bFound = false;
int iSize = pcsaVisitedList->GetSize();
CString csCompare;
for(int i = 0; i < iSize; i++){
csCompare = pcsaVisitedList->GetAt(i);
if(csNodeName.CompareNoCase(csCompare) == 0){
bFound = true;
break;
}
}
if(!bFound){
TRACE(_T("Found class ") + csNodeName + _T("... continuing\n"));
CString csPassIt;
BSTR bstrCLASS = SysAllocString(L"__CLASS");
IWbemClassObject *pObj;
ULONG uReturned;
m_pProgress->SetCurrentProgress(m_iProgressTotal - pcsaClassList->GetSize(), NULL);
pcsaVisitedList->Add(csNodeName);
// Check if it's in our schema and mark that we've visited
//it if it is
int iSize = pcsaClassList->GetSize();
for(int i = 0; i < iSize; i++){
if(csNodeName.CompareNoCase(pcsaClassList->GetAt(i)) == 0){
pcsaClassList->RemoveAt(i);
break;
}
}
IWbemClassObject *pErrorObject = NULL;
IWbemClassObject *pClass = NULL;
BSTR bstrName = csNodeName.AllocSysString();
TRACE(_T("Getting class ") + csNodeName + _T("\n"));
if(FAILED(hr = m_pNamespace->GetObject(bstrName, 0, NULL, &pClass, NULL))){
// CString csUserMsg = _T("Unable to access ") + csNodeName + _T(" object.");
// ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrName);
return hr;
}
SysFreeString(bstrName);
VARIANT v;
VariantInit(&v);
//get superclass of csNodeName
BSTR bstrSUPERCLASS = SysAllocString(L"__SUPERCLASS");
TRACE(_T("Getting ") + csNodeName + _T(" superclass\n"));
if(FAILED(hr = pClass->Get(bstrSUPERCLASS, 0, &v, NULL, NULL))){
// CString csUserMsg = _T("Cannot get ") + csNodeName + _T(" superclass for subgraph analysis");
// ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrSUPERCLASS);
return hr;
}else{
if(V_VT(&v) != VT_NULL){
csPassIt = V_BSTR(&v);
ProcessNode(csPassIt, pcsaClassList, pcsaVisitedList);
}
VariantClear(&v);
}
SysFreeString(bstrSUPERCLASS);
pClass->Release();
if(pcsaClassList->GetSize() < 1) return hr;
//get subclasses of csNodeName
IEnumWbemClassObject *pEnum = NULL;
BSTR bstrWQL = SysAllocString(L"WQL");
CString csQuery = _T("select * from meta_class where __SUPERCLASS=\"") + csNodeName + _T("\"");
BSTR bstrQuery = csQuery.AllocSysString();
TRACE(_T("Getting ") + csNodeName + _T(" subclasses\n"));
if(FAILED(hr = m_pNamespace->ExecQuery(bstrWQL, bstrQuery, 0, NULL, &pEnum))){
// CString csUserMsg = _T("Cannot get ") + csNodeName + _T(" subclasses for subgraph analysis");
// ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrQuery);
return hr;
}else{
pObj = NULL;
uReturned = 0;
while((hr = pEnum->Next(INFINITE, 1, &pObj, &uReturned)) == WBEM_S_NO_ERROR){
if(pcsaClassList->GetSize() < 1){
pObj->Release();
break;
}
if(FAILED(hr = pObj->Get(bstrCLASS, 0, &v, NULL, NULL))){
// CString csUserMsg = _T("Cannot get ") + csNodeName + _T(" subclasses for subgraph analysis");
// ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrCLASS);
SysFreeString(bstrQuery);
pObj->Release();
return hr;
}else{
csPassIt = V_BSTR(&v);
VariantClear(&v);
ProcessNode(csPassIt, pcsaClassList, pcsaVisitedList);
}
pObj->Release();
pObj = NULL;
}
SysFreeString(bstrCLASS);
pEnum->Release();
pEnum = NULL;
}
SysFreeString(bstrQuery);
if(pcsaClassList->GetSize() < 1){
return hr;
}
//get references of csNodeName
csQuery = _T("references of{") + csNodeName + _T("} where schemaonly");
bstrQuery = csQuery.AllocSysString();
pEnum = NULL;
TRACE(_T("Getting ") + csNodeName + _T(" references\n"));
if(FAILED(hr = m_pNamespace->ExecQuery(bstrWQL, bstrQuery, 0, NULL, &pEnum))){
// CString csUserMsg = _T("Cannot get ") + csNodeName + _T(" references for subgraph analysis");
// ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrQuery);
return hr;
}else{
pObj = NULL;
uReturned = 0;
while((hr = pEnum->Next(INFINITE, 1, &pObj, &uReturned)) == WBEM_S_NO_ERROR){
if(pcsaClassList->GetSize() < 1){
pObj->Release();
break;
}
if(FAILED(hr = pObj->Get(bstrCLASS, 0, &v, NULL, NULL))){
// CString csUserMsg = _T("Cannot get ") + csNodeName + _T(" references for subgraph analysis");
// ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrCLASS);
SysFreeString(bstrQuery);
pObj->Release();
return hr;
}else{
csPassIt = V_BSTR(&v);
VariantClear(&v);
ProcessNode(csPassIt, pcsaClassList, pcsaVisitedList);
}
pObj->Release();
pObj = NULL;
}
pEnum->Release();
pEnum = NULL;
}
SysFreeString(bstrQuery);
if(pcsaClassList->GetSize() < 1){
return hr;
}
//get associations of csNodeName
csQuery = _T("associators of {") + csNodeName + _T("} where schemaonly");
bstrQuery = csQuery.AllocSysString();
pEnum = NULL;
TRACE(_T("Getting ") + csNodeName + _T(" associators\n"));
if(FAILED(hr = m_pNamespace->ExecQuery(bstrWQL, bstrQuery, 0, NULL, &pEnum))){
// CString csUserMsg = _T("Cannot get ") + csNodeName + _T(" associations for subgraph analysis");
// ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrQuery);
return hr;
}else{
pObj = NULL;
uReturned = 0;
while((hr = pEnum->Next(INFINITE, 1, &pObj, &uReturned)) == WBEM_S_NO_ERROR){
if(pcsaClassList->GetSize() < 1){
pObj->Release();
break;
}
if(FAILED(hr = pObj->Get(bstrCLASS, 0, &v, NULL, NULL))){
// CString csUserMsg = _T("Cannot get ") + csNodeName + _T(" associations for subgraph analysis");
// ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrCLASS);
SysFreeString(bstrQuery);
SysFreeString(bstrWQL);
pObj->Release();
return hr;
}else{
csPassIt = V_BSTR(&v);
VariantClear(&v);
ProcessNode(csPassIt, pcsaClassList, pcsaVisitedList);
}
pObj->Release();
pObj = NULL;
}
pEnum->Release();
pEnum = NULL;
}
SysFreeString(bstrQuery);
SysFreeString(bstrWQL);
SysFreeString(bstrCLASS);
}
return hr;
}
*/
HRESULT CSchemaValWizCtrl::ProcessNode(CString csNodeName,
CStringArray *pcsaClassList,
CStringArray *pcsaVisitedList)
{
HRESULT hr = WBEM_S_NO_ERROR;
if(csNodeName == "") return hr;
// Check the visited list to make sure we haven't already been
//to this class
bool bFound = false;
int iSize = pcsaVisitedList->GetSize();
for(int i = 0; i < iSize; i++){
if(csNodeName.CompareNoCase(pcsaVisitedList->GetAt(i)) == 0){
bFound = true;
break;
}
}
if(!bFound){
m_pProgress->SetCurrentProgress(m_iProgressTotal - pcsaClassList->GetSize(), NULL);
pcsaVisitedList->Add(csNodeName);
// Check if it's in our schema and mark that we've visited
//it if it is
int iSize = pcsaClassList->GetSize();
for(int i = 0; i < iSize; i++){
if(csNodeName.CompareNoCase(pcsaClassList->GetAt(i)) == 0){
pcsaClassList->RemoveAt(i);
break;
}
}
IWbemClassObject *pErrorObject = NULL;
IWbemClassObject *pClass = NULL;
BSTR bstrName = csNodeName.AllocSysString();
if(FAILED(hr = m_pNamespace->GetObject(bstrName, 0, NULL, &pClass, NULL))){
// CString csUserMsg = _T("Unable to access ") + csNodeName + _T(" object.");
// ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrName);
return hr;
}
SysFreeString(bstrName);
VARIANT v;
VariantInit(&v);
//get superclass of csNodeName
BSTR bstrSUPERCLASS = SysAllocString(L"__SUPERCLASS");
if(FAILED(hr = pClass->Get(bstrSUPERCLASS, 0, &v, NULL, NULL))){
// CString csUserMsg = _T("Cannot get ") + csNodeName + _T(" superclass for subgraph analysis");
// ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrSUPERCLASS);
return hr;
}else{
if(V_VT(&v) != VT_NULL){
CString csPassIt = V_BSTR(&v);
ProcessNode(csPassIt, pcsaClassList, pcsaVisitedList);
// csPassIt.Empty();
}
VariantClear(&v);
}
SysFreeString(bstrSUPERCLASS);
pClass->Release();
if(pcsaClassList->GetSize() < 1) return hr;
//get subclasses of csNodeName
IEnumWbemClassObject *pEnum = NULL;
BSTR bstrWQL = SysAllocString(L"WQL");
CString csQuery = _T("select * from meta_class where __SUPERCLASS=\"") + csNodeName + _T("\"");
BSTR bstrQuery = csQuery.AllocSysString();
if(FAILED(hr = m_pNamespace->ExecQuery(bstrWQL, bstrQuery, 0, NULL, &pEnum))){
// CString csUserMsg = _T("Cannot get ") + csNodeName + _T(" subclasses for subgraph analysis");
// ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrQuery);
return hr;
}else{
IWbemClassObject *pObj = NULL;
ULONG uReturned = 0;
BSTR bstrCLASS = SysAllocString(L"__CLASS");
while((hr = pEnum->Next(INFINITE, 1, &pObj, &uReturned)) == WBEM_S_NO_ERROR){
if(pcsaClassList->GetSize() < 1){
pObj->Release();
break;
}
if(FAILED(hr = pObj->Get(bstrCLASS, 0, &v, NULL, NULL))){
// CString csUserMsg = _T("Cannot get ") + csNodeName + _T(" subclasses for subgraph analysis");
// ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrCLASS);
SysFreeString(bstrQuery);
pObj->Release();
return hr;
}else{
CString csPassIt = V_BSTR(&v);
VariantClear(&v);
ProcessNode(csPassIt, pcsaClassList, pcsaVisitedList);
// csPassIt.Empty();
}
pObj->Release();
pObj = NULL;
}
SysFreeString(bstrCLASS);
pEnum->Release();
pEnum = NULL;
}
SysFreeString(bstrQuery);
if(pcsaClassList->GetSize() < 1){
return hr;
}
//get references of csNodeName
csQuery = _T("references of{") + csNodeName + _T("} where schemaonly");
bstrQuery = csQuery.AllocSysString();
if(FAILED(hr = m_pNamespace->ExecQuery(bstrWQL, bstrQuery, 0, NULL, &pEnum))){
// CString csUserMsg = _T("Cannot get ") + csNodeName + _T(" references for subgraph analysis");
// ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrQuery);
return hr;
}else{
IWbemClassObject *pObj = NULL;
ULONG uReturned = 0;
BSTR bstrCLASS = SysAllocString(L"__CLASS");
while((hr = pEnum->Next(INFINITE, 1, &pObj, &uReturned)) == WBEM_S_NO_ERROR){
if(pcsaClassList->GetSize() < 1){
pObj->Release();
break;
}
if(FAILED(hr = pObj->Get(bstrCLASS, 0, &v, NULL, NULL))){
// CString csUserMsg = _T("Cannot get ") + csNodeName + _T(" references for subgraph analysis");
// ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrCLASS);
SysFreeString(bstrQuery);
pObj->Release();
return hr;
}else{
CString csPassIt = V_BSTR(&v);
VariantClear(&v);
ProcessNode(csPassIt, pcsaClassList, pcsaVisitedList);
// csPassIt.Empty();
}
pObj->Release();
pObj = NULL;
}
SysFreeString(bstrCLASS);
pEnum->Release();
pEnum = NULL;
}
SysFreeString(bstrQuery);
if(pcsaClassList->GetSize() < 1){
return hr;
}
//get associations of csNodeName
csQuery = _T("associators of {") + csNodeName + _T("} where schemaonly");
bstrQuery = csQuery.AllocSysString();
if(FAILED(hr = m_pNamespace->ExecQuery(bstrWQL, bstrQuery, 0, NULL, &pEnum))){
// CString csUserMsg = _T("Cannot get ") + csNodeName + _T(" associations for subgraph analysis");
// ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrQuery);
return hr;
}else{
IWbemClassObject *pObj = NULL;
ULONG uReturned = 0;
BSTR bstrCLASS = SysAllocString(L"__CLASS");
while((hr = pEnum->Next(INFINITE, 1, &pObj, &uReturned)) == WBEM_S_NO_ERROR){
if(pcsaClassList->GetSize() < 1){
pObj->Release();
break;
}
if(FAILED(hr = pObj->Get(bstrCLASS, 0, &v, NULL, NULL))){
// CString csUserMsg = _T("Cannot get ") + csNodeName + _T(" associations for subgraph analysis");
// ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
SysFreeString(bstrCLASS);
SysFreeString(bstrQuery);
SysFreeString(bstrWQL);
pObj->Release();
return hr;
}else{
CString csPassIt = V_BSTR(&v);
VariantClear(&v);
ProcessNode(csPassIt, pcsaClassList, pcsaVisitedList);
// csPassIt.Empty();
}
pObj->Release();
pObj = NULL;
}
SysFreeString(bstrCLASS);
pEnum->Release();
pEnum = NULL;
}
SysFreeString(bstrQuery);
SysFreeString(bstrWQL);
ReleaseErrorObject(pErrorObject);
}
return hr;
}
/*
void CSchemaValWizCtrl::PerformClassChecks(CString csClass)
{
CString csMsg;
HRESULT hr;
//////////////////////////////
//Do the class checks
// Check class name for a numeric first character
if(csClass[0] == '1' || csClass[0] == '2' || csClass[0] == '3' || csClass[0] == '4' ||
csClass[0] == '5' || csClass[0] == '6' || csClass[0] == '7' || csClass[0] == '8' ||
csClass[0] == '9' || csClass[0] == '0'){
csMsg = _T("Class names must begin with an alpha character.");
AddClassMsg(csMsg, csClass);
}
// Check class name for multiple underscores
int iLen = csClass.GetLength();
bool bUnderscore = false;
for(int i = 1; i < iLen; i++){
if(csClass[i] == '_'){
if(bUnderscore){
csMsg = _T("Class names may not contain more than one underscore.");
AddClassMsg(csMsg, csClass);
}
bUnderscore = true;
}
}
if(!bUnderscore){
csMsg = _T("Class names must begin with a schema name.");
AddClassMsg(csMsg, csClass);
}
bool bAbstract, bDynamic, bStatic, bProvider;
bAbstract = bDynamic = bStatic = bProvider = false;
IWbemClassObject *pErrorObject = NULL;
IWbemClassObject *pClass = NULL;
BSTR bstrClass = csClass.AllocSysString();
hr = m_pNamespace->GetObject(bstrClass, 0, NULL, &pClass, NULL);
SysFreeString(bstrClass);
if(FAILED(hr)){
CString csUserMsg = _T("Cannot get object ") + csClass;
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
}else{
IWbemQualifierSet *pQualSet = NULL;
hr = pClass->GetQualifierSet(&pQualSet);
if(FAILED(hr)){
CString csUserMsg = _T("Cannot get ") + csClass + _T(" qualifier set");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
}else{
VARIANT v;
VariantInit(&v);
// Check for abstract, dynamic and static qualifiers
BSTR bstrAbstract = SysAllocString(L"Abstract");
if(SUCCEEDED(pQualSet->Get(bstrAbstract, 0, &v, NULL))){
bAbstract = true;
// Check class derivation for proper abstract usage.
}
SysFreeString(bstrAbstract);
VariantClear(&v);
BSTR bstrDynamic = SysAllocString(L"Dynamic");
if(SUCCEEDED(pQualSet->Get(bstrDynamic, 0, &v, NULL))) bDynamic = true;
SysFreeString(bstrDynamic);
VariantClear(&v);
BSTR bstrStatic = SysAllocString(L"Static");
if(SUCCEEDED(pQualSet->Get(bstrStatic, 0, &v, NULL))) bStatic = true;
SysFreeString(bstrStatic);
VariantClear(&v);
// Perform Provider check
BSTR bstrProvider = SysAllocString(L"Provider");
if(SUCCEEDED(pQualSet->Get(bstrProvider, 0, &v, NULL))) bProvider = true;
SysFreeString(bstrProvider);
VariantClear(&v);
// Perform UUID check
BSTR bstrUUID = SysAllocString(L"UUID");
if(SUCCEEDED(pQualSet->Get(bstrUUID, 0, &v, NULL))){
// Check class UUID
}else{
csMsg = _T("Class must have a UUID qualifier.");
AddClassMsg(csMsg, csClass);
}
SysFreeString(bstrUUID);
VariantClear(&v);
// Perform Locale check
BSTR bstrLocale = SysAllocString(L"Locale");
if(SUCCEEDED(pQualSet->Get(bstrLocale, 0, &v, NULL))){
// Check class Locale
}else{
csMsg = _T("Class must have a Locale qualifier.");
AddClassMsg(csMsg, csClass);
}
SysFreeString(bstrLocale);
VariantClear(&v);
// Perform Description check
BSTR bstrDescription = SysAllocString(L"Description");
if(SUCCEEDED(hr = pQualSet->Get(bstrDescription, 0, &v, NULL))){
// Check class description
if(!PerformDescriptionCheck(csClass, pQualSet)){
csMsg = _T("Class Description is inadaquate.");
AddClassMsg(csMsg, csClass);
}
}else if(hr == WBEM_E_NOT_FOUND){
csMsg = _T("Class must contain Description qualifier.");
AddClassMsg(csMsg, csClass);
}
SysFreeString(bstrDescription);
VariantClear(&v);
// Perform MappingStrings check
BSTR bstrMappingStrings = SysAllocString(L"MappingStrings");
if(SUCCEEDED(hr = pQualSet->Get(bstrMappingStrings, 0, &v, NULL))){
// Check class MappingStrings
if(!PerformMappingStringsCheck(pQualSet)){
csMsg = _T("Class MappingStrings qualifier is not valid.");
AddClassMsg(csMsg, csClass);
}
}else if(hr == WBEM_E_NOT_FOUND){
csMsg = _T("Class must contain MappingStrings qualifier.");
AddClassMsg(csMsg, csClass);
}
SysFreeString(bstrMappingStrings);
VariantClear(&v);
// Check class is abstract, static or dynamic
if(!bAbstract && !bDynamic && !bStatic){
csMsg = _T("Class must have one of abstract, dynamic or static.");
AddClassMsg(csMsg, csClass);
}else if((bAbstract && (bDynamic || bStatic)) || (bDynamic && bStatic)){
csMsg = _T("Class may not have more than one of abstract, dynamic or static.");
AddClassMsg(csMsg, csClass);
}
// Check class with provider is dynamic
if(bProvider && !bDynamic){
csMsg = _T("Class with a provider must be dynamic.");
AddClassMsg(csMsg, csClass);
}
// Perform the class level qualifier checks
PerformQualifierChecks(&csClass, NULL, NULL, NULL, false, pQualSet);
// Perform the property checks
PerformPropertyChecks(csClass, pClass);
// Perform the method checks
PerformMethodChecks(csClass, pClass);
}
}
}
*/
/*
void CSchemaValWizCtrl::PerformPropertyChecks(CString csClass, IWbemClassObject *pClass)
{
HRESULT hr;
CString csMsg;
BSTR bstrProp = NULL;
bool bArray = false;
IWbemClassObject *pErrorObject = NULL;
if(FAILED(pClass->BeginEnumeration(WBEM_FLAG_NONSYSTEM_ONLY))){
CString csUserMsg = _T("Cannot enumerate property set for ") + csClass;
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
}else{
BSTR bstrName = NULL;
VARIANT vVal;
LONG lType, lFlav;
VariantInit(&vVal);
while((hr = pClass->Next(0, &bstrName, &vVal, &lType, &lFlav)) != WBEM_S_NO_MORE_DATA){
char cBuf[5000];
CString csName;
WideCharToMultiByte(CP_OEMCP, WC_COMPOSITECHECK, bstrName, (-1),
cBuf, 5000, NULL, NULL);
csName = cBuf;
if(V_VT(&vVal) & VT_ARRAY) bArray = true;
//////////////////////////////
//Do the property checks
IWbemQualifierSet *pQualSet = NULL;
VARIANT v;
VariantInit(&v);
// Check override validity
//get derivation
BSTR bstrDerivation = SysAllocString(L"__Derivation");
if(FAILED(pClass->Get(bstrDerivation, 0, &vDer, NULL, NULL))){
CString csUserMsg = _T("Cannot get ") + csClass + _T(" derivation");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
}else{
BSTR bstrOrigin;
hr = pClass->GetPropertyOrigin(bstrName, &bstrOrigin);
long i, j, min;
BSTR HUGEP *pbstr;
IWbemClassObject *pObj = NULL;
BSTR bstrOverride = SysAllocString(L"Override");
VARIANT vOverFlav;
VariantInit(&vOverFlav);
hr = SafeArrayAccessData(vDer.pparray, (void HUGEP* FAR*)&pbstr);
i = 0;
while(wcscmp(bstrOrigin, pbstr[i]) != 0){
hr = m_pNamespace->GetObject(pbstr[i], 0, NULL, pObj, NULL);
hr = pObj->Get(bstrName, 0, &vDer, NULL, NULL);
hr = pObj->GetPropertyQualifierSet(bstrName, &pQualSet);
if(SUCCEEDED(hr = pQualSet->Get(bstrOverride, 0, &v, &vOverFlav))){
}
i++;
}
SysFreeString(bstrOrigin);
SysFreeString(bstrOverride);
}
SysFreeString(bstrDerivation);
VariantClear(&vDer);
VariantClear(&v);
hr = pClass->GetPropertyQualifierSet(bstrName, &pQualSet);
// Check Value/ValueMap
int iValueCnt;
int iValueMapCnt;
BSTR bstrValue = SysAllocString(L"Value");
if(SUCCEEDED(hr = pQualSet->Get(bstrValue, 0, &v, NULL))){
if(!(V_VT(&v) & VT_ARRAY)){
csMsg = _T("Property Value qualifier must be an array.");
AddPropertyMsg(csMsg, csClass, csName);
}
//count number of items
iValueCnt = v.parray->rgsabound[0].cElements;
//check overrides against parents
PerfomQualOverrideCheck(pClass, csName, "Value");
}else if(hr == WBEM_E_NOT_FOUND){
csMsg = _T("Property should have Value qualifier.");
AddPropertyMsg(csMsg, csClass, csName);
}
SysFreeString(bstrValue);
VariantClear(&v);
BSTR bstrValueMap = SysAllocString(L"ValueMap");
if(SUCCEEDED(hr = pQualSet->Get(bstrValueMap, 0, &v, NULL))){
if(!(V_VT(&v) & VT_ARRAY)){
csMsg = _T("Property Value qualifier must be an array.");
AddPropertyMsg(csMsg, csClass, csName);
}
//check type against property
if(!(V_VT(&v) & V_VT(&vVal))){
csMsg = _T("Property ValueMap qualifier must be of the same CIMType as its property.");
AddPropertyMsg(csMsg, csClass, csName);
}
//count number of items
iValueMapCnt = v.parray->rgsabound[0].cElements;
//check overrides against parents
PerfomQualOverrideCheck(pClass, csName, "ValueMap");
}else if(hr == WBEM_E_NOT_FOUND){
csMsg = _T("Property should have Value qualifier.");
AddPropertyMsg(csMsg, csClass, csName);
}
SysFreeString(bstrValueMap);
VariantClear(&v);
//compare item counts for value & valuemap
if(iValueMapCnt != iValueCnt){
csMsg = _T("Property Value & ValueMap qualifiers must contain the same number of items.");
AddPropertyMsg(csMsg, csClass, csName);
}
// Perform Description check
BSTR bstrDescription = SysAllocString(L"Description");
if(SUCCEEDED(hr = pQualSet->Get(bstrDescription, 0, &v, NULL))){
// Check property description
if(!PerformDescriptionCheck(csName, pQualSet)){
csMsg = _T("Property Description is inadaquate.");
AddPropertyMsg(csMsg, csClass, csName);
}
}else if(hr == WBEM_E_NOT_FOUND){
csMsg = _T("Property must contain Description qualifier.");
AddPropertyMsg(csMsg, csClass, csName);
}
SysFreeString(bstrDescription);
VariantClear(&v);
// Perform MappingStrings check
BSTR bstrMappingStrings = SysAllocString(L"MappingStrings");
if(SUCCEEDED(hr = pQualSet->Get(bstrMappingStrings, 0, &v, NULL))){
// Check property MappingStrings
if(!PerformMappingStringsCheck(pQualSet)){
csMsg = _T("Property MappingStrings qualifier is not valid.");
AddPropertyMsg(csMsg, csClass, csName);
}
}else if(hr == WBEM_E_NOT_FOUND){
csMsg = _T("Property must contain MappingStrings qualifier.");
AddPropertyMsg(csMsg, csClass, csName);
}
SysFreeString(bstrMappingStrings);
VariantClear(&v);
if(FAILED(hr)){
CString csUserMsg = _T("Cannot get ") + csClass + _T(" property qualifier set");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
}else{
// Perform the property level qualifier checks
PerformQualifierChecks(&csClass, &csName, NULL, NULL, bArray, pQualSet);
}
VariantClear(&vVal);
}
}
}
*/
/*
void CSchemaValWizCtrl::PerfomQualOverrideCheck(IWbemClassObject *pClass, CString csProperty,
CString csQualifier)
{
HRESULT hr;
VARIANT vDer, v;
BSTR bstrProperty = csProperty.AllocSysString();
IWbemClassObject *pErrorObject;
VariantInit(&vDer);
VariantInit(&v);
// Check override validity
//get derivation
BSTR bstrDerivation = SysAllocString(L"__Derivation");
if(FAILED(pClass->Get(bstrDerivation, 0, &vDer, NULL, NULL))){
CString csUserMsg = _T("Cannot get ") + csProperty + _T(" derivation");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
}else{
BSTR bstrOrigin = NULL;
hr = pClass->GetPropertyOrigin(bstrProperty, &bstrOrigin);
BSTR HUGEP *pbstr;
IWbemClassObject *pObj = NULL;
BSTR bstrQual = csQualifier.AllocSysString();
IWbemQualifierSet *pQualSet;
hr = SafeArrayAccessData(vDer.parray, (void HUGEP* FAR*)&pbstr);
long i = 0;
while(wcscmp(bstrOrigin, pbstr[i]) != 0){
hr = m_pNamespace->GetObject(pbstr[i], 0, NULL, &pObj, NULL);
hr = pObj->Get(bstrProperty, 0, &vDer, NULL, NULL);
hr = pObj->GetPropertyQualifierSet(bstrProperty, &pQualSet);
if(SUCCEEDED(hr = pQualSet->Get(bstrQual, 0, &v, NULL))){
}
i++;
}
SysFreeString(bstrOrigin);
SysFreeString(bstrQual);
}
SysFreeString(bstrDerivation);
SysFreeString(bstrProperty);
VariantClear(&vDer);
VariantClear(&v);
}
*/
/*
void CSchemaValWizCtrl::PerformMethodChecks(CString csClass, IWbemClassObject *pClass)
{
HRESULT hr;
CString csMsg;
BSTR bstrProp = NULL;
IWbemClassObject *pErrorObject = NULL;
if(FAILED(pClass->BeginMethodEnumeration(0))){
CString csUserMsg = _T("Cannot enumerate property set for ") + csClass;
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
}else{
BSTR bstrName = NULL;
IWbemClassObject *pInObj = NULL;
IWbemClassObject *pOutObj = NULL;
while((hr = pClass->NextMethod(0, &bstrName, &pInObj, &pOutObj)) != WBEM_S_NO_MORE_DATA){
char cBuf[5000];
CString csName;
WideCharToMultiByte(CP_OEMCP, WC_COMPOSITECHECK, bstrName, (-1),
cBuf, 5000, NULL, NULL);
csName = cBuf;
//////////////////////////////
//Do the property checks
// Check override validity
IWbemQualifierSet *pQualSet = NULL;
VARIANT v;
VariantInit(&v);
hr = pClass->GetMethodQualifierSet(bstrName, &pQualSet);
// Perform Description check
BSTR bstrDescription = SysAllocString(L"Description");
if(SUCCEEDED(hr = pQualSet->Get(bstrDescription, 0, &v, NULL))){
// Check method description
if(!PerformDescriptionCheck(csName, pQualSet)){
csMsg = _T("Method Description is inadaquate.");
AddMethodMsg(csMsg, csClass, csName);
}
}else if(hr == WBEM_E_NOT_FOUND){
csMsg = _T("Method must contain Description qualifier.");
AddMethodMsg(csMsg, csClass, csName);
}
SysFreeString(bstrDescription);
VariantClear(&v);
// Perform MappingStrings check
BSTR bstrMappingStrings = SysAllocString(L"MappingStrings");
if(SUCCEEDED(hr = pQualSet->Get(bstrMappingStrings, 0, &v, NULL))){
// Check method MappingStrings
if(!PerformMappingStringsCheck(pQualSet)){
csMsg = _T("Method MappingStrings qualifier is not valid.");
AddMethodMsg(csMsg, csClass, csName);
}
}else if(hr == WBEM_E_NOT_FOUND){
csMsg = _T("Method must contain MappingStrings qualifier.");
AddMethodMsg(csMsg, csClass, csName);
}
SysFreeString(bstrMappingStrings);
VariantClear(&v);
if(FAILED(hr)){
CString csUserMsg = _T("Cannot get ") + csClass + _T(" property qualifier set");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
}else{
// Perform the method level qualifier checks
PerformQualifierChecks(&csClass, NULL, &csName, NULL, false, pQualSet);
}
pInObj->Release();
pOutObj->Release();
}
}
}
*/
/*
void CSchemaValWizCtrl::PerformQualifierChecks(CString *pcsClass, CString *pcsProperty,
CString *pcsMethod, CString *pcsParameter,
bool bArray, IWbemQualifierSet *pQualSet)
{
HRESULT hr;
CString csMsg;
CString csQual;
VARIANT v;
IWbemClassObject *pErrorObject = NULL;
bool bAssociation = false;
bool bIndication = false;
bool bMethod = false;
bool bProperty = false;
bool bReference = false;
bool bParameter = false;
bool bClass = false;
VariantInit(&v);
InitQualifierArrays();
if(FAILED(pQualSet->BeginEnumeration(0))){
CString csUserMsg = _T("Cannot enumerate qualifier set");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
ReleaseErrorObject(pErrorObject);
}else{
BSTR bstrName = NULL;
VARIANT vVal;
LONG lFlav;
VariantInit(&vVal);
// do we have an method?
if(pcsMethod){
// do we have a parameter?
if(pcsParameter) bParameter = true;
else bMethod = true;
}
// do we have an property?
if(pcsProperty){
// do we have an reference?
BSTR bstrCIMType = SysAllocString(L"CIMType");
if(SUCCEEDED(hr = pQualSet->Get(bstrCIMType, 0, &v, NULL))){
char cBuf[5000];
CString csType;
WideCharToMultiByte(CP_OEMCP, WC_COMPOSITECHECK, V_BSTR(&v), (-1),
cBuf, 5000, NULL, NULL);
csType = cBuf;
if(csType.Find(_T("ref:")) != -1) bReference = true;
else bProperty = true;
}
SysFreeString(bstrCIMType);
VariantClear(&v);
}
// do we have an class?
if((!pcsProperty && !pcsMethod) && pcsClass) bClass = true;
// do we have an association?
BSTR bstrAssociation = SysAllocString(L"Association");
if(SUCCEEDED(hr = pQualSet->Get(bstrAssociation, 0, &v, NULL))) bAssociation = true;
SysFreeString(bstrAssociation);
VariantClear(&v);
// do we have an indication?
BSTR bstrIndication = SysAllocString(L"Indication");
if(SUCCEEDED(hr = pQualSet->Get(bstrIndication, 0, &v, NULL))) bIndication = true;
SysFreeString(bstrIndication);
VariantClear(&v);
while((hr = pQualSet->Next(0, &bstrName, &vVal, &lFlav)) != WBEM_S_NO_MORE_DATA){
WCHAR wcTmp[250];
char cBuf[5000];
WideCharToMultiByte(CP_OEMCP, WC_COMPOSITECHECK, bstrName, (-1),
cBuf, 5000, NULL, NULL);
csQual = cBuf;
//////////////////////////////
//Do the qualifier checks
if(bClass){
if(!IsClassQual(csQual)){
if(IsCIMQual(csQual))
csMsg = csQual + _T(" qualifier is not allow on a class.");
else
csMsg = csQual + _T(" is not a CIM qualifier.");
AddClassMsg(csMsg, *pcsClass);
}
}
if(bAssociation){
if(!IsAssocQual(csQual)){
if(IsCIMQual(csQual))
csMsg = csQual + _T(" qualifier is not allow on aan association.");
else
csMsg = csQual + _T(" is not a CIM qualifier.");
AddClassMsg(csMsg, *pcsClass);
}
}
if(bIndication){
if(!IsIndicQual(csQual)){
if(IsCIMQual(csQual))
csMsg = csQual + _T(" qualifier is not allow on an indication.");
else
csMsg = csQual + _T(" is not a CIM qualifier.");
AddClassMsg(csMsg, *pcsClass);
}
}
if(bProperty){
if((!IsPropQual(csQual)) && (!bArray || !IsArrayQual(csQual))){
if(IsCIMQual(csQual))
csMsg = csQual + _T(" qualifier is not allow on a property.");
else
csMsg = csQual + _T(" is not a CIM qualifier.");
AddPropertyMsg(csMsg, *pcsClass, *pcsProperty);
}
}
if(bMethod){
if(!IsMethQual(csQual)){
if(IsCIMQual(csQual))
csMsg = csQual + _T(" qualifier is not allow on a method.");
else csMsg = csQual + _T(" is not a CIM qualifier.");
AddMethodMsg(csMsg, *pcsClass, *pcsMethod);
}
}
if(bParameter){
if(!IsParamQual(bstrName)){
if(IsCIMQual(csQual))
csMsg = csQual + _T(" qualifier is not allow on a parameter.");
else csMsg = csQual + _T(" is not a CIM qualifier.");
AddMethodMsg(csMsg, *pcsClass, *pcsMethod);
}
}
if(bReference){
if(!IsRefQual(bstrName)){
if(IsCIMQual(csQual))
csMsg = csQual + _T(" qualifier is not allow on a reference.");
else csMsg = csQual + _T(" is not a CIM qualifier.");
AddPropertyMsg(csMsg, *pcsClass, *pcsProperty);
}
}
if(bArray){
if(!IsArrayQual(bstrName)){
if(IsCIMQual(csQual))
csMsg = csQual + _T(" qualifier is not allow on an array.");
else csMsg = csQual + _T(" is not a CIM qualifier.");
AddPropertyMsg(csMsg, *pcsClass, *pcsProperty);
}
}
SysFreeString(bstrName);
VariantClear(&vVal);
}
}
}
*/
/*
bool CSchemaValWizCtrl::PerformDescriptionCheck(CString csName, IWbemQualifierSet *pQualSet)
{
VARIANT v;
bool RetVal = false;
VariantInit(&v);
BSTR bstrDescription = SysAllocString(L"Description");
if(SUCCEEDED(pQualSet->Get(bstrDescription, 0, &v, NULL))){
// Should disalllow descriptions that just recapitulate the name for
// example given the name
// Win32_LogicalDiskDrive
// An unacceptable description would be:
// "This class represents logical disk drives"
long lNoise;
CString csDesc;
g_iNoise = 0;
AddNoise("a");
AddNoise("and");
AddNoise("the");
AddNoise("class");
AddNoise("property");
AddNoise("this");
AddNoise("which");
AddNoise("is");
AddNoise("for");
AddNoise("may");
AddNoise("be");
AddNoise("component");
AddNoise("manage");
AddNoise("such");
AddNoise("as");
AddNoise("all");
AddNoise("abstract");
AddNoise("define");
AddNoise("object");
AddNoise("string");
AddNoise("number");
AddNoise("integer");
AddNoise("reference");
AddNoise("association");
AddNoise("or");
AddNoise("represent");
AddNoise(",");
AddNoise(".");
AddNoise(" ");
AddNoise("(");
AddNoise(")");
AddNoise("\\");
AddNoise("/");
AddNoise("<");
AddNoise(">");
char cBuf[5000];
WideCharToMultiByte(CP_OEMCP, WC_COMPOSITECHECK, V_BSTR(&v), (-1),
cBuf, 5000, NULL, NULL);
csDesc = cBuf;
for(long l = 1; l < csDesc.GetLength(); l++){
lNoise = FindNoise(csDesc.Mid(l));
if(lNoise > 0) csDesc = csDesc.Left(l - 1) + csDesc.Mid(l + lNoise);
}
if(CountLetters(csDesc, csName) < 50) RetVal = false;
else RetVal = true;
}
SysFreeString(bstrDescription);
VariantClear(&v);
return RetVal;
}
*/
/*
bool CSchemaValWizCtrl::PerformMappingStringsCheck(IWbemQualifierSet *pQualSet)
{
VARIANT v;
bool RetVal = true;
VariantInit(&v);
BSTR bstrMappingStrings = SysAllocString(L"MappingStrings");
if(SUCCEEDED(pQualSet->Get(bstrMappingStrings, 0, &v, NULL))){
// Check that it is an array
WORD test = VT_ARRAY|VT_BSTR;
if(V_VT(&v) != test) RetVal = false;
// Check for a valid string format
}
SysFreeString(bstrMappingStrings);
VariantClear(&v);
return RetVal;
}
*/
/*
void CSchemaValWizCtrl::AddClassMsg(CString csMsg, CString csClass)
{
}
void CSchemaValWizCtrl::AddPropertyMsg(CString csMsg, CString csClass, CString csProperty)
{
}
void CSchemaValWizCtrl::AddMethodMsg(CString csMsg, CString csClass, CString csMethod)
{
}
void CSchemaValWizCtrl::AddQualifierMsg(CString csMsg, CString *pcsClass,
CString *pcsProperty, CString *pcsMethod)
{
}
*/
bool CSchemaValWizCtrl::RecievedClassList()
{
return m_bList;
}
bool CSchemaValWizCtrl::SetSourceList(bool bAssociators, bool bDescendents)
{
bool bReduced = false;
//display an hourglass
CWaitCursor *pCur = new CWaitCursor();
//clean out any system classes
int iSize = m_csaClassNames.GetSize();
int i;
for(i = 0; i < iSize; i++){
CString csClass = m_csaClassNames.GetAt(i).Left(2);
if(csClass.CompareNoCase(_T("__")) == 0){
m_csaClassNames.RemoveAt(i--);
iSize--;
bReduced = true;
}
}
if(bReduced){
CString csUserMsg = _T("System classes have been found in the list of selected classes. System classes can not be validated and those that have been found have been removed from the class list.");
ErrorMsg(&csUserMsg, WBEM_S_NO_ERROR, NULL, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
}
IWbemClassObject *pErrorObject = NULL;
int nClasses = m_csaClassNames.GetSize();
if(nClasses <= 0){
CString csUserMsg = _T("Cannot pass an empty class list");
ErrorMsg(&csUserMsg, NULL, NULL, TRUE, &csUserMsg, __FILE__, __LINE__ - 32);
return false;
}
if(!m_pNamespace) m_pNamespace = InitServices(&m_csNamespace);
m_bList = true;
CStringArray csaAssocAddition;
if(bAssociators){
m_bAssociators = bAssociators;
csaAssocAddition.RemoveAll();
IEnumWbemClassObject *pEnum;
IWbemClassObject *pObj;
ULONG uReturned;
BSTR bstrWQL = SysAllocString(L"WQL");
HRESULT hr = WBEM_S_NO_ERROR;
VARIANT v;
VariantInit(&v);
//get the associators
for(int i = 0; i < nClasses; i++){
CString csQuery = _T("associators of {");
csQuery += m_csaClassNames.GetAt(i);
csQuery += _T("} where SchemaOnly");
BSTR bstrQuery = csQuery.AllocSysString();
if(SUCCEEDED(hr = m_pNamespace->ExecQuery(bstrWQL, bstrQuery, 0, NULL, &pEnum))){
SysFreeString(bstrQuery);
while(pEnum->Next(WBEM_INFINITE, 1, &pObj, &uReturned) == WBEM_S_NO_ERROR){
csaAssocAddition.Add(GetClassName(pObj));
pObj->Release();
pObj = NULL;
}
pEnum->Release();
}
SysFreeString(bstrQuery);
csQuery = _T("references of {");
csQuery += m_csaClassNames.GetAt(i);
csQuery += _T("} where ClassDefsOnly");
bstrQuery = csQuery.AllocSysString();
if(SUCCEEDED(hr = m_pNamespace->ExecQuery(bstrWQL, bstrQuery, 0, NULL, &pEnum))){
SysFreeString(bstrQuery);
while(pEnum->Next(WBEM_INFINITE, 1, &pObj, &uReturned) == WBEM_S_NO_ERROR){
csaAssocAddition.Add(GetClassName(pObj));
pObj->Release();
pObj = NULL;
}
pEnum->Release();
}
SysFreeString(bstrQuery);
}
SysFreeString(bstrWQL);
}
CStringArray csaDescendAddition;
if(bDescendents){
m_bDescendents = bDescendents;
csaDescendAddition.RemoveAll();
IEnumWbemClassObject *pEnum;
IWbemClassObject *pObj;
ULONG uReturned;
BSTR bstrWQL = SysAllocString(L"WQL");
HRESULT hr = WBEM_S_NO_ERROR;
VARIANT v;
VariantInit(&v);
//get the descendents
for(int i = 0; i < nClasses; i++){
CString csQuery = _T("select * from meta_class where __this isa \"");
csQuery += m_csaClassNames.GetAt(i);
csQuery += _T("\"");
BSTR bstrQuery = csQuery.AllocSysString();
if(SUCCEEDED(hr = m_pNamespace->ExecQuery(bstrWQL, bstrQuery, 0, NULL, &pEnum))){
SysFreeString(bstrQuery);
while(pEnum->Next(WBEM_INFINITE, 1, &pObj, &uReturned) == WBEM_S_NO_ERROR){
CString csName = GetClassName(pObj);
if(csName != m_csaClassNames.GetAt(i))
csaDescendAddition.Add(csName);
pObj->Release();
pObj = NULL;
}
pEnum->Release();
}
SysFreeString(bstrQuery);
}
SysFreeString(bstrWQL);
}
// add the results to the main list
nClasses = csaAssocAddition.GetSize();
for(i = 0; i < nClasses; i++){
m_csaClassNames.Add(csaAssocAddition.GetAt(i));
}
nClasses = csaDescendAddition.GetSize();
for(i = 0; i < nClasses; i++){
m_csaClassNames.Add(csaDescendAddition.GetAt(i));
}
//clean out duplicates
nClasses = m_csaClassNames.GetSize();
for(i = 0; i < nClasses; i++){
for(int t = (i + 1); t < nClasses; t++){
if(m_csaClassNames.GetAt(t).CompareNoCase(m_csaClassNames.GetAt(i)) == 0){
m_csaClassNames.RemoveAt(t--);
nClasses--;
}
}
}
ReleaseErrorObject(pErrorObject);
delete pCur;
return true;
}
bool CSchemaValWizCtrl::SetSourceSchema(CString *pcsSchema, CString *pcsNamespace)
{
CStringArray csaClasses;
m_csSchema = *pcsSchema;
m_bSchema = true;
//display an hourglass
CWaitCursor *pCur = new CWaitCursor();
if(m_csNamespace.CompareNoCase(*pcsNamespace) != 0){
if(m_pNamespace){
m_pNamespace->Release();
m_pNamespace = NULL;
}
m_csNamespace = *pcsNamespace;
m_pNamespace = InitServices(&m_csNamespace);
pCur->Restore();
if(!m_pNamespace){
m_csNamespace = _T("");
delete pCur;
return false;
}
}
//select all the classes in a given schema
HRESULT hr;
IEnumWbemClassObject *pEnum = NULL;
IWbemClassObject *pObj = NULL;
IWbemClassObject *pErrorObject = NULL;
ULONG uReturned;
if(SUCCEEDED(hr = m_pNamespace->CreateClassEnum(NULL,
(WBEM_FLAG_DEEP | WBEM_FLAG_FORWARD_ONLY), NULL, &pEnum))){
CString csName;
CString csSchema;
csaClasses.RemoveAll();
while(pEnum->Next(WBEM_INFINITE, 1, &pObj, &uReturned) == WBEM_S_NO_ERROR){
csName = GetClassName(pObj);
int i = 0;
csSchema = csName;
//check for system classes
if(csSchema.Mid(0, 1) != L'_'){
while((i < csSchema.GetLength()) && (csSchema.Mid(i, 1) != L'_')) i++;
if(i < csSchema.GetLength()){
csSchema = csSchema.Left(i);
if(csSchema.CompareNoCase(*pcsSchema) == 0)
csaClasses.Add(csName);
}
}
pObj->Release();
pObj = NULL;
}
pEnum->Release();
}else{
CString csUserMsg = _T("unable to build class list");
ErrorMsg(&csUserMsg, hr, pErrorObject, TRUE, &csUserMsg, __FILE__, __LINE__ - 8);
ReleaseErrorObject(pErrorObject);
delete pCur;
return false;
}
int iSize = csaClasses.GetSize();
if(iSize < 1){
CString csUserMsg = _T("There are no classes in this schema");
ErrorMsg(&csUserMsg, NULL, NULL, TRUE, &csUserMsg, __FILE__, __LINE__ - 8);
delete pCur;
return false;
}else{
m_csaClassNames.RemoveAll();
for(int j = 0; j < iSize; j++)
m_csaClassNames.Add(csaClasses.GetAt(j));
csaClasses.RemoveAll();
}
ReleaseErrorObject(pErrorObject);
delete pCur;
return true;
}
void CSchemaValWizCtrl::SetComplianceChecks(bool bCompliance)
{
m_bComplianceChecks = bCompliance;
}
void CSchemaValWizCtrl::SetW2KChecks(bool bW2K, bool bComputerSystem, bool bDevice)
{
m_bW2K = bW2K;
m_bComputerSystemManagement = bComputerSystem;
m_bDeviceManagement = bDevice;
}
void CSchemaValWizCtrl::SetLocalizationChecks(bool bLocalization)
{
m_bLocalizationChecks = bLocalization;
}
CString CSchemaValWizCtrl::GetCurrentNamespace()
{
return m_csNamespace;
}
void CSchemaValWizCtrl::GetSourceSettings(bool *pbSchema, bool *pbList, bool *pbAssoc, bool *pbDescend)
{
*pbSchema = m_bSchema;
*pbList = m_bList;
*pbAssoc = m_bAssociators;
*pbDescend = m_bDescendents;
}
void CSchemaValWizCtrl::GetComplianceSettings(bool *pbCompliance)
{
*pbCompliance = m_bComplianceChecks;
}
void CSchemaValWizCtrl::GetW2KSettings(bool *pbW2K, bool *pbComputerSystem, bool *pbDevice)
{
*pbW2K = m_bW2K;
*pbComputerSystem = m_bComputerSystemManagement;
*pbDevice = m_bDeviceManagement;
}
void CSchemaValWizCtrl::GetLocalizationSettings(bool *pbLocalization)
{
*pbLocalization = m_bLocalizationChecks;
}
CStringArray * CSchemaValWizCtrl::GetClassList()
{
return &m_csaClassNames;
}
CString CSchemaValWizCtrl::GetSchemaName()
{
return m_csSchema;
}
Reference in New Issue View Git Blame Copy Permalink