void test03()
{
//
// Define query:
//
const char TEXT[] =
"SELECT *\n"
"FROM AnotherClass\n";
//
// Will test WQLParser::parse(const String&, WQLSelectStatement&)
// and WQLParser::parse(const char*, WQLSelectStatement&) forms
//
String text (TEXT);
if (verbose)
{
cout << text << endl;
}
//
// Parse the text:
//
WQLSelectStatement statement;
try
{
WQLParser::parse(text, statement);
if (verbose)
{
statement.print();
}
//
// Test WQLSelectStatement functions
//
assert (statement.getClassName().equal ("AnotherClass"));
assert (statement.getAllProperties());
CIMPropertyList propList = statement.getSelectPropertyList();
assert (propList.isNull());
assert (!statement.hasWhereClause());
assert (statement.getWherePropertyNameCount() == 0);
CIMPropertyList wherePropList = statement.getWherePropertyList();
assert (!wherePropList.isNull());
assert (wherePropList.size() == 0);
}
catch (Exception& e)
{
cerr << "Exception: " << e.getMessage() << endl;
exit(1);
}
}
void IndicationFormatter::validateTextFormatParameters (
const CIMPropertyList & propertyList,
const CIMClass & indicationClass,
const Array<String> & textFormatParams)
{
PEG_METHOD_ENTER (TRC_IND_FORMATTER,
"IndicationFormatter::validateTextFormatParameters");
Array <String> indicationClassProperties;
String exceptionStr;
// All the properties are selected
if (propertyList.isNull ())
{
for (Uint32 i = 0; i < indicationClass.getPropertyCount (); i++)
{
indicationClassProperties.append(
indicationClass.getProperty (i).getName ().getString());
}
}
// partial properties are selected
else
{
Array<CIMName> propertyNames = propertyList.getPropertyNameArray();
for (Uint32 j = 0; j < propertyNames.size(); j++)
{
indicationClassProperties.append(propertyNames[j].getString());
}
}
// check if the textFormatParams is contained in the
// indicationClassProperties
for (Uint32 k = 0; k < textFormatParams.size(); k++)
{
if (!Contains(indicationClassProperties, textFormatParams[k]))
{
// The property name in TextFormatParameters is not
// included in the select clause of the associated filter query
MessageLoaderParms parms(
"IndicationFormatter.IndicationFormatter._MSG_MISS_MATCHED_PROPERTY_NAME",
"The property name $0 in $1 does not match the properties in the select clause",
textFormatParams[k],
_PROPERTY_TEXTFORMATPARAMETERS.getString());
exceptionStr.append(MessageLoader::getMessage(parms));
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION (
CIM_ERR_INVALID_PARAMETER, exceptionStr);
}
}
PEG_METHOD_EXIT();
}
void PG_TestPropertyTypes::modifyInstance(
const OperationContext& context,
const CIMObjectPath& instanceReference,
const CIMInstance& instanceObject,
const Boolean includeQualifiers,
const CIMPropertyList& propertyList,
ResponseHandler& handler)
{
// This provider only allows partial instance modification for the
// PropertyUint8 property.
if (!(propertyList.isNull() ||
((propertyList.size() == 1) &&
(propertyList[0].equal("PropertyUint8")))))
{
throw CIMException(CIM_ERR_NOT_SUPPORTED);
}
// synchronously get references
Array<CIMObjectPath> references =
_enumerateInstanceNames(context, instanceReference);
// ensure the Namespace is valid
if (!instanceReference.getNameSpace().equal("test/static"))
{
throw CIMException(CIM_ERR_INVALID_NAMESPACE);
}
// ensure the class existing in the specified namespace
if (!instanceReference.getClassName().equal("PG_TestPropertyTypes"))
{
throw CIMException(CIM_ERR_INVALID_CLASS);
}
// ensure the property values are valid
_testPropertyTypesValue(instanceObject);
// ensure the request object exists
Uint32 index = findObjectPath(references, instanceReference);
if (index == PEG_NOT_FOUND)
{
throw CIMException(CIM_ERR_NOT_FOUND);
}
// begin processing the request
handler.processing();
// We do nothing here since we like to have static result
// complete processing the request
handler.complete();
}
void _printPropertyList(CIMPropertyList& propList)
{
if (propList.isNull())
{
cout << "-----all properties required" << endl;
}
else if (propList.size() == 0)
{
cout << "-----no properties required" << endl;
}
else
{
for (Uint32 n = 0; n < propList.size(); n++)
{
cout << "-----Required property " << propList[n].getString() << endl;
}
}
}
// KS Mar 05 - The following removal functions are very inefficient and should
// be optimized to avoid the multiple memory moves. Actually, the remove
// qualifiers should be added as a function and optimized that once.
void CIMInstanceRep::filter(
Boolean includeQualifiers,
Boolean includeClassOrigin,
const CIMPropertyList& propertyList)
{
// Filter any qualifiers from this instance.
if (!includeQualifiers && _qualifiers.getCount() > 0)
{
while (_qualifiers.getCount())
{
_qualifiers.removeQualifier(0);
}
}
// For each property, remove if not in propertylist
for (Uint32 i = 0 ; i < _properties.size(); i++)
{
CIMConstProperty p = getProperty(i);
CIMName name = p.getName();
Array<CIMName> pl = propertyList.getPropertyNameArray();
if (propertyList.isNull() || Contains(pl, name))
{
// test ClassOrigin and possibly remove
if (!includeClassOrigin)
{
_properties[i].setClassOrigin(CIMName());
}
// remove qualifiers if required.
if (!includeQualifiers && _properties[i].getQualifierCount() > 0)
{
while (_properties[i].getQualifierCount() > 0)
{
_properties[i].removeQualifier(0);
}
}
}
else
{
_properties.remove(i--);
}
}
return;
}
PEGASUS_NAMESPACE_BEGIN
void SCMOInternalXmlEncoder::_putXMLInstance(
CIMBuffer& out,
const SCMOInstance& ci,
const CIMPropertyList& propertyList )
{
if (ci.isUninitialized())
{
out.putUint32(0);
out.putUint32(0);
out.putString(String());
out.putNamespaceName(CIMNamespaceName());
}
else
{
Buffer buf(4096);
// Serialize instance as XML.
if (propertyList.isNull())
{
Array<Uint32> emptyNodes;
SCMOXmlWriter::appendInstanceElement(
buf,
ci,
false,
emptyNodes);
}
else
{
Array<propertyFilterNodesArray_t> propFilterNodesArrays;
// This searches for an already created array of nodes,
// if not found, creates it inside propFilterNodesArrays
const Array<Uint32> & nodes=
SCMOXmlWriter::getFilteredNodesArray(
propFilterNodesArrays,
ci,
propertyList);
SCMOXmlWriter::appendInstanceElement(
buf,
ci,
true,
nodes);
}
buf.append('\0');
out.putUint32(buf.size());
out.putBytes(buf.getData(), buf.size());
buf.clear();
if (0 == ci.getClassName())
{
out.putUint32(0);
out.putString(String());
out.putNamespaceName(CIMNamespaceName());
}
else
{
// Serialize object path as XML.
SCMOXmlWriter::appendValueReferenceElement(buf, ci);
buf.append('\0');
out.putUint32(buf.size());
out.putBytes(buf.getData(), buf.size());
// Write hostname and namespace in UTF-16 format
Uint32 len=0;
const char* hn = ci.getHostName_l(len);
out.putUTF8AsString(hn, len);
const char * ns = ci.getNameSpace_l(len);
out.putUTF8AsString(ns, len);
}
}
}
void test01()
{
//
// Create a property source (a place for the evaluate to get the
// values of properties from):
//
WQLSimplePropertySource source;
assert(source.addValue("x", WQLOperand(10, WQL_INTEGER_VALUE_TAG)));
assert(source.addValue("y", WQLOperand(20, WQL_INTEGER_VALUE_TAG)));
assert(source.addValue("z", WQLOperand(1.5, WQL_DOUBLE_VALUE_TAG)));
//
// Define query:
//
const char TEXT[] =
"SELECT x,y,z\n"
"FROM MyClass\n"
"WHERE x > 5 AND y < 25 AND z > 1.2";
//
// Will test WQLParser::parse(const Array<Sint8>&, WQLSelectStatement&)
// and WQLParser::parse(const char*, WQLSelectStatement&) forms
//
Array<char> text;
text.append(TEXT, sizeof(TEXT));
if (verbose)
{
cout << text.getData() << endl;
}
//
// Parse the text:
//
WQLSelectStatement statement;
try
{
WQLParser::parse(text, statement);
if (verbose)
{
statement.print();
}
//
// Test WQLSelectStatement functions
//
assert (statement.getClassName().equal ("MyClass"));
assert (!statement.getAllProperties());
assert (statement.getSelectPropertyNameCount() == 3);
CIMName propName = statement.getSelectPropertyName (0);
assert ((propName.equal ("x")) || (propName.equal ("y")) ||
(propName.equal ("z")));
CIMPropertyList propList = statement.getSelectPropertyList();
assert (!propList.isNull());
assert (propList.size() == 3);
assert ((propList[0].equal ("x")) || (propList[0].equal ("y")) ||
(propList[0].equal ("z")));
assert (statement.hasWhereClause());
assert (statement.getWherePropertyNameCount() == 3);
CIMName wherePropName = statement.getWherePropertyName (0);
assert ((wherePropName.equal ("x")) || (wherePropName.equal ("y")) ||
(wherePropName.equal ("z")));
CIMPropertyList wherePropList = statement.getWherePropertyList();
assert (!wherePropList.isNull());
assert (wherePropList.size() == 3);
assert ((wherePropList[0].equal ("x")) ||
(wherePropList[0].equal ("y")) ||
(wherePropList[0].equal ("z")));
assert (statement.evaluateWhereClause(&source));
}
catch (Exception& e)
{
cerr << "Exception: " << e.getMessage() << endl;
exit(1);
}
}
void test02()
{
//
// Create a property source (a place for the evaluate to get the
// values of properties from):
//
WQLSimplePropertySource source;
assert(source.addValue("a", WQLOperand(5, WQL_INTEGER_VALUE_TAG)));
assert(source.addValue("b", WQLOperand(25, WQL_INTEGER_VALUE_TAG)));
assert(source.addValue("c", WQLOperand(0.9, WQL_DOUBLE_VALUE_TAG)));
assert(source.addValue("d", WQLOperand("Test", WQL_STRING_VALUE_TAG)));
//
// Define query:
//
const char TEXT[] =
"SELECT a,c,d\n"
"FROM YourClass\n"
"WHERE a > 5 AND b < 25 AND c > 1.2 AND d = \"Pass\"";
//
// Will test WQLParser::parse(const String&, WQLSelectStatement&)
// and WQLParser::parse(const char*, WQLSelectStatement&) forms
//
String text (TEXT);
if (verbose)
{
cout << text << endl;
}
//
// Parse the text:
//
WQLSelectStatement statement;
try
{
WQLParser::parse(text, statement);
if (verbose)
{
statement.print();
}
//
// Test WQLSelectStatement functions
//
assert (statement.getClassName().equal ("YourClass"));
assert (!statement.getAllProperties());
assert (statement.getSelectPropertyNameCount() == 3);
CIMName propName = statement.getSelectPropertyName (2);
assert ((propName.equal ("a")) || (propName.equal ("c")) ||
(propName.equal ("d")));
CIMPropertyList propList = statement.getSelectPropertyList();
assert (!propList.isNull());
assert (propList.size() == 3);
assert ((propList[2].equal ("a")) || (propList[2].equal ("c")) ||
(propList[2].equal ("d")));
assert (statement.hasWhereClause());
assert (statement.getWherePropertyNameCount() == 4);
CIMName wherePropName = statement.getWherePropertyName (3);
assert ((wherePropName.equal ("a")) || (wherePropName.equal ("b")) ||
(wherePropName.equal ("c")) || (wherePropName.equal ("d")));
CIMPropertyList wherePropList = statement.getWherePropertyList();
assert (!wherePropList.isNull());
assert (wherePropList.size() == 4);
assert ((wherePropList[3].equal ("a")) ||
(wherePropList[3].equal ("b")) ||
(wherePropList[3].equal ("c")) ||
(wherePropList[3].equal ("d")));
assert (!statement.evaluateWhereClause(&source));
}
catch (Exception& e)
{
cerr << "Exception: " << e.getMessage() << endl;
exit(1);
}
}
void ConfigSettingProvider::_modifyInstance(
const OperationContext & context,
const CIMObjectPath & instanceReference,
const CIMInstance& modifiedIns,
const CIMPropertyList& propertyList,
Uint32 timeoutSeconds)
{
PEG_METHOD_ENTER(TRC_CONFIG,
"ConfigSettingProvider::_modifyInstance()");
//
// get userName
//
String userName;
try
{
IdentityContainer container = context.get(IdentityContainer::NAME);
userName = container.getUserName();
}
catch (...)
{
userName = String::EMPTY;
}
//
// verify user authorizations
// z/OS: authorization check is done in CIMOpReqAuth already
//
#ifndef PEGASUS_OS_ZOS
if (userName != String::EMPTY)
{
_verifyAuthorization(userName);
}
#endif
// NOTE: Qualifiers are not processed by this provider, so the
// IncludeQualifiers flag is ignored.
//
// check if the class name requested is PG_ConfigSetting
//
if (!instanceReference.getClassName().equal (PG_CONFIG_SETTING))
{
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
instanceReference.getClassName().getString());
}
//
// validate key bindings
//
Array<CIMKeyBinding> kbArray = instanceReference.getKeyBindings();
if ( (kbArray.size() != 1) ||
(!kbArray[0].getName().equal (PROPERTY_NAME)))
{
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L(
CIM_ERR_INVALID_PARAMETER,
MessageLoaderParms(
"ControlProviders.ConfigSettingProvider."
"ConfigSettingProvider."
"INVALID_INSTANCE_NAME",
"Invalid instance name"));
}
String configPropertyName = kbArray[0].getValue();
// Modification of the entire instance is not supported by this provider
if (propertyList.isNull())
{
PEG_METHOD_EXIT();
//l10n
//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
//"Modification of entire instance");
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
MessageLoaderParms(
"ControlProviders.ConfigSettingProvider."
"ConfigSettingProvider."
"MODIFICATION_OF_ENTIRE_INSTANCE",
"Modification of entire instance"));
}
Boolean currentValueModified = false;
Boolean plannedValueModified = false;
for (Uint32 i = 0; i < propertyList.size(); ++i)
{
CIMName propertyName = propertyList[i];
if (propertyName.equal (CURRENT_VALUE))
{
currentValueModified = true;
}
else if (propertyName.equal (PLANNED_VALUE))
{
plannedValueModified = true;
}
else
{
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,
MessageLoaderParms(
"ControlProviders.ConfigSettingProvider."
"ConfigSettingProvider."
"MODIFICATION_NOT_SUPPORTED",
"Modification of property \"$0\"",
propertyName.getString()));
}
}
String preValue;
String currentValue;
String plannedValue;
Boolean currentValueIsNull = false;
Boolean plannedValueIsNull = false;
//
// Get the current value from the instance
//
Uint32 pos = modifiedIns.findProperty(CURRENT_VALUE);
if (pos == PEG_NOT_FOUND)
{
currentValueIsNull = true;
}
else
{
CIMConstProperty prop = modifiedIns.getProperty(pos);
try
{
prop.getValue().get(currentValue);
}
catch (Exception& e)
{
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, e.getMessage());
}
}
//
// Get the planned value from the instance
//
pos = modifiedIns.findProperty(PLANNED_VALUE);
if (pos == PEG_NOT_FOUND)
{
plannedValueIsNull = true;
}
else
{
CIMConstProperty prop = modifiedIns.getProperty(pos);
try
{
prop.getValue().get(plannedValue);
}
catch (Exception& e)
{
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, e.getMessage());
}
}
try
{
//
// Update the current value, if requested
//
if (currentValueModified)
{
preValue = _configManager->getCurrentValue(configPropertyName);
if ( !_configManager->updateCurrentValue(
configPropertyName,
currentValue,
userName,
timeoutSeconds,
currentValueIsNull))
{
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L(
CIM_ERR_FAILED,
MessageLoaderParms(
"ControlProviders.ConfigSettingProvider."
"ConfigSettingProvider."
"UPDATE_CURRENT_VALUE_FAILED",
"Failed to update the current value."));
}
// It is unset, get current value which is default
if (currentValueIsNull)
{
currentValue = _configManager->getCurrentValue(
configPropertyName);
}
// send notify config change message to Handler Service
if(String::equal(configPropertyName,
"maxIndicationDeliveryRetryAttempts")||
String::equal(configPropertyName,
"minIndicationDeliveryRetryInterval"))
{
_sendNotifyConfigChangeMessage(
configPropertyName,
currentValue,
userName,
PEGASUS_QUEUENAME_INDHANDLERMANAGER,
true);
}
// send notify config change message to ProviderManager Service
_sendNotifyConfigChangeMessage(
configPropertyName,
currentValue,
userName,
PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP,
true);
PEG_AUDIT_LOG(logSetConfigProperty(userName, configPropertyName,
preValue, currentValue, false));
}
//
// Update the planned value, if requested
//
if (plannedValueModified)
{
preValue = _configManager->getPlannedValue(configPropertyName);
if ( !_configManager->updatePlannedValue(
configPropertyName, plannedValue, plannedValueIsNull) )
{
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L(
CIM_ERR_FAILED,
MessageLoaderParms(
"ControlProviders.ConfigSettingProvider."
"ConfigSettingProvider."
"UPDATE_PLANNED_VALUE_FAILED",
"Failed to update the planned value."));
}
// It is unset, get planned value which is default
if (plannedValueIsNull)
{
plannedValue = _configManager->getPlannedValue(
configPropertyName);
if (String::equal(configPropertyName,
"maxIndicationDeliveryRetryAttempts") ||
String::equal(configPropertyName,
"minIndicationDeliveryRetryInterval"))
{
_sendNotifyConfigChangeMessage(
configPropertyName,
plannedValue,
userName,
PEGASUS_QUEUENAME_INDHANDLERMANAGER,
false);
}
}
// send notify config change message to ProviderManager Service
_sendNotifyConfigChangeMessage(
configPropertyName,
plannedValue,
userName,
PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP,
false);
PEG_AUDIT_LOG(logSetConfigProperty(userName, configPropertyName,
preValue, plannedValue, true));
}
}
catch (const NonDynamicConfigProperty& ndcp)
{
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION(
CIM_ERR_NOT_SUPPORTED, ndcp.getMessage());
}
catch (const InvalidPropertyValue& ipv)
{
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION(
CIM_ERR_FAILED, ipv.getMessage());
}
catch (const UnrecognizedConfigProperty&)
{
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L(
CIM_ERR_NOT_FOUND,
MessageLoaderParms(
"ControlProviders.ConfigSettingProvider."
"ConfigSettingProvider."
"CONFIG_PROPERTY_NOT_FOUND",
"Configuration property \"$0\"",
configPropertyName));
}
PEG_METHOD_EXIT();
return;
}
/////////////////////////////////////////////////////////////////////////////
// WMIInstanceProvider::modifyInstance
//
// ///////////////////////////////////////////////////////////////////////////
void WMIInstanceProvider::modifyInstance(
const String& nameSpace,
const String& userName,
const String& password,
const CIMInstance& modifiedInstance,
Boolean includeQualifiers,
const CIMPropertyList& propertylist)
{
PEG_METHOD_ENTER(TRC_WMIPROVIDER,"WMIClassProvider::modifyInstance()");
HRESULT hr;
CComPtr<IWbemClassObject> pClass;
CComPtr<IWbemClassObject> pInstance;
setup(nameSpace, userName, password);
PEG_TRACE((TRC_WMIPROVIDER,
Tracer::LEVEL3,
"ModifyInstance() - nameSpace %s, userName %s",
nameSpace.getCString(),
userName.getCString()));
if (!m_bInitialized)
{
PEG_TRACE((TRC_WMIPROVIDER, Tracer::LEVEL1,
"WMIInstanceProvider::ModifyInstance - m_bInitilized= %x, "
"throw CIM_ERR_FAILED exception",
m_bInitialized));
throw CIMException(CIM_ERR_FAILED);
}
// Check if the instance's class is valid.
String className = modifiedInstance.getClassName().getString();
if (!(_collector->getObject(&pClass, className)))
{
if (pClass)
pClass.Release();
throw CIMException(CIM_ERR_INVALID_CLASS);
}
else if (_collector->isInstance(pClass))
{
if (pClass)
pClass.Release();
throw CIMException(CIM_ERR_INVALID_PARAMETER);
}
if (pClass)
pClass.Release();
// Get the instance path
CIMObjectPath objPath = modifiedInstance.getPath();
// Get the name of the instance
String instanceName = getObjectName(objPath);
// Check if the instance exists
if (!(_collector->getObject(&pInstance, instanceName)))
{
if (pInstance)
pInstance.Release();
throw CIMException(CIM_ERR_NOT_FOUND);
}
else if (!(_collector->isInstance(pInstance)))
{
if (pInstance)
pInstance.Release();
throw CIMException(CIM_ERR_INVALID_PARAMETER);
}
// Set the properties that are into propertylist
Array<CIMName> listNames;
listNames = propertylist.getPropertyNameArray();
bool foundInArray;
bool bPropertySet = false;
for(Uint32 i = 0; i < modifiedInstance.getPropertyCount(); i++)
{
CComVariant v;
CIMProperty property = modifiedInstance.getProperty(i).clone();
String sPropName = property.getName().getString();
// change only the properties defined into the array
// if the array is null, change all properties
if (propertylist.isNull())
{
foundInArray = true;
}
else
{
foundInArray = false;
for (Uint32 j = 0; (j < listNames.size()) && !foundInArray; j++)
//if (listNames[j].getString() == str)
if (String::equalNoCase(listNames[j].getString(), sPropName))
foundInArray = true;
}
if (foundInArray)
{
WMIValue propertyValue = property.getValue();
try
{
propertyValue.getAsVariant(&v,nameSpace, userName, password);
}
catch (CIMException&)
{
if (pInstance)
pInstance.Release();
v.Clear();
throw;
}
CComBSTR bs = sPropName.getCString();
hr = pInstance->Put(bs, 0, &v, 0);
v.Clear();
// If we fail to set one property, we must assure
// that the others will be processed
if(SUCCEEDED(hr))
{
// Mark that at least one property was set
bPropertySet = true;
}
}
}
// Check if at least one property was set
// otherwise throw invalid parameter error
if(!bPropertySet)
{
PEG_TRACE((TRC_WMIPROVIDER,
Tracer::LEVEL1,
"modifyInstance() - Put Failed hr=0x%x.",
hr));
throw CIMException(CIM_ERR_FAILED);
}
// Connect to the server
CComPtr<IWbemServices> pServices;
bool bConnected = _collector->Connect(&pServices);
if (!bConnected)
{
throw CIMException(CIM_ERR_ACCESS_DENIED);
}
// Write the instance to WMI.
hr = pServices->PutInstance(pInstance,
WBEM_FLAG_UPDATE_ONLY,
NULL,
NULL);
if (pInstance)
pInstance.Release();
if (pServices)
pServices.Release();
if(FAILED(hr))
{
switch(hr)
{
case E_ACCESSDENIED:
throw CIMException(CIM_ERR_ACCESS_DENIED);
break;
case WBEM_E_ACCESS_DENIED:
throw CIMException(CIM_ERR_ACCESS_DENIED);
break;
case WBEM_E_NOT_FOUND:
throw CIMException(CIM_ERR_NOT_FOUND);
break;
case WBEM_E_INVALID_CLASS:
throw CIMException(CIM_ERR_INVALID_CLASS);
break;
case WBEM_E_INVALID_OBJECT:
throw CIMException(CIM_ERR_INVALID_PARAMETER);
break;
default:
throw CIMException(CIM_ERR_FAILED);
}
}
PEG_METHOD_EXIT();
return;
}