static CMPIStatus mbSetProperty(
const CMPIBroker *mb,
const CMPIContext *ctx,
const CMPIObjectPath *cop,
const char *name,
const CMPIValue *val,
CMPIType type)
{
PEG_METHOD_ENTER(
TRC_CMPIPROVIDERINTERFACE,
"CMPI_Broker:mbSetProperty()");
mb = CM_BROKER;
CMPIrc rc;
CIMValue v = value2CIMValue(val,type,&rc);
SCMOInstance* scmoObjPath = SCMO_ObjectPath(cop);
CIMObjectPath qop;
try
{
scmoObjPath->getCIMObjectPath(qop);
CM_CIMOM(mb)->setProperty(
*CM_Context(ctx),
SCMO_ObjectPath(cop)->getNameSpace(),
qop,
String(name),
v);
}
HandlerCatchReturnStatus();
PEG_METHOD_EXIT();
CMReturn(CMPI_RC_OK);
}
static CMPIData mbGetProperty(
const CMPIBroker *mb,
const CMPIContext *ctx,
const CMPIObjectPath *cop,
const char *name,
CMPIStatus *rc)
{
PEG_METHOD_ENTER(
TRC_CMPIPROVIDERINTERFACE,
"CMPI_Broker:mbGetProperty()");
mb = CM_BROKER;
CMPIData data = {0,CMPI_nullValue,{0}};
SCMOInstance* scmoObjPath = SCMO_ObjectPath(cop);
CIMObjectPath qop;
scmoObjPath->getCIMObjectPath(qop);
try
{
CIMValue v = CM_CIMOM(mb)->getProperty(
*CM_Context(ctx),
SCMO_ObjectPath(cop)->getNameSpace(),
qop,
String(name));
CIMType vType = v.getType();
CMPIType t = type2CMPIType(vType,v.isArray());
value2CMPIData(v,t,&data);
CMSetStatus(rc,CMPI_RC_OK);
}
HandlerCatchSetStatus(rc, data);
PEG_METHOD_EXIT();
return data; // "data" will be valid data or nullValue (in error case)
}
static CMPIStatus mbDeleteInstance(
const CMPIBroker *mb,
const CMPIContext *ctx,
const CMPIObjectPath *cop)
{
PEG_METHOD_ENTER(
TRC_CMPIPROVIDERINTERFACE,
"CMPI_Broker:mbDeleteInstance()");
mb = CM_BROKER;
SCMOInstance* scmoObjPath = SCMO_ObjectPath(cop);
CIMObjectPath qop;
try
{
scmoObjPath->getCIMObjectPath(qop);
CM_CIMOM(mb)->deleteInstance(
*CM_Context(ctx),
SCMO_ObjectPath(cop)->getNameSpace(),
qop);
}
HandlerCatchReturnStatus();
PEG_METHOD_EXIT();
CMReturn(CMPI_RC_OK);
}
static CMPIEnumeration* mbReferenceNames(
const CMPIBroker *mb,
const CMPIContext *ctx,
const CMPIObjectPath *cop,
const char *resultClass,
const char *role,
CMPIStatus *rc)
{
PEG_METHOD_ENTER(
TRC_CMPIPROVIDERINTERFACE,
"CMPI_Broker:mbReferenceNames()");
mb = CM_BROKER;
// ATTN-CAKG-P2-20020726: The following condition does not correctly
// distinguish instanceNames from classNames in every case
// The instanceName of a singleton instance of a keyless class has no
// key bindings
if (!SCMO_ObjectPath(cop)->getKeyBindingCount())
{
CMSetStatus(rc, CMPI_RC_ERR_FAILED);
PEG_METHOD_EXIT();
return 0;
}
SCMOInstance* scmoObjPath = SCMO_ObjectPath(cop);
CIMObjectPath qop;
try
{
scmoObjPath->getCIMObjectPath(qop);
// For compatibility with previous implementations have empty ns
qop.setNameSpace(CIMNamespaceName());
CIMResponseData resData =
CM_CIMOM(mb)->referenceNames(
*CM_Context(ctx),
scmoObjPath->getNameSpace(),
qop,
resultClass ? CIMName(resultClass) : CIMName(),
role ? String(role) : String::EMPTY);
// Add the namespace from the input parameters when neccessary
resData.completeNamespace(scmoObjPath);
Array<SCMOInstance>* aRef =
new Array<SCMOInstance>(resData.getSCMO());
CMPIEnumeration* cmpiEnum = reinterpret_cast<CMPIEnumeration*>(
new CMPI_Object(new CMPI_OpEnumeration(aRef)));
CMSetStatus(rc,CMPI_RC_OK);
PEG_METHOD_EXIT();
return cmpiEnum;
}
HandlerCatchSetStatus(rc, NULL);
// Code flow should never get here.
}
static CMPIInstance* mbGetInstance(
const CMPIBroker *mb,
const CMPIContext *ctx,
const CMPIObjectPath *cop,
const char **properties,
CMPIStatus *rc)
{
PEG_METHOD_ENTER(
TRC_CMPIPROVIDERINTERFACE,
"CMPI_Broker:mbGetInstance()");
mb = CM_BROKER;
CMPIFlags flgs =
ctx->ft->getEntry(ctx,CMPIInvocationFlags,NULL).value.uint32;
const CIMPropertyList props = getList(properties);
SCMOInstance* scmoObjPath = SCMO_ObjectPath(cop);
CIMObjectPath qop;
try
{
scmoObjPath->getCIMObjectPath(qop);
CIMResponseData resData = CM_CIMOM(mb)->getInstance(
*CM_Context(ctx),
scmoObjPath->getNameSpace(),
qop,
CM_IncludeQualifiers(flgs),
CM_ClassOrigin(flgs),
props);
// When running out of process the returned instances don't contain
// a namespace.
// Add the namespace from the input parameters where neccessary
resData.completeNamespace(SCMO_ObjectPath(cop));
SCMOInstance& scmoOrgInst = resData.getSCMO()[0];
SCMOInstance* scmoInst = new SCMOInstance(scmoOrgInst);
// Rebuild the objectPath
scmoInst->buildKeyBindingsFromProperties();
CMPIInstance* cmpiInst = reinterpret_cast<CMPIInstance*>(
new CMPI_Object(scmoInst,CMPI_Object::ObjectTypeInstance));
CMSetStatus(rc,CMPI_RC_OK);
PEG_METHOD_EXIT();
return cmpiInst;
}
HandlerCatchSetStatus(rc, NULL);
// Code flow should never get here.
}
static CMPIData mbInvokeMethod(
const CMPIBroker *mb,
const CMPIContext *ctx,
const CMPIObjectPath *cop,
const char *method,
const CMPIArgs *in,
CMPIArgs *out,
CMPIStatus *rc)
{
PEG_METHOD_ENTER(
TRC_CMPIPROVIDERINTERFACE,
"CMPI_Broker:mbInvokeMethod()");
CMPIData data = {0,CMPI_nullValue,{0}};
mb = CM_BROKER;
SCMOInstance* scmoObjPath = SCMO_ObjectPath(cop);
CIMObjectPath qop;
try
{
scmoObjPath->getCIMObjectPath(qop);
CIMValue v = CM_CIMOM(mb)->invokeMethod(
*CM_Context(ctx),
SCMO_ObjectPath(cop)->getNameSpace(),
qop,
method ? String(method) : String::EMPTY,
*CM_Args(in),
*CM_Args(out));
CIMType vType=v.getType();
CMPIType t = type2CMPIType(vType,v.isArray());
value2CMPIData(v,t,&data);
if (rc)
{
CMSetStatus(rc,CMPI_RC_OK);
}
}
HandlerCatchSetStatus(rc, data);
PEG_METHOD_EXIT();
return data; // "data" will be valid data or nullValue (in error case)
}
/**
Function to convert CMPIValue to CIMValue
*/
CIMValue value2CIMValue(const CMPIValue* data, const CMPIType type, CMPIrc *rc)
{
CIMValue v;
if( rc )
{
*rc=CMPI_RC_OK;
}
/**
check data for NULL if type is not CMPIArray.
*/
if( !(type & CMPI_ARRAY) && !data )
{
return CIMValue(type2CIMType(type), false);
}
/**
Case when type is CMPIArray
*/
if( type & CMPI_ARRAY )
{
//Return if data itself is NULL or Array is NULL
if( data == NULL || data->array == NULL )
{
CMPIType aType=type&~CMPI_ARRAY;
return CIMValue(type2CIMType(aType),true);
}
// When data is not NULL and data->array is also set
CMPIArray *ar=data->array;
CMPIData *aData=(CMPIData*)((CMPI_Array*)ar->hdl)->hdl;
//Get the type of the elements in the array
CMPIType aType=aData->type&~CMPI_ARRAY;
int aSize=aData->value.sint32;
aData++;
// Checks for Signed Integers
if( (aType & (CMPI_UINT|CMPI_SINT))==CMPI_SINT )
{
switch( aType )
{
case CMPI_sint32:
CopyToArray(Sint32,sint32);
break;
case CMPI_sint16:
CopyToArray(Sint16,sint16);
break;
case CMPI_sint8:
CopyToArray(Sint8,sint8);
break;
case CMPI_sint64:
CopyToArray(Sint64,sint64);
break;
default: ;
}
}
else
if( aType == CMPI_chars )
{
CopyToStringArray(String,string->hdl)
}
else
if( aType == CMPI_charsptr )
{
CopyCharsptrToStringArray(String,chars)
}
else
if( aType == CMPI_string )
{
CopyToStringArray(String,string->hdl)
}
// Checks for Unsigned Integers
else
if( (aType & (CMPI_UINT|CMPI_SINT))==CMPI_UINT )
{
switch( aType )
{
case CMPI_uint32:
CopyToArray(Uint32,uint32);
break;
case CMPI_uint16:
CopyToArray(Uint16,uint16);
break;
case CMPI_uint8:
CopyToArray(Uint8,uint8);
break;
case CMPI_uint64:
CopyToArray(Uint64,uint64);
break;
default: ;
}
}
else
{
switch( aType )
{
case CMPI_ref:
{
Array<CIMObjectPath> arCIMObjectPath(aSize);
ArrayIterator<CIMObjectPath> iterator(arCIMObjectPath);
for (int i=0; i<aSize; i++)
{
SCMOInstance* scmoInst =
(SCMOInstance*)aData[i].value.ref->hdl;
scmoInst->getCIMObjectPath(iterator[i]);
}
v.set(arCIMObjectPath);
}
break;
case CMPI_dateTime:
CopyToEncArray(CIMDateTime,dateTime);
break;
case CMPI_instance:
{
Array<CIMObject> arCIMInstance(aSize);
ArrayIterator<CIMObject> iterator(arCIMInstance);
for (int i=0; i<aSize; i++)
{
SCMOInstance* scmoInst =
(SCMOInstance*)aData[i].value.inst->hdl;
CIMInstance inst;
scmoInst->getCIMInstance(inst);
CIMObject obj(inst);
iterator[i]=obj;
}
v.set(arCIMInstance);
}
break;
case CMPI_boolean:
CopyToArray(Boolean,boolean);
break;
case CMPI_char16:
CopyToArray(Char16,char16);
break;
case CMPI_real32:
CopyToArray(Real32,real32);
break;
case CMPI_real64:
CopyToArray(Real64,real64);
break;
default:
if( rc )
{
*rc=CMPI_RC_ERR_NOT_SUPPORTED;
}
}
}
return CIMValue(v);
} // end of array processing
//Start of non - array types processing
else
if( type == CMPI_chars )
static CMPIEnumeration* mbAssociators(
const CMPIBroker *mb,
const CMPIContext *ctx,
const CMPIObjectPath *cop,
const char *assocClass,
const char *resultClass,
const char *role,
const char *resultRole,
const char **properties,
CMPIStatus *rc)
{
PEG_METHOD_ENTER(
TRC_CMPIPROVIDERINTERFACE,
"CMPI_Broker:mbAssociators()");
mb = CM_BROKER;
// ATTN-CAKG-P2-20020726: The following condition does not correctly
// distinguish instanceNames from classNames in every case
// The instanceName of a singleton instance of a keyless class has no
// key bindings
if (!SCMO_ObjectPath(cop)->getKeyBindingCount())
{
CMSetStatus(rc, CMPI_RC_ERR_FAILED);
PEG_METHOD_EXIT();
return 0;
}
CMPIFlags flgs =
ctx->ft->getEntry(ctx,CMPIInvocationFlags,NULL).value.uint32;
const CIMPropertyList props = getList(properties);
SCMOInstance* scmoObjPath = SCMO_ObjectPath(cop);
CIMObjectPath qop;
try
{
scmoObjPath->getCIMObjectPath(qop);
// For compatibility with previous implementations have empty ns
qop.setNameSpace(CIMNamespaceName());
CIMResponseData resData =
CM_CIMOM(mb)->associators(
*CM_Context(ctx),
SCMO_ObjectPath(cop)->getNameSpace(),
qop,
assocClass ? CIMName(assocClass) : CIMName(),
resultClass ? CIMName(resultClass) : CIMName(),
role ? String(role) : String::EMPTY,
resultRole ? String(resultRole) : String::EMPTY,
CM_IncludeQualifiers(flgs),
CM_ClassOrigin(flgs),
props);
// When running out of process the returned instances don't contain
// a namespace.
// Add the namespace from the input parameters where neccessary
resData.completeNamespace(scmoObjPath);
Array<SCMOInstance>* aObj =
new Array<SCMOInstance>(resData.getSCMO());
CMPIEnumeration* cmpiEnum = reinterpret_cast<CMPIEnumeration*>(
new CMPI_Object(new CMPI_ObjEnumeration(aObj)));
CMSetStatus(rc,CMPI_RC_OK);
PEG_METHOD_EXIT();
return cmpiEnum;
}
HandlerCatchSetStatus(rc, NULL);
// Code flow should never get here.
}
