CMPIStatus Linux_FanAssociatedSensorProviderEnumInstances(
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * ref,
const char ** properties)
{
UNUSED(mi); UNUSED(properties);
CMPIStatus rc = {CMPI_RC_OK, NULL};
int refrc = 0;
_OSBASE_TRACE(1,("--- %s CMPI EnumInstances() called",_ClassName));
refrc = _assoc_create_inst_1toN( _broker,ctx,rslt,ref,
_ClassName,_RefLeftClass,_RefRightClass,
_RefLeft,_RefRight,
1,1,&rc);
if( refrc != 0 ) {
if( rc.msg != NULL ) {
_OSBASE_TRACE(1, ("--- %s CMPI EnumInstances() failed : %s",
_ClassName,CMGetCharPtr(rc.msg)));
}
else {
_OSBASE_TRACE(1,("--- %s CMPI EnumInstances() failed",_ClassName));
}
return rc;
}
CMReturnDone( rslt );
_OSBASE_TRACE(1,("--- %s CMPI EnumInstances() exited",_ClassName));
return rc;
}
CMPIStatus Linux_FanAssociatedSensorProviderGetInstance(
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * cop,
const char ** properties)
{
UNUSED(mi); UNUSED(properties);
const CMPIInstance * ci = NULL;
CMPIStatus rc = {CMPI_RC_OK, NULL};
_OSBASE_TRACE(1,("--- %s CMPI GetInstance() called",_ClassName));
ci = _assoc_get_inst( _broker,ctx,cop,_ClassName,_RefLeft,_RefRight,&rc);
if( ci == NULL ) {
if( rc.msg != NULL ) {
_OSBASE_TRACE(1, ("--- %s CMPI GetInstance() failed : %s",
_ClassName,CMGetCharPtr(rc.msg)));
}
else {
_OSBASE_TRACE(1,("--- %s CMPI GetInstance() failed",_ClassName));
}
return rc;
}
CMReturnInstance( rslt, ci );
CMReturnDone(rslt);
_OSBASE_TRACE(1,("--- %s CMPI GetInstance() exited",_ClassName));
return rc;
}
CMPIStatus Linux_FanAssociatedSensorProviderAssociators(
CMPIAssociationMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * cop,
const char * assocClass,
const char * resultClass,
const char * role,
const char * resultRole,
const char ** propertyList)
{
UNUSED(mi); UNUSED(propertyList);
CMPIStatus rc = {CMPI_RC_OK, NULL};
CMPIObjectPath * op = NULL;
int refrc = 0;
_OSBASE_TRACE(1,("--- %s CMPI Associators() called",_ClassName));
if( assocClass ) {
op = CMNewObjectPath( _broker, CMGetCharPtr(CMGetNameSpace(cop,&rc)),
_ClassName, &rc );
if( op==NULL ) {
CMSetStatusWithChars( _broker, &rc,
CMPI_RC_ERR_FAILED, "Create CMPIObjectPath failed." );
_OSBASE_TRACE(2,
("--- %s CMPI Associators() failed : %s",CMGetCharPtr(rc.msg)));
return rc;
}
}
if ( (assocClass == NULL)
|| (CMClassPathIsA(_broker,op,assocClass,&rc) == 1))
{
if( _assoc_check_parameter_const( _broker,cop,_RefLeft,_RefRight,
_RefLeftClass,_RefRightClass,
resultClass,role,resultRole,
&rc ) == 0 ) { goto exit; }
refrc = _assoc_create_refs_1toN(_broker, ctx, rslt, cop,
_ClassName,_RefLeftClass,_RefRightClass,
_RefLeft,_RefRight,
1, 1, &rc);
if( refrc != 0 ) {
if( rc.msg != NULL ) {
_OSBASE_TRACE(1, ("--- %s CMPI Associators() failed : %s",
_ClassName,CMGetCharPtr(rc.msg)));
}
else {
_OSBASE_TRACE(1,("--- %s CMPI Associators() failed",_ClassName));
}
return rc;
}
}
exit:
CMReturnDone( rslt );
_OSBASE_TRACE(1,("--- %s CMPI Associators() exited",_ClassName));
CMReturn(CMPI_RC_OK);
}
/**
Enumerate the Instances serviced by this provider.
*/
CMPIStatus TestInstanceProviderEnumInstances (
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * op,
const char **properties)
{
CMPIStatus rc = {CMPI_RC_OK, NULL};
unsigned int j = 0;
CMPIData data;
/* get the element from array containing created instances */
for (j = 0; j < numOfInst; j++)
{
/* check for validity of Instance, that its not deleted */
if(valid[j] == 1)
{
/* get element(instance) from array */
data = CMGetArrayElementAt(clone_arr_ptr, j, &rc);
/* return the instance */
CMReturnInstance(rslt, data.value.inst);
}
}
CMReturnDone (rslt);
CMReturn (CMPI_RC_OK);
}
/**
Enumerate ObjectPaths of Instances serviced by this provider.
*/
CMPIStatus TestInstanceProviderEnumInstanceNames (
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * ref)
{
CMPIStatus rc = {CMPI_RC_OK, NULL};
unsigned int j = 0;
CMPIObjectPath *local;
CMPIData data;
/* get the element from array containing created instances. */
for (j = 0; j < numOfInst; j++)
{
/*check for validity of Instance, that its not deleted */
if(valid[j] == 1)
{
/* get element(instance) from array */
data = CMGetArrayElementAt(clone_arr_ptr, j, &rc);
/* get object-path of that instance */
local = CMGetObjectPath(data.value.inst, &rc);
/* return object-path */
CMReturnObjectPath(rslt,local);
}
}
CMReturnDone (rslt);
CMReturn (CMPI_RC_OK);
}
CMPIStatus CWS_DirectoryGetInstance( CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * cop,
const char ** properties)
{
CMPIInstance *in = NULL;
CMPIStatus st = {CMPI_RC_OK,NULL};
CMPIData nd = CMGetKey(cop,"Name",&st);
CWS_FILE filebuf;
if (!silentMode()) fprintf(stderr,"--- CWS_DirectoryGetInstance() \n");
if (st.rc == CMPI_RC_OK &&
nd.type == CMPI_string &&
CWS_Get_File(CMGetCharsPtr(nd.value.string, NULL),&filebuf))
in = makeInstance(_broker,
LOCALCLASSNAME,
CMGetCharsPtr(CMGetNameSpace(cop,NULL), NULL),
&filebuf);
if (CMIsNullObject(in)) {
CMSetStatusWithChars(_broker, &st, CMPI_RC_ERR_FAILED,
"Could not find or construct instance");
} else {
CMReturnInstance(rslt,in);
CMReturnDone(rslt);
}
return st;
}
CMPIStatus cmpiPerf_TestClassProviderEnumInstanceNames(
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * ref)
{
CMPIObjectPath * op = NULL;
CMPIStatus rc = {CMPI_RC_OK, NULL};
unsigned int index = 0;
unsigned int numInst = 1;
//
// While the instance itself is hard code, the number of instances
// is determined from an environment variable
//
numInst = getNumberOfInstances();
for (index=0; index < numInst; index++)
{
op = _makePath_TestClass( _broker, ctx, ref, index );
if (op == NULL)
{
return rc;
}
CMReturnObjectPath( rslt, op );
CMRelease( op );
}
CMReturnDone( rslt );
return rc;
}
static int
_testCMPIResult(const CMPIResult *rslt)
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIValue value;
CMPIType type;
const CMPIObjectPath *objPath = NULL;
CMPIBoolean returnDataSuccessful = 0;
value.uint32 = 10;
type = CMPI_uint32;
rc = CMReturnData(rslt, &value, type);
if (rc.rc == CMPI_RC_OK) {
returnDataSuccessful = 1;
}
objPath = make_ObjectPath(_broker, _Namespace, _ClassName);
rc = CMReturnObjectPath(rslt, objPath);
rc = CMReturnDone(rslt);
rc = CMReturnData(rslt, NULL, type);
if (rc.rc != CMPI_RC_ERR_INVALID_PARAMETER) {
return 1;
}
return 0;
}
/**
Create Instance from inst, using object-path op as reference.
*/
CMPIStatus TestInstanceProviderCreateInstance (
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * cop,
const CMPIInstance * ci)
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIInstance * inst;
CMPIValue value_inst;
CMPIData key1,key2, retInst;
CMPIObjectPath *obp;
unsigned int j = 0;
if(ci)
{
/* clone the instance to be added to the array */
inst = CMClone(ci, &rc);
key1 = CMGetProperty(inst, "Identifier", &rc);
for (j=0; j < numOfInst ; j++)
{
/* check for validity of Instance, that its not deleted */
if (valid[j] == 1)
{
/* get element(instance) from array */
retInst = CMGetArrayElementAt(clone_arr_ptr, j, &rc);
/* get object-path of instance */
obp = CMGetObjectPath(retInst.value.inst, &rc);
/* get key from this object-path */
key2 = CMGetKey(obp, "Identifier", &rc);
/*compare key values.
If they match throw exception as two instance with same key
properties cannot exists. */
if(key1.value.uint8 == key2.value.uint8)
{
CMRelease(inst);
CMReturn (CMPI_RC_ERR_ALREADY_EXISTS);
}
}
}
value_inst.inst = inst;
/* If instance doesnot exists in array add it */
rc = CMSetArrayElementAt(
clone_arr_ptr,
numOfInst,
&value_inst,
CMPI_instance);
valid[numOfInst]=1;
numOfInst++;
/* return object-path of instance */
CMReturnObjectPath(rslt, cop);
CMReturnDone(rslt);
}
else
{
CMReturn (CMPI_RC_ERR_NOT_SUPPORTED);
}
CMRelease(inst);
CMReturn (CMPI_RC_OK);
}
/**
Replace an existing Instance from inst, using object-path op as reference.
*/
CMPIStatus TestInstanceProviderModifyInstance (
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * cop,
const CMPIInstance * ci,
const char **properties)
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIInstance * inst;
CMPIValue val1, val2;
CMPIData key1, key2, retData1, retInst;
CMPIObjectPath *obp;
unsigned int j = 0, flag = 0;
if(ci)
{
inst = CMClone(ci, &rc);
/* get key from the object-path */
key1 = CMGetKey(cop, "Identifier", &rc);
val1.uint8 = key1.value.uint8;
/* get the value of Message property */
retData1 = CMGetProperty(inst, "Message", &rc);
val2.string = retData1.value.string;
for (j=0; j < numOfInst; j++)
{
/* check for validity of Instance, that its not deleted */
if (valid[j] == 1)
{
/* get element(instance) from array */
retInst = CMGetArrayElementAt(clone_arr_ptr, j, &rc);
/* get object-path of instance */
obp = CMGetObjectPath(retInst.value.inst, &rc);
/* get key from this object-path */
key2 = CMGetKey(obp, "Identifier", &rc);
/*compare key values.
If they match then set the properties received from client */
if(key1.value.uint8 == key2.value.uint8)
{
CMSetProperty(
retInst.value.inst,
"Message",
&val2,
CMPI_string);
flag = 1;
}
}
}
CMRelease(inst);
/*If match fails, throw exception, as instance to be mmodified is not
found */
if(!flag)
{
CMReturn (CMPI_RC_ERR_NOT_FOUND);
}
}
CMReturnDone (rslt);
CMReturn (CMPI_RC_OK);
}
CMPIStatus
TestCMPIFail_4ProviderDeleteInstance (CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * cop)
{
// This out-of-place macro was added to test bug #4107
// in which CMReturnDone without a previous CMReturnInstance would
// crash cimserver.
CMReturnDone(rslt);
CMReturnWithChars (_broker, CMPI_RC_ERR_NOT_FOUND, _msg);
}
CMPIStatus Linux_FanProviderEnumInstances( CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * ref,
const char ** properties) {
UNUSED(mi);
CMPIInstance * ci = NULL;
CMPIStatus rc = {CMPI_RC_OK, NULL};
struct fanlist * lptr = NULL;
struct fanlist * rm = NULL;
_OSBASE_TRACE(1,("--- %s CMPI EnumInstances() called",_ClassName));
if (enum_all_fans(&lptr)) {
CMSetStatusWithChars(_broker, &rc,
CMPI_RC_ERR_FAILED, "Could not list fans.");
_OSBASE_TRACE(1, ("--- %s CMPI EnumInstances() failed : %s",
_ClassName,CMGetCharPtr(rc.msg)));
return rc;
}
// iterate fan list
for (rm=lptr; lptr && rc.rc == CMPI_RC_OK; lptr = lptr->next) {
// method call to create the CMPIInstance object
ci = _makeInst_Fan(_broker, ctx, ref, properties, lptr->f, &rc);
if (ci == NULL || rc.rc != CMPI_RC_OK ) {
if (rc.msg != NULL ) {
_OSBASE_TRACE(1, ("--- %s CMPI EnumInstances() failed :"
" %s",_ClassName,CMGetCharPtr(rc.msg)));
}
CMSetStatusWithChars( _broker, &rc,
CMPI_RC_ERR_FAILED, "Transformation from internal"
" structure to CIM Instance failed.");
if (rm) free_fanlist(rm);
_OSBASE_TRACE(1, ("--- %s CMPI EnumInstances() failed :"
" %s", _ClassName,CMGetCharPtr(rc.msg)));
return rc;
}else {
CMReturnInstance(rslt, ci);
}
}
if (rm) free_fanlist(rm);
CMReturnDone(rslt);
_OSBASE_TRACE(1, ("--- %s CMPI EnumInstances() exited", _ClassName));
return rc;
}
/*
Get the Instances defined by <op>.
Parameters:
mi - Provider this pointer.
ctx - Invocation Context.
rslt - Result data container.
cop - ObjectPath containing namespace, classname and key components.
properties - If not NULL, the members of the array define one or more Property names. Each returned Object MUST NOT include elements for any Properties missing from this list.
Returns:
Function return status. The following CMPIrc codes shall be recognized: CMPI_RC_OK Operation successful. CMPI_RC_ERR_FAILED Unspecific error occurred.
CMPI_RC_ERR_NOT_SUPPORTED Operation not supported by this MI. CMPI_RC_ERR_ACCESS_DENIED Not authorized. CMPI_RC_ERR_NOT_FOUND Instance not found.
*/
CMPIStatus GK_TestGetInstance( CMPIInstanceMI * mi,
CMPIContext * ctx,
CMPIResult * rslt,
CMPIObjectPath * cop,
char ** properties) {
const CMPIInstance * ci = NULL;
CMPIStatus rc = {CMPI_RC_OK, NULL};
CMPIString * instanceId = NULL;
printf("--- %s CMPI GetInstance() called",_ClassName);
instanceId = CMGetKey( cop, "InstanceID", &rc).value.string;
if( instanceId == NULL ) {
CMSetStatusWithChars( _broker, &rc,
CMPI_RC_ERR_NOT_FOUND, "Could not get InstanceID." );
goto exit;
}
if ( strcmp(CMGetCharPtr(instanceId),_InstanceID) != 0){
CMSetStatusWithChars( _broker, &rc,
CMPI_RC_ERR_NOT_FOUND, "This class name does not exist (wrong InstanceID)." );
goto exit;
}
ci = _makeInst_GK_Test(cop, &rc );
if( ci == NULL ){
CMSetStatusWithChars(_broker, &rc, CMPI_RC_ERR_FAILED,
"Couldn't build instance");
goto exit;
}
CMReturnInstance( rslt, ci );
CMReturnDone(rslt);
exit:
return rc;
}
/**
Get the Instances defined by object-path op.
*/
CMPIStatus TestInstanceProviderGetInstance (
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * op,
const char **properties)
{
CMPIData data,key1,key2;
CMPIObjectPath *local;
unsigned int j = 0;
CMPIBoolean flag = 0;
CMPIStatus rc = {CMPI_RC_OK, NULL};
/* get the kay from object-path */
key1 = CMGetKey(op, "Identifier", &rc);
/* get the element from array containing created instances */
for(j = 0; j < numOfInst; j++)
{
/* check for validity of Instance, that its not deleted */
if (valid[j] == 1)
{
/* get element(instance) from array */
data = CMGetArrayElementAt(clone_arr_ptr, j, &rc);
/* get object-path of instance */
local = CMGetObjectPath(data.value.inst, &rc);
/* get key from this object-path */
key2 = CMGetKey(local, "Identifier", &rc);
/* compare key values.
If they match return instance */
if (key1.value.uint8 == key2.value.uint8)
{
CMReturnInstance(rslt, data.value.inst);
flag =1;
}
}
}
/* key values did not match so throw exception */
if(!flag)
{
CMReturn (CMPI_RC_ERR_NOT_FOUND);
}
CMReturnDone (rslt);
CMReturn (CMPI_RC_OK);
}
CMPIStatus indProvInvokeMethod
(CMPIMethodMI * cThis, const CMPIContext *ctx,
const CMPIResult *rslt, const CMPIObjectPath * cop,
const char *method, const CMPIArgs * in, CMPIArgs * out) {
CMPIValue value;
fprintf(stderr, "+++ indProvInvokeMethod()\n");
if (enabled == 0) {
fprintf(stderr, "+++ PROVIDER NOT ENABLED\n");
} else {
generateIndication(method, ctx);
}
value.uint32 = 0;
CMReturnData(rslt, &value, CMPI_uint32);
CMReturnDone(rslt);
CMReturn(CMPI_RC_OK);
}
static CMPIStatus
ResourceGroupInvokeMethod(CMPIMethodMI * mi, CMPIContext * ctx,
CMPIResult * rslt, CMPIObjectPath * ref,
const char * method_name, CMPIArgs * in, CMPIArgs * out)
{
CMPIString * classname = NULL;
CMPIStatus rc = {CMPI_RC_OK, NULL};
int ret = 0;
classname = CMGetClassName(ref, &rc);
if(strcasecmp(CMGetCharPtr(classname), ClassName) == 0 &&
strcasecmp(METHOD_ADD_PRIMITIVE_RESOURCE, method_name) == 0){
ret = resource_add_subrsc(Broker, ClassName, ctx, rslt,
ref, TID_RES_GROUP, in, out, &rc);
}
CMReturnData(rslt, &ret, CMPI_uint32);
CMReturnDone(rslt);
CMReturn(CMPI_RC_OK);
}
CMPIStatus TestCMPIBrokerInstanceProviderExecQuery (CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * ref,
const char *lang,
const char *query)
{
CMPIData retData;
CMPIString* type;
CMPIBoolean bol=0;
CMPIStatus rc = {CMPI_RC_OK, NULL};
PROV_LOG_OPEN (_ClassName, _ProviderLocation);
PROV_LOG ("ExecQuery");
retData = CMGetProperty(_inst, "n64", &rc);
PROV_LOG("++++ Status of CMGetProperty : (%s)",
strCMPIStatus(rc));
PROV_LOG("n64 = %" PEGASUS_64BIT_CONVERSION_WIDTH "u",
retData.value.uint64);
type = CDGetType (_broker, rslt, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type "
"CMPIResult with CMPI_ResultExecQueryOnStack_Ftab : (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
bol = CDIsOfType (_broker, rslt, "CMPIResult", &rc);
if ( bol )
{
PROV_LOG ("++++ CDIsOfType for CMPIResult with "
"CMPI_ResultExecQueryOnStack_Ftab status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
PROV_LOG_CLOSE();
CMReturnInstance(rslt, _inst);
CMReturnDone(rslt);
CMReturn (CMPI_RC_OK);
}
CMPIStatus CWS_DirectoryEnumInstances( CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * ref,
const char ** properties)
{
CMPIInstance *in;
CMPIStatus st = {CMPI_RC_OK,NULL};
void *enumhdl;
CWS_FILE filebuf;
if (!silentMode()) fprintf(stderr,"--- CWS_DirectoryEnumInstances() \n");
enumhdl = CWS_Begin_Enum(CWS_FILEROOT,CWS_TYPE_DIR);
if (enumhdl == NULL) {
CMSetStatusWithChars(_broker, &st, CMPI_RC_ERR_FAILED,
"Could not begin file enumeration");
return st;
} else {
while (CWS_Next_Enum(enumhdl,&filebuf)) {
/* build instance from file buffer */
in = makeInstance(_broker,
LOCALCLASSNAME,
CMGetCharsPtr(CMGetNameSpace(ref,NULL), NULL),
&filebuf);
if (CMIsNullObject(in)) {
CMSetStatusWithChars(_broker, &st, CMPI_RC_ERR_FAILED,
"Could not construct instance");
break;
}
CMReturnInstance(rslt,in);
}
CMReturnDone(rslt);
CWS_End_Enum(enumhdl);
}
return st;
}
/*
Enumerate the Instances serviced by this provider.
Parameters:
mi - Provider this pointer.
ctx - Invocation Context.
rslt - Result data container.
ref - ObjectPath containing namespace and classname components.
properties - If not NULL, the members of the array define one or more Property names. Each returned Object MUST NOT include elements for any Properties missing from this list.
Returns:
Function return status. The following CMPIrc codes shall be recognized: CMPI_RC_OK Operation successful. CMPI_RC_ERR_FAILED Unspecific error occurred.
CMPI_RC_ERR_NOT_SUPPORTED Operation not supported by this MI. CMPI_RC_ERR_ACCESS_DENIED Not authorized. CMPI_RC_ERR_NOT_FOUND Instance not found.
*/
CMPIStatus GK_TestEnumInstances( CMPIInstanceMI * mi,
CMPIContext * ctx,
CMPIResult * rslt,
CMPIObjectPath * ref,
char ** properties) {
CMPIStatus rc = {CMPI_RC_OK, NULL};
const CMPIInstance * ci = NULL;
ci = _makeInst_GK_Test( ref, &rc );
if( ci == NULL) {
CMSetStatusWithChars(_broker, &rc, CMPI_RC_ERR_FAILED,
"Couldn't build instance");
goto exit;
}
CMReturnInstance( rslt, ci );
CMReturnDone( rslt );
exit:
return rc;
}
CMPIStatus cmpiPerf_TestClassProviderGetInstance(
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * cop,
const char ** properties)
{
CMPIInstance * ci = NULL;
CMPIStatus rc = {CMPI_RC_OK, NULL};
ci = _makeInst_TestClass(_broker,ctx,cop,properties,1);
if (ci == NULL)
{
return rc;
}
CMReturnInstance( rslt, ci );
CMReturnDone(rslt);
return rc;
}
static CMPIStatus
ResourceCloneInvokeMethod(CMPIMethodMI * mi, CMPIContext * ctx,
CMPIResult * rslt, CMPIObjectPath * ref,
const char * method_name, CMPIArgs * in, CMPIArgs * out)
{
CMPIString * classname = NULL;
CMPIStatus rc = {CMPI_RC_OK, NULL};
int ret = 0;
PROVIDER_INIT_LOGGER();
DEBUG_ENTER();
classname = CMGetClassName(ref, &rc);
if(strcasecmp(CMGetCharPtr(classname), ClassName) == 0 &&
strcasecmp(METHOD_ADD_RESOURCE, method_name) == 0 ){
ret = resource_add_subrsc(Broker, ClassName, ctx, rslt,
ref, TID_RES_CLONE, in, out, &rc);
}
CMReturnData(rslt, &ret, CMPI_uint32);
CMReturnDone(rslt);
DEBUG_LEAVE();
CMReturn(CMPI_RC_OK);
}
static CMPIStatus
PrimitiveResourceInvokeMethod(CMPIMethodMI * mi, CMPIContext * ctx,
CMPIResult * rslt, CMPIObjectPath * ref,
const char * method_name, CMPIArgs * in, CMPIArgs * out)
{
CMPIString * classname = NULL;
CMPIStatus rc = {CMPI_RC_OK, NULL};
int ret = 0;
classname = CMGetClassName(ref, &rc);
if(strcasecmp(CMGetCharPtr(classname), ClassName) == 0 &&
strcasecmp(METHOD_ADD_OPERATION, method_name) == 0 ){
#if 0
ret = resource_add_operation(Broker, ClassName, ctx, rslt,
ref, TID_RES_PRIMITIVE, in, out, &rc);
#endif
ret = HA_OK;
}
CMReturnData(rslt, &ret, CMPI_uint32);
CMReturnDone(rslt);
CMReturn(CMPI_RC_OK);
}
/*
Enumerate ObjectPaths of Instances serviced by this provider.
Parameters:
mi - Provider this pointer.
ctx - Invocation Context.
rslt - Result data container.
ref - ObjectPath containing namespace and classname components.
Returns:
Function return status. The following CMPIrc codes shall be recognized: CMPI_RC_OK Operation successful.
CMPI_RC_ERR_FAILED Unspecific error occurred. CMPI_RC_ERR_NOT_SUPPORTED Operation not supported by this MI. CMPI_RC_ERR_ACCESS_DENIED Not authorized.
CMPI_RC_ERR_NOT_FOUND Instance not found.
*/
CMPIStatus GK_TestEnumInstanceNames( CMPIInstanceMI * mi,
CMPIContext * ctx,
CMPIResult * rslt,
CMPIObjectPath * ref) {
CMPIObjectPath * op = NULL;
CMPIStatus rc = {CMPI_RC_OK, NULL};
op = _makePath_GK_Test( ref, &rc );
if( op == NULL) {
CMSetStatusWithChars(_broker, &rc, CMPI_RC_ERR_FAILED,
"Couldn't build objectpath");
goto exit;
}
CMReturnObjectPath( rslt, op );
CMReturnDone( rslt );
exit:
return rc;
}
CMPIStatus cmpiPerf_TestClassProviderCreateInstance(
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * cop,
const CMPIInstance * ci)
{
CMPIObjectPath * op = NULL;
CMPIStatus rc = {CMPI_RC_OK, NULL};
unsigned int numInst = 1;
numInst = getNumberOfInstances()+1;
op = _makePath_TestClass( _broker, ctx, cop, numInst );
CMReturnObjectPath( rslt, op );
CMReturnDone( rslt );
setNumberOfInstances(numInst);
return rc;
}
CMPIStatus TestCMPIBrokerInstanceProviderGetInstance (CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * cop,
const char **properties)
{
CMPIStatus rc = {CMPI_RC_OK, NULL};
CMPIString* retNamespace;
CMPIString* retClassname;
CMPIString* type;
CMPIData retData;
CMPIObjectPath* obj;
CMPIBoolean bol = 0;
const char* str1;
const char* str2;
PROV_LOG_OPEN (_ClassName, _ProviderLocation);
PROV_LOG("GetInstance");
PROV_LOG("++++Namespace ");
obj = CMGetObjectPath(_inst, &rc);
PROV_LOG("++++ Status of CMGetObjectPath : (%s)",
strCMPIStatus(rc));
retNamespace = CMGetNameSpace(obj, &rc);
PROV_LOG("++++ Status of CMGetNameSpace : (%s)",
strCMPIStatus(rc));
retClassname = CMGetClassName(obj, &rc);
PROV_LOG("++++ Status of CMGetClassName : (%s)",
strCMPIStatus(rc));
str1 = CMGetCharsPtr(retNamespace, &rc);
PROV_LOG("++++ Status of CMGetCharsPtr : (%s)",
strCMPIStatus(rc));
str2 = CMGetCharsPtr(retClassname, &rc);
PROV_LOG("++++ Status of CMGetCharsPtr : (%s)",
strCMPIStatus(rc));
retData = CMGetProperty(_inst, "n64", &rc);
PROV_LOG("++++ Status of CMGetProperty : (%s)",
strCMPIStatus(rc));
PROV_LOG("n64 = %" PEGASUS_64BIT_CONVERSION_WIDTH "u",
retData.value.uint64);
/* Test cases for increasing coverage in CMPI_BrokerEnc.cpp*/
type = CDGetType (_broker, rslt, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type "
"CMPIResult with CMPI_ResultInstOnStack_Ftab : (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
bol = CDIsOfType (_broker, rslt, "CMPIResult", &rc);
if ( bol )
{
PROV_LOG ("++++ CDIsOfType for CMPIResult with "
"CMPI_ResultInstOnStack_Ftab status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
PROV_LOG_CLOSE();
if (_inst)
{
CMReturnInstance(rslt, _inst);
CMReturnDone(rslt);
CMReturn (CMPI_RC_OK);
}
else
{
CMReturn (CMPI_RC_ERR_NOT_SUPPORTED);
}
}
CMPIStatus TestCMPIBrokerInstanceProviderCreateInstance (CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * cop,
const CMPIInstance * ci)
{
const CMPIString* retNamespace;
const CMPIString* retClassname;
CMPIString* type;
const char* str1;
const char* str2;
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIData retData;
CMPIObjectPath *obj;
CMPIBoolean bol = 0;
PROV_LOG_OPEN (_ClassName, _ProviderLocation);
PROV_LOG("CreateInstance");
retNamespace = CMGetNameSpace(cop, &rc);
retClassname = CMGetClassName(cop, &rc);
str1 = CMGetCharsPtr(retNamespace, &rc);
str2 = CMGetCharsPtr(retClassname, &rc);
PROV_LOG("++++Obtained Namespace : (%s) Class (%s)", str1, str2);
if(ci)
{
/* Test to increase coverage in Broker_Enc.cpp*/
type = CDToString (_broker, ci, &rc);
PROV_LOG ("++++ Passing CMPIInstance with CMPI_InstanceOnStack_Ftab "
"to mbEncToString successes : "
"(%s)",
strCMPIStatus (rc));
type = CDGetType (_broker, ci, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIInstance"
" : (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
bol = CDIsOfType (_broker, ci, "CMPIInstance", &rc);
if ( bol )
{
PROV_LOG ("++++ CDIsOfType for CMPIInstance with "
"CMPI_InstanceOnStack_Ftab status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
type = CDToString (_broker, cop, &rc);
PROV_LOG ("++++ Passing CMPIObjectPath with "
"CMPI_ObjectPathOnStack_Ftab to mbEncToString successes : (%s)",
strCMPIStatus (rc));
type = CDGetType (_broker, cop, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type "
"CMPIObjectPath : (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
bol = CDIsOfType (_broker, cop, "CMPIObjectPath", &rc);
if ( bol )
{
PROV_LOG ("++++ CDIsOfType for CMPIObjectPath with "
"CMPI_ObjectPathOnStack_Ftab status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
type = CDGetType (_broker, rslt, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type "
"CMPIResult with CMPI_ResultRefOnStack_Ftab : (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
bol = CDIsOfType (_broker, rslt, "CMPIResult", &rc);
if ( bol )
{
PROV_LOG ("++++ CDIsOfType for CMPIResult with "
"CMPI_ResultRefOnStack_Ftab status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
_inst = CMClone(ci, &rc);
PROV_LOG("++++ Status of CMClone(ci) : (%s)",
strCMPIStatus(rc));
CMSetObjectPath (_inst, cop);
PROV_LOG("++++ Status of CMSetObjectPath(_inst) : (%s)",
strCMPIStatus(rc));
_setProperty1(_inst, "*");
retData = CMGetProperty(_inst, "n64", &rc);
PROV_LOG("++++ Status of CMGetProperty : (%s)",
strCMPIStatus(rc));
PROV_LOG("n64 = %" PEGASUS_64BIT_CONVERSION_WIDTH "u",
retData.value.uint64);
retData = CMGetProperty(_inst, "n32", &rc);
PROV_LOG("++++ Status of CMGetProperty : (%s)",
strCMPIStatus(rc));
PROV_LOG("n32 = %d", retData.value.uint32);
obj = CMGetObjectPath(_inst, &rc);
PROV_LOG("++++ Status of CMGetObjectPath : (%s)",
strCMPIStatus(rc));
retNamespace = CMGetNameSpace(obj, &rc);
PROV_LOG("++++ Status of CMGetNameSpace : (%s)",
strCMPIStatus(rc));
retClassname = CMGetClassName(obj, &rc);
PROV_LOG("++++ Status of CMGetClassName : (%s)",
strCMPIStatus(rc));
str1 = CMGetCharsPtr(retNamespace, &rc);
PROV_LOG("++++ Status of CMGetCharsPtr : (%s)",
strCMPIStatus(rc));
str2 = CMGetCharsPtr(retClassname, &rc);
PROV_LOG("++++ Status of CMGetCharsPtr : (%s)",
strCMPIStatus(rc));
PROV_LOG("++++Namespace (_inst): (%s) Class (*%s)", str1, str2);
retData = CMGetProperty(_inst, "n64", &rc);
PROV_LOG("++++ Status of CMGetProperty : (%s)",
strCMPIStatus(rc));
PROV_LOG("n64 = %" PEGASUS_64BIT_CONVERSION_WIDTH "u",
retData.value.uint64);
PROV_LOG_CLOSE ();
CMReturnObjectPath(rslt, cop);
CMReturnDone(rslt);
CMReturn (CMPI_RC_OK);
}
else
{
PROV_LOG_CLOSE ();
CMReturn (CMPI_RC_ERR_NOT_SUPPORTED);
}
}
CMPIStatus
TestMethodProviderInvokeMethod(CMPIMethodMI * mi,
const CMPIContext *ctx,
const CMPIResult *rslt,
const CMPIObjectPath * ref,
const char *methodName,
const CMPIArgs * in, CMPIArgs * out)
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIString *className;
CMPIData data;
char result[80] = "Hello,";
const char *strCat;
const char *name;
char *argName = "Message";
CMPIString *str1;
CMPIString *str2;
CMPIValue val1,
val2;
/*
* get the class name from object-path
*/
className = CMGetClassName(ref, &rc);
/*
* get a pointer to a C char* representation of this String.
*/
name = CMGetCharsPtr(className, &rc);
if (!strcmp(name, _ClassName)) {
if (!strcmp("SayHello", methodName)) {
/*
* gets the number of arguments contained in "in" Args.
*/
if (CMGetArgCount(in, &rc) > 0) {
/*
* gets a Name argument value
*/
data = CMGetArg(in, "Name", &rc);
/*
* check for data type and not null value of argument value
* recieved
*/
if (data.type == CMPI_string && !(CMIsNullValue(data))) {
strCat = CMGetCharsPtr(data.value.string, &rc);
strcat(result, strCat);
// strcat(result, "!");
/*
* create the new string to return to client
*/
str1 = CMNewString(_broker, result, &rc);
val1.string = str1;
}
} else {
str1 = CMNewString(_broker, result, &rc);
val1.string = str1;
}
/*
* create string to add to an array
*/
str2 = CMNewString(_broker, "Have a good day", &rc);
val2.string = str2;
/*
* Adds a value of str2 string to out array argument
*/
rc = CMAddArg(out, argName, &val2, CMPI_string);
/*
* For: 3048960 method array types not filled in Test provider.
*/
} else if (!strcmp("CheckArrayNoType", methodName)) {
data = CMGetArg(in, "IntArray", &rc);
CMPIType atype=data.value.array->ft->getSimpleType(data.value.array,&rc);
sprintf(result,"Datatype is %s",paramType(atype));
str1 = CMNewString(_broker, result, &rc);
val1.string = str1;
/*
* This method simulates various provider problems for testing.
*/
} else if (!strcmp("Misbehave", methodName)) {
data = CMGetArg(in, "Action", &rc);
const char *strval = NULL;
if (data.type == CMPI_string && !(CMIsNullValue(data))) {
strval = CMGetCharsPtr(data.value.string, &rc);
sprintf(result, "data type is %s, value = %s", paramType(data.type),
strval);
if (!strcmp(strval,"hang")) {
while(sleep(60)); /* to test req handler timeout, etc. */
}
else if (!strcmp(strval,"abort")) {
abort();
}
else if (!strcmp(strval,"fpe")) {
#pragma GCC diagnostic ignored "-Wdiv-by-zero"
fprintf(stderr,"ouch! %d\n",1/0);
#pragma GCC diagnostic warning "-Wdiv-by-zero"
}
else if (!strcmp(strval,"segfault")) {
void (*crashme)(void) = NULL;
crashme();
}
/*
* These tend to behave as if the condition were raised internally
*/
else if (!strcmp(strval,"sigabrt")) {
kill(getpid(), SIGABRT);
while(sleep(3)); /* slight pause to ensure we catch signal */
}
else if (!strcmp(strval,"sigfpe")) {
kill(getpid(), SIGFPE);
while(sleep(3));
}
else if (!strcmp(strval,"sigsegv")) {
kill(getpid(), SIGSEGV);
while(sleep(3));
}
else if (!strcmp(strval,"sigusr1")) {
kill(getpid(), SIGUSR1); /* as if we received a signal from stopBroker() */
while(sleep(3));
}
else if (!strcmp(strval,"sigkill")) {
kill(getpid(), SIGKILL); /* this is currently not handled by providerDrv*/
while(sleep(3));
} else {
sprintf(result, "Action not recognized: %s", strval);
fprintf(stderr,
"+++ cmpiTestMethodProvider: Action not recognized \"%s\"\n",
strval);
}
/*
* create the new string to return to client
*/
str1 = CMNewString(_broker, result, &rc);
val1.string = str1;
}
} else {
sprintf(result, "Unknown method name: %s", methodName);
fprintf(stderr,
"+++ cmpiTestMethodProvider: Unknown method name \"%s\"\n",
methodName);
str1 = CMNewString(_broker, result, &rc);
val1.string = str1;
}
}
CMReturnData(rslt, (CMPIValue *) & val1, CMPI_string);
CMReturnDone(rslt);
return rc;
}
/******************************************************************************
* Provider export function
* Execute an extrinsic method on the specified CIM instance.
*****************************************************************************/
static CMPIStatus xen_resource_invoke_method(
CMPIMethodMI * self, /* [in] Handle to this provider (i.e. 'self') */
const CMPIBroker *broker, /* [in] CMPI Factory services */
const CMPIContext * context, /* [in] Additional context info, if any */
const CMPIResult * results, /* [out] Results of this operation */
const CMPIObjectPath * reference, /* [in] Contains the CIM namespace, classname and desired object path */
const char * methodname, /* [in] Name of the method to apply against the reference object */
const CMPIArgs * argsin, /* [in] Method input arguments */
CMPIArgs * argsout) /* [in] Method output arguments */
{
CMPIStatus status = {CMPI_RC_OK, NULL}; /* Return status of CIM operations. */
char * nameSpace = CMGetCharPtr(CMGetNameSpace(reference, NULL)); /* Target namespace. */
unsigned long rc = 0;
CMPIData argdata;
xen_utils_session * session = NULL;
_SBLIM_ENTER("InvokeMethod");
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_INFO, ("--- self=\"%s\"", self->ft->miName));
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_INFO, ("--- methodname=\"%s\"", methodname));
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_INFO, ("--- namespace=\"%s\"", nameSpace));
struct xen_call_context *ctx = NULL;
if(!xen_utils_get_call_context(context, &ctx, &status)){
goto Exit;
}
if (!xen_utils_validate_session(&session, ctx)) {
CMSetStatusWithChars(broker, &status,
CMPI_RC_ERR_METHOD_NOT_AVAILABLE, "Unable to connect to Xen");
goto Exit;
}
int argcount = CMGetArgCount(argsin, NULL);
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_INFO, ("--- argsin=%d", argcount));
argdata = CMGetKey(reference, "Name", &status);
if((status.rc != CMPI_RC_OK) || CMIsNullValue(argdata)) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR,
("Couldnt find the Virtual System Migration Service to invoke method on"));
goto Exit;
}
/* Check that the method has the correct number of arguments. */
if(strcmp(methodname, "MigrateVirtualSystemToHost") == 0) {
rc = MigrateVirtualSystem(broker, context, argsin, argsout, session, true, false, &status);
//CMPIObjectPath* job_instance_op = NULL;
//CMAddArg(argsout, "Job", (CMPIValue *)&job_instance_op, CMPI_ref);
}
else if(strcmp(methodname, "MigrateVirtualSystemToSystem") == 0) {
rc = MigrateVirtualSystem(broker, context, argsin, argsout, session, false, false, &status);
//CMPIObjectPath* job_instance_op = NULL;
//CMAddArg(argsout, "Job", (CMPIValue *)&job_instance_op, CMPI_ref);
//CMPIObjectPath* newcomputersystem_instance_op = NULL;
//CMAddArg(argsout, "NewComputerSystem", (CMPIValue *)&newcomputersystem_instance_op, CMPI_ref);
}
else if(strcmp(methodname, "CheckVirtualSystemIsMigratableToHost") == 0) {
rc = MigrateVirtualSystem(broker, context, argsin, argsout, session, true, true, &status);
}
else if(strcmp(methodname, "CheckVirtualSystemIsMigratableToSystem") == 0) {
rc = MigrateVirtualSystem(broker, context, argsin, argsout, session, false, true, &status);
}
else
status.rc = CMPI_RC_ERR_METHOD_NOT_FOUND;
Exit:
if(session)
xen_utils_cleanup_session(session);
if(ctx)
xen_utils_free_call_context(ctx);
CMReturnData(results, (CMPIValue *)&rc, CMPI_uint32);
CMReturnDone(results);
_SBLIM_RETURNSTATUS(status);
}
CMPIStatus TestMethodProviderInvokeMethod (
CMPIMethodMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * ref,
const char *methodName,
const CMPIArgs * in,
CMPIArgs * out)
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIString *className;
CMPIData data;
char result[80] = "Hello,";
const char *strCat;
const char * name;
char *argName = "Message";
CMPIString * str1;
CMPIString * str2;
CMPIValue val1, val2;
/* get the class name from object-path */
className = CMGetClassName(ref, &rc);
/* get a pointer to a C char* representation of this String. */
name = CMGetCharsPtr(className, &rc);
if(!strcmp(name, _ClassName))
{
if(!strcmp ("SayHello", methodName))
{
/* gets the number of arguments contained in "in" Args. */
if(CMGetArgCount(in, &rc) > 0)
{
/* gets a Name argument value */
data = CMGetArg(in, "Name", &rc);
/*check for data type and not null value of argument value
recieved */
if(data.type == CMPI_string && !(CMIsNullValue(data)))
{
strCat = CMGetCharsPtr(data.value.string, &rc);
strcat(result, strCat);
// strcat(result, "!");
/* create the new string to return to client */
str1 = CMNewString(_broker, result, &rc);
val1.string = str1;
}
}
else
{
str1 = CMNewString(_broker, result, &rc);
val1.string = str1;
}
/* create string to add to an array */
str2 = CMNewString(_broker,"Have a good day", &rc);
val2.string = str2;
/* Adds a value of str2 string to out array argument */
rc = CMAddArg(out, argName, &val2, CMPI_string);
} else if (!strcmp("CheckArrayNoType", methodName)) {
data = CMGetArg(in, "IntArray", &rc);
CMPIType atype=data.value.array->ft->getSimpleType(data.value.array,&rc);
sprintf(result,"Datatype is %s",paramType(atype));
str1 = CMNewString(_broker, result, &rc);
val1.string = str1;
}
}
CMReturnData (rslt, (CMPIValue *) &val1, CMPI_string);
CMReturnDone (rslt);
return rc;
}
CMPIStatus TestInstanceProviderExecQuery (
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * referencePath,
const char *query,
const char *lang)
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIStatus rc_Eval = { CMPI_RC_OK, NULL };
CMPIStatus rc_Clone = { CMPI_RC_OK, NULL };
CMPIStatus rc_Array = { CMPI_RC_OK, NULL };
CMPISelectExp *se_def = NULL;
CMPICount cnt = 0;
CMPIArray *projection = NULL;
unsigned int j = 0;
CMPIBoolean evalRes;
CMPIData arr_data;
CMPIInstance *instance1;
CMPIObjectPath *cop1;
CMPIData data;
CMPIValue value1;
const char* prop_name;
CMPIData retProp;
/*create the select expression */
se_def = CMNewSelectExp (_broker, query, lang, &projection, &rc_Clone);
if (se_def)
{
/*loop over instances in array to evaluate for requested properties */
for (j = 0; j < numOfInst ; j++)
{
/*check for validity of Instance,that its not deleted */
if(valid[j] == 1)
{
/*get the element from array */
arr_data = CMGetArrayElementAt(
clone_arr_ptr,
j,
&rc);
/*Evaluate the instance using this select expression */
evalRes = CMEvaluateSelExp(se_def,arr_data.value.inst, &rc_Eval);
if (evalRes)
{
/*check if any of properties are requested */
if (projection)
{
/*get number of properties requested */
cnt = CMGetArrayCount (projection, &rc_Array);
/*if count is not equal to number of properties of
instance */
if(cnt == 1)
{
/*check for the properties, requested */
data = CMGetArrayElementAt(
projection,
0,
&rc_Array);
prop_name = CMGetCharsPtr (
data.value.string,
&rc);
/*create the new instance that has to be returned */
cop1 = CMNewObjectPath(
_broker,
"root/cimv2",
_ClassName,
&rc);
instance1 = CMNewInstance(_broker,
cop1,
&rc);
/*if property name is "Identifier",
gets its value from instance */
if(!strcmp(prop_name, "Identifier"))
{
retProp = CMGetProperty(
arr_data.value.inst,
"Identifier",
&rc);
value1.uint8 = retProp.value.uint8;
CMSetProperty(
instance1,
"Identifier",
(CMPIValue *)&value1,
CMPI_uint8);
}
/*if property name is "Message",
gets its value from instance */
if(!strcmp(prop_name, "Message"))
{
retProp = CMGetProperty(
arr_data.value.inst,
"Message",
&rc);
value1.string = retProp.value.string;
CMSetProperty(
instance1,
"Message",
(CMPIValue *)&value1,
CMPI_string);
}
/*if the query is evaluated return instance */
CMReturnInstance (rslt, instance1);
}
}
else
{
CMReturnInstance(rslt, arr_data.value.inst);
}
}
}
}
}
CMReturnDone (rslt);
CMReturn (CMPI_RC_OK);
}
