PredicateConjunction *orGetPredicateConjunction(QLOperation *op)
{
int rdn=0,i,m,ii,mi;
PredicateConjunction *lc=op->lhon->ft->getPredicateConjunction(op->lhon);
if (!op->rhon) return lc;
PredicateConjunction *rc=op->rhon->ft->getPredicateConjunction(op->rhon);
PredicateConjunction *rd=TrackedCMPIArray(
CMGetArrayCount(lc,NULL)*CMGetArrayCount(rc,NULL), CMPI_ptr, NULL);
for (i=0, m=CMGetArrayCount(lc,NULL); i<m; i++) {
PredicateConjunction *lci=CMGetArrayElementAt(lc,i,NULL).value.dataPtr.ptr;
for (ii=0, mi=CMGetArrayCount(rc,NULL); ii<mi; ii++) {
PredicateConjunction *rcii=CMGetArrayElementAt(rc,ii,NULL).value.dataPtr.ptr;
Predicates *tc=TrackedCMPIArray(0, CMPI_ptr, NULL);
CMPIValuePtr rdv={tc,1};
appendArray(tc,lci);
appendArray(tc,rcii);
CMSetArrayElementAt(rd,rdn,&rdv,CMPI_ptr);
rdn++;
}
}
return rd;
}
static CMPIArray *appendArray(CMPIArray *t, CMPIArray *f)
{
int tn=CMGetArrayCount(t,NULL),fm=CMGetArrayCount(f,NULL),fn;
for (fn=0; fn<fm; tn++,fn++) {
CMPIData d=CMGetArrayElementAt(f,fn,NULL);
sfcb_native_array_increase_size(t,1);
CMSetArrayElementAt(t,tn,&d.value,d.type);
}
return t;
}
void print(const CMPIData& data)
{
if (data.state & CMPI_nullValue)
{
printf("null");
return;
}
if (CMIsArray(data))
{
printf("{");
CMPICount n = CMGetArrayCount(data.value.array, NULL);
for (CMPICount i = 0; i < n; i++)
{
CMPIData td = CMGetArrayElementAt(data.value.array, i, NULL);
print_scalar(td);
if (i + 1 != n)
printf(",");
}
printf("}");
}
else
print_scalar(data);
}
// transforms numerical values into their string counterpart
// utilizing the Values and ValueMap qualifiers
char *
transformValue(char *cssf, CMPIObjectPath * op, char *propertyName)
// cssf = cimSLPService Field in the struct
{
CMPIData qd;
CMPIStatus status;
char *valuestr;
_SFCB_ENTER(TRACE_SLP, "transformValue");
qd = CMGetPropertyQualifier(op, propertyName, "ValueMap", &status);
if (status.rc) {
printf("getPropertyQualifier failed ... Status: %d\n", status.rc);
_SFCB_RETURN(NULL);
}
if (CMIsArray(qd)) {
CMPIArray *arr = qd.value.array;
CMPIType eletyp = qd.type & ~CMPI_ARRAY;
int j = 0;
int n;
n = CMGetArrayCount(arr, NULL);
CMPIData ele;
ele = CMGetArrayElementAt(arr, j, NULL);
valuestr = value2Chars(eletyp, &ele.value);
j++;
while (strcmp(valuestr, cssf)) {
free(valuestr);
ele = CMGetArrayElementAt(arr, j, NULL);
valuestr = value2Chars(eletyp, &ele.value);
if (j == n) {
free(valuestr);
_SFCB_RETURN(cssf); // nothing found, probably "NULL" ->
// return it
}
j++;
}
free(valuestr);
free(cssf);
if (j - 1 <= n) {
qd = CMGetPropertyQualifier(op, propertyName, "Values",
&status);
arr = qd.value.array;
eletyp = qd.type & ~CMPI_ARRAY;
ele = CMGetArrayElementAt(arr, j - 1, NULL);
cssf = value2Chars(eletyp, &ele.value);
_SFCB_RETURN(cssf);
} else {
// printf("No Valuemap Entry for %s in %s. Exiting ...\n", cssf,
// propertyName);
_SFCB_RETURN(NULL);
}
}
else {
// printf("No qualifier found for %s. Exiting ...\n", propertyName);
_SFCB_RETURN(NULL);
}
}
static int
_testCMPIEnumeration(const CMPIContext *ctx)
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIEnumeration *enum_ptr = NULL;
CMPIData data;
unsigned int initCount = 0;
CMPIObjectPath *objPath = NULL;
CMPIArray *arr_ptr = NULL;
CMPICount returnedArraySize;
void *eptr;
objPath = make_ObjectPath(_broker, _Namespace, _PersonClass);
enum_ptr = CBEnumInstances(_broker, ctx, objPath, NULL, &rc);
if (enum_ptr == NULL) {
return 1;
}
arr_ptr = CMToArray(enum_ptr, &rc);
if (arr_ptr == NULL) {
return 1;
}
returnedArraySize = CMGetArrayCount(arr_ptr, &rc);
while (CMHasNext(enum_ptr, &rc)) {
data = CMGetNext(enum_ptr, &rc);
if (data.type != CMPI_instance) {
return 1;
}
initCount++;
}
eptr = enum_ptr->hdl;
enum_ptr->hdl = NULL;
CMToArray(enum_ptr, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
CMGetNext(enum_ptr, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
CMHasNext(enum_ptr, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
enum_ptr->hdl = eptr;
rc = CMRelease(enum_ptr);
if (rc.rc != CMPI_RC_OK) {
return 1;
}
return 0;
}
static CMPICount __eft_getCount(const CMPISubCond* cond, CMPIStatus* rc)
{
NativeSubCond *c = (NativeSubCond *) cond;
CMPIArray *conds=(CMPIArray*)c->cond.ptr;
CMPICount count=0;
if (conds) count=CMGetArrayCount(conds,NULL);
if (rc) CMSetStatus(rc, CMPI_RC_OK);
return count;
}
static CMPIBoolean __eft_hasNext (
CONST CMPIEnumeration * enumeration,
CMPIStatus * rc )
{
struct native_enum * e = (struct native_enum *) enumeration;
if (!checkArgs(enumeration, rc))
{
return 0;
}
return( e->current < CMGetArrayCount ( e->data, rc ) );
}
static CMPIPredicate* __eft_getPredicateAt
(const CMPISubCond* cond, unsigned int index, CMPIStatus* rc)
{
NativeSubCond *c = (NativeSubCond *)cond;
CMPIValuePtr pvp={NULL,0};
CMPIPredicate *pr=NULL;
CMPICount count=0;
CMPIStatus irc={CMPI_RC_ERR_NOT_FOUND,NULL};
CMPIArray *conds=(CMPIArray*)c->cond.ptr;
if (conds) {
count=CMGetArrayCount(conds,NULL);
if (index<count) pvp=CMGetArrayElementAt(conds,index,&irc).value.dataPtr;
}
else {
mlogf(M_ERROR,M_SHOW,"### getPredicateAt, no conds\n");
}
if (rc) *rc=irc;
if (pvp.ptr) pr=TrackedCMPIPredicate(pvp,&irc);
return pr;
}
static CMPIStatus _set_value(KValue* kv, KTag tag, const CMPIData* cd)
{
/* Strip unused flags */
tag = KTypeOf(tag) | (tag & KTAG_ARRAY);
if (_cmpitype_to_ktag(cd->type) != tag)
{
KReturn(ERR_FAILED);
}
kv->exists = 1;
if (cd->state & CMPI_nullValue)
{
kv->null = 1;
kv->u.uint64 = 0;
KReturn(OK);
}
else
{
kv->u.uint64 = cd->value.uint64;
if (tag == KTYPE_STRING)
{
KString* ks = (KString*)kv;
ks->chars = KChars(ks->value);
}
if (tag & KTAG_ARRAY)
{
KArray* ks = (KArray*)kv;
ks->count = CMGetArrayCount(ks->value, NULL);
}
/* ATTN: validate references and instances */
KReturn(OK);
}
}
/*!
Since results from remote providers cannot be sent as CMPIResult directly,
they are serialized using arrays, which can be transferred to the result
using this method.
\param array the source array.
\param result the destination result.
*/
void socketcomm_array2result ( CMPIArray * array, CONST CMPIResult * result )
{
TRACE_VERBOSE(("entered function."));
if ( array != NULL && result != NULL ) {
CMPICount size = CMGetArrayCount ( array, NULL );
CMPICount i;
TRACE_NORMAL(("Transferring %d array elements to CMPIResult.",
size));
for ( i = 0; i < size; i++ ) {
CMPIData data = CMGetArrayElementAt ( array, i, NULL );
if ( data.type == CMPI_instance ) {
TRACE_INFO(("transferring instance."));
CMReturnInstance ( result, data.value.inst );
} else if ( data.type == CMPI_ref ) {
TRACE_INFO(("transferring object path."));
CMReturnObjectPath ( result, data.value.ref );
} else {
TRACE_INFO(("transferring CMPIData."));
CMReturnData ( result,
&data.value,
data.type );
}
}
}
TRACE_VERBOSE(("leaving function."));
}
CMPIStatus
InternalProviderEnumInstanceNames(CMPIInstanceMI * mi,
const CMPIContext *ctx,
const CMPIResult *rslt,
const CMPIObjectPath * ref)
{
CMPIStatus st = { CMPI_RC_OK, NULL };
CMPIStatus sti = { CMPI_RC_OK, NULL };
BlobIndex *bi;
CMPIString *cn = CMGetClassName(ref, NULL);
CMPIString *ns = CMGetNameSpace(ref, NULL);
CMPIObjectPath *cop;
const char *nss = ns->ft->getCharPtr(ns, NULL);
const char *cns = cn->ft->getCharPtr(cn, NULL);
const char *bnss = repositoryNs(nss);
size_t ekl;
int i,
ac = 0;
char copKey[8192] = "";
char *kp;
CMPIArgs *in,
*out;
CMPIObjectPath *op;
CMPIArray *ar;
CMPIData rv;
_SFCB_ENTER(TRACE_INTERNALPROVIDER, "InternalProviderEnumInstanceNames");
_SFCB_TRACE(1, ("%s %s", nss, cns));
in = CMNewArgs(Broker, NULL);
out = CMNewArgs(Broker, NULL);
CMAddArg(in, "class", cns, CMPI_chars);
op = CMNewObjectPath(Broker, bnss, "$ClassProvider$", &sti);
rv = CBInvokeMethod(Broker, ctx, op, "getallchildren", in, out, &sti);
ar = CMGetArg(out, "children", NULL).value.array;
if (ar)
ac = CMGetArrayCount(ar, NULL);
for (i = 0; cns; i++) {
if ((bi = _getIndex(bnss, cns)) != NULL) {
if (ipGetFirst(bi, NULL, &kp, &ekl)) {
while (1) {
strcpy(copKey, nss);
strcat(copKey, ":");
strcat(copKey, cns);
strcat(copKey, ".");
strncat(copKey, kp, ekl);
cop = getObjectPath(copKey, NULL);
if (cop)
CMReturnObjectPath(rslt, cop);
else {
CMPIStatus st = { CMPI_RC_ERR_FAILED, NULL };
return st;
}
if (bi->next < bi->dSize && ipGetNext(bi, NULL, &kp, &ekl)) {
continue;
}
break;
}
}
freeBlobIndex(&bi, 1);
}
if (i < ac)
cns = (char *) CMGetArrayElementAt(ar, i, NULL).value.string->hdl;
else
cns = NULL;
}
_SFCB_RETURN(st);
}
void
data2xml(CMPIData *data, void *obj, CMPIString *name,
CMPIString *refName, char *bTag, int bTagLen, char *eTag,
int eTagLen, UtilStringBuffer * sb, UtilStringBuffer * qsb,
int inst, int param)
{
_SFCB_ENTER(TRACE_CIMXMLPROC, "data2xml");
char *type;
if (data->type & CMPI_ARRAY) {
CMPIArray *ar = data->value.array;
CMPIData d;
int j,
ac = ar ? CMGetArrayCount(ar, NULL) : 0;
sb->ft->appendBlock(sb, bTag, bTagLen);
sb->ft->appendChars(sb, (char *) name->hdl);
if (param)
SFCB_APPENDCHARS_BLOCK(sb, "\" PARAMTYPE=\"");
else if (bTag)
SFCB_APPENDCHARS_BLOCK(sb, "\" TYPE=\"");
if (data->type == CMPI_refA) {
SFCB_APPENDCHARS_BLOCK(sb, "reference");
} else if (((data->type & ~CMPI_ARRAY) == CMPI_instance)
|| ((data->type & ~CMPI_ARRAY) == CMPI_class)) {
SFCB_APPENDCHARS_BLOCK(sb, "string\" EmbeddedObject=\"object");
} else {
sb->ft->appendChars(sb, dataType(data->type));
}
SFCB_APPENDCHARS_BLOCK(sb, "\">\n");
if (qsb)
sb->ft->appendChars(sb, (char *) qsb->hdl);
if (data->state == 0) {
if (data->type == CMPI_refA) {
SFCB_APPENDCHARS_BLOCK(sb, "<VALUE.REFARRAY>\n");
} else {
SFCB_APPENDCHARS_BLOCK(sb, "<VALUE.ARRAY>\n");
}
for (j = 0; j < ac; j++) {
d = CMGetArrayElementAt(ar, j, NULL);
if ((d.state & CMPI_nullValue) == 0) {
if (d.type == CMPI_ref) {
refValue2xml(d.value.ref, sb);
} else {
value2xml(d, sb, 1);
}
}
}
if (data->type == CMPI_refA) {
SFCB_APPENDCHARS_BLOCK(sb, "</VALUE.REFARRAY>\n");
} else {
SFCB_APPENDCHARS_BLOCK(sb, "</VALUE.ARRAY>\n");
}
}
}
else {
type = dataType(data->type);
if (*type == '*') {
sb->ft->appendBlock(sb, bTag, bTagLen);
sb->ft->appendChars(sb, (char *) name->hdl);
if (param) {
SFCB_APPENDCHARS_BLOCK(sb, "\" PARAMTYPE=\"reference");
} else if (refName) {
SFCB_APPENDCHARS_BLOCK(sb, "\" REFERENCECLASS=\"");
sb->ft->appendChars(sb, (char *) refName->hdl);
}
SFCB_APPENDCHARS_BLOCK(sb, "\">\n");
if (qsb)
sb->ft->appendChars(sb, (char *) qsb->hdl);
if (inst && data->value.ref) {
refValue2xml(data->value.ref, sb);
}
}
else if (*type == '%') {
sb->ft->appendBlock(sb, bTag, bTagLen);
sb->ft->appendChars(sb, (char *) name->hdl);
SFCB_APPENDCHARS_BLOCK(sb, "\" EmbeddedObject=\"object");
if (param)
SFCB_APPENDCHARS_BLOCK(sb, "\" PARAMTYPE=\"string\">\n");
else
SFCB_APPENDCHARS_BLOCK(sb, "\" TYPE=\"string\">\n");
if (data->value.inst) {
SFCB_APPENDCHARS_BLOCK(sb, "<VALUE>");
SFCB_APPENDCHARS_BLOCK(sb, "<![CDATA[");
instance2xml(data->value.inst, sb, 0);
SFCB_APPENDCHARS_BLOCK(sb, "]]>");
SFCB_APPENDCHARS_BLOCK(sb, "</VALUE>\n");
}
}
else {
sb->ft->appendBlock(sb, bTag, bTagLen);
sb->ft->appendChars(sb, (char *) name->hdl);
if (param)
SFCB_APPENDCHARS_BLOCK(sb, "\" PARAMTYPE=\"");
else if (bTag)
SFCB_APPENDCHARS_BLOCK(sb, "\" TYPE=\"");
sb->ft->appendChars(sb, type);
SFCB_APPENDCHARS_BLOCK(sb, "\">\n");
if (qsb)
sb->ft->appendChars(sb, (char *) qsb->hdl);
if (data->state == 0)
value2xml(*data, sb, 1);
}
}
sb->ft->appendBlock(sb, eTag, eTagLen);
}
CMPIStatus
TestCMPIErrorProviderInvokeMethod (CMPIMethodMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * ref,
const char *methodName,
const CMPIArgs * in, CMPIArgs * out)
{
CMPIString *class_name = NULL;
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIError *cmpiError;
CMPIError *cmpiErrorClone;
CMPICount i, arrSize;
CMPIObjectPath *objPath = NULL;
CMPIUint32 brokerCapabilities;
/* CMPIError data */
const char* inOwningEntity = "ACME";
CMPIString* outOwningEntity;
const char* inMsgID = "ACME0023";
CMPIString* outMsgID;
const char* inMsg = "ACME0023 Need to restock Road Runner bait and traps.";
CMPIString* outMsg;
const CMPIErrorSeverity inSev = ErrorSevMedium;
CMPIErrorSeverity outSev;
const CMPIErrorProbableCause inPc = Equipment_Malfunction;
CMPIErrorProbableCause outPc;
const CMPIrc inCIMStatusCode = CMPI_RC_ERR_FAILED;
CMPIrc outCIMStatusCode;
const char * inCIMStatusCodeDesc = "another failed attempt at road "
"runner elimination";
CMPIString* outCIMStatusCodeDesc;
const CMPIErrorType inErrType = OtherErrorType;
CMPIErrorType outErrType;
const char* inOtherErrType = "Pervasive Coyote Incompetance";
CMPIString* outOtherErrType;
const char* inPcd = "Incorrect use of equipment";
CMPIString* outPcd;
CMPIArray *inRecActions;
CMPIArray *outRecActions;
CMPIArray *inMsgArgs;
CMPIArray *outMsgArgs;
CMPIValue raOne;
CMPIValue raTwo;
const char* inErrSource = "Acme bomb";
CMPIString* outErrSource;
const CMPIErrorSrcFormat inErrSourceFormat = CMPIErrSrcOther;
CMPIErrorSrcFormat outErrSourceFormat;
const char* inOtherErrSourceFormat = "no idea";
CMPIString* outOtherErrSourceFormat;
CMPIData retData;
PROV_LOG_OPEN (_ClassName, _ProviderLocation);
PROV_LOG ("Calling CBGetBrokerCapabilities");
brokerCapabilities = CBGetBrokerCapabilities(_broker);
if (brokerCapabilities & CMPI_MB_Supports_Extended_Error)
{
PROV_LOG("CMPI_MB_Supports_Extended_Error Support : True");
}
else
{
PROV_LOG("CMPI_MB_Supports_Extended_Error Support : False");
CMReturnWithString(CMPI_RC_ERR_NOT_SUPPORTED,
CMNewString(_broker,
"Extended error support not avilable", NULL));
}
PROV_LOG ("--- %s CMPI InvokeMethod() called", _ClassName);
class_name = CMGetClassName (ref, &rc);
PROV_LOG ("InvokeMethod: checking for correct classname [%s]",
CMGetCharsPtr (class_name,NULL));
PROV_LOG ("Calling CMNewCMPIError");
cmpiError = CMNewCMPIError(_broker, inOwningEntity, inMsgID, inMsg,
inSev, inPc, inCIMStatusCode, &rc);
PROV_LOG ("++++ (%s) CMNewCMPIError", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetErrorType");
rc = CMSetErrorType(cmpiError, inErrType);
PROV_LOG ("++++ (%s) CMSetErrorType", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetOtherErrorType");
rc = CMSetOtherErrorType(cmpiError, inOtherErrType);
PROV_LOG ("++++ (%s) CMSetOtherErrorType", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetProbableCauseDescription");
rc = CMSetProbableCauseDescription(cmpiError, inPcd);
PROV_LOG ("++++ (%s) CMSetProbableCauseDescription", strCMPIStatus (rc));
inRecActions = CMNewArray(_broker, 2, CMPI_string, &rc);
PROV_LOG ("++++ (%s) CMNewArray", strCMPIStatus (rc));
raOne.string = CMNewString(_broker, "Fire coyote.", &rc);
PROV_LOG ("++++ (%s) CMNewString", strCMPIStatus (rc));
rc = CMSetArrayElementAt(inRecActions, 0, &raOne, CMPI_string);
PROV_LOG ("++++ (%s) CMSetArrayElementAt [0]", strCMPIStatus (rc));
raTwo.string = CMNewString(_broker, "Give peace a chance.", &rc);
PROV_LOG ("++++ (%s) CMNewString", strCMPIStatus (rc));
rc = CMSetArrayElementAt(inRecActions, 1, &raTwo, CMPI_string);
PROV_LOG ("++++ (%s) CMSetArrayElementAt [1]", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetRecommendedActions");
rc = CMSetRecommendedActions(cmpiError, inRecActions);
PROV_LOG ("++++ (%s) CMSetRecommendedActions", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetErrorSource");
rc = CMSetErrorSource(cmpiError, inErrSource);
PROV_LOG ("++++ (%s) CMSetErrorSource", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetErrorSourceFormat");
rc = CMSetErrorSourceFormat(cmpiError, inErrSourceFormat);
PROV_LOG ("++++ (%s) CMSetErrorSourceFormat", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetOtherErrorSourceFormat");
rc = CMSetOtherErrorSourceFormat(cmpiError, inOtherErrSourceFormat);
PROV_LOG ("++++ (%s) CMSetOtherErrorSourceFormat", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetCIMStatusCodeDescription");
rc = CMSetCIMStatusCodeDescription(cmpiError, inCIMStatusCodeDesc);
PROV_LOG ("++++ (%s) CMSetCIMStatusCodeDescription", strCMPIStatus (rc));
inMsgArgs = CMNewArray(_broker, 1, CMPI_string, &rc);
PROV_LOG ("++++ (%s) CMNewArray", strCMPIStatus (rc));
raOne.string = CMNewString(_broker, "no real inserts", &rc);
PROV_LOG ("++++ (%s) CMNewString", strCMPIStatus (rc));
rc = CMSetArrayElementAt(inMsgArgs, 0, &raOne, CMPI_string);
PROV_LOG ("++++ (%s) CMSetArrayElementAt [0]", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetMessageArguments");
rc = CMSetMessageArguments(cmpiError, inMsgArgs);
PROV_LOG ("++++ (%s) CMSetMessageArguments", strCMPIStatus (rc));
PROV_LOG ("First clone the CMPIError.");
cmpiErrorClone = CMClone(cmpiError, &rc);
PROV_LOG ("++++ (%s) CMClone", strCMPIStatus (rc));
PROV_LOG ("Ok, reading back fields to verify");
PROV_LOG ("Calling CMGetErrorType");
outErrType = CMGetErrorType(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetErrorType (%d)", strCMPIStatus (rc), outErrType);
PROV_LOG ("Calling CMGetOtherErrorType");
outOtherErrType = CMGetOtherErrorType(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetOtherErrorType (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outOtherErrType,NULL));
PROV_LOG ("Calling CMGetOwningEntity");
outOwningEntity = CMGetOwningEntity(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetOwningEntity (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outOwningEntity,NULL));
PROV_LOG ("Calling CMGetMessageID");
outMsgID = CMGetMessageID(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetMessageID (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outMsgID,NULL));
PROV_LOG ("Calling CMGetErrorMessage");
outMsg = CMGetErrorMessage(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetErrorMessage (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outMsg,NULL));
PROV_LOG ("Calling CMGetPerceivedSeverity");
outSev = CMGetPerceivedSeverity(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetPerceivedSeverity (%d)", strCMPIStatus (rc),
outSev);
PROV_LOG ("Calling CMGetProbableCause");
outPc = CMGetProbableCause(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetProbableCause (%d)", strCMPIStatus (rc),
outPc);
PROV_LOG ("Calling CMGetProbableCauseDescription");
outPcd = CMGetProbableCauseDescription(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetProbableCauseDescription (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(outPcd,NULL));
PROV_LOG ("Calling CMGetRecommendedActions");
outRecActions = CMGetRecommendedActions(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetRecommendedActions", strCMPIStatus (rc));
arrSize = CMGetArrayCount(outRecActions, &rc);
PROV_LOG ("++++ (%s) CMGetArrayCount (%d)", strCMPIStatus (rc), arrSize);
for (i = 0 ; i < arrSize ; i++)
{
CMPIData dta = CMGetArrayElementAt(outRecActions, i, &rc);
PROV_LOG ("++++ (%s) CMGetArrayElementAt (%d:%s)", strCMPIStatus (rc),
i, CMGetCharsPtr(dta.value.string,NULL));
}
PROV_LOG ("Calling CMGetErrorSource");
outErrSource = CMGetErrorSource(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetErrorSource (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outErrSource,NULL));
PROV_LOG ("Calling CMGetErrorSourceFormat");
outErrSourceFormat = CMGetErrorSourceFormat(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetErrorSourceFormat (%d)", strCMPIStatus (rc),
outErrSourceFormat);
PROV_LOG ("Calling CMGetOtherErrorSourceFormat");
outOtherErrSourceFormat = CMGetOtherErrorSourceFormat(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetOtherErrorSourceFormat (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outOtherErrSourceFormat,NULL));
PROV_LOG ("Calling CMGetCIMStatusCode");
outCIMStatusCode = CMGetCIMStatusCode(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetCIMStatusCode (%d)", strCMPIStatus (rc),
outCIMStatusCode);
PROV_LOG ("Calling CMGetCIMStatusCodeDescription");
outCIMStatusCodeDesc = CMGetCIMStatusCodeDescription(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetCIMStatusCodeDescription (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outCIMStatusCodeDesc,NULL));
PROV_LOG ("Calling CMGetMessageArguments");
outMsgArgs = CMGetMessageArguments(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetMessageArguments", strCMPIStatus (rc));
arrSize = CMGetArrayCount(outMsgArgs, &rc);
PROV_LOG ("++++ (%s) CMGetArrayCount (%d)", strCMPIStatus (rc), arrSize);
for (i = 0 ; i < arrSize ; i++)
{
CMPIData dta = CMGetArrayElementAt(outMsgArgs, i, &rc);
PROV_LOG ("++++ (%s) CMGetArrayElementAt (%d:%s)", strCMPIStatus (rc),
i, CMGetCharsPtr(dta.value.string,NULL));
}
PROV_LOG ("Calling CMPIResultFT.returnData");
rc = (rslt)->ft->returnError (rslt, cmpiErrorClone);
PROV_LOG ("++++ (%s) returnData", strCMPIStatus (rc));
PROV_LOG ("Releasing cloned CMPIError");
rc = CMRelease(cmpiErrorClone);
PROV_LOG ("++++ (%s) CMClone", strCMPIStatus (rc));
//Test Error Paths
PROV_LOG ("Testing for Error Paths in CMPI_Error.cpp");
PROV_LOG ("Calling CMNewCMPIError");
cmpiError = CMNewCMPIError(_broker,
inOwningEntity,
inMsgID,
inMsg,
inSev,
inPc,
inCIMStatusCode,
&rc);
PROV_LOG ("++++ (%s) CMNewCMPIError", strCMPIStatus (rc));
PROV_LOG ("Calling CMGetErrorType without setting the ErrorType");
outErrType = CMGetErrorType(cmpiError, &rc);
if (!outErrType)
{
PROV_LOG ("++++ (%s) CMGetErrorType (%d)", strCMPIStatus (rc),
outErrType);
}
PROV_LOG ("Calling CMGetOtherErrorType without setting the OtherErrorType");
outOtherErrType = CMGetOtherErrorType(cmpiError, &rc);
if (outOtherErrType == NULL)
{
PROV_LOG ("++++ (%s) CMGetOtherErrorType", strCMPIStatus (rc));
}
PROV_LOG ("Testing CMSetMessageArguments");
CMRelease(inMsgArgs);
inMsgArgs = CMNewArray(_broker, 1, CMPI_uint32, &rc);
PROV_LOG ("++++ (%s) CMNewArray inMsgArgs of CMPI_uint32 type",
strCMPIStatus (rc));
raOne.uint32 = 32;
rc = CMSetArrayElementAt(inMsgArgs, 0, &raOne, CMPI_uint32);
PROV_LOG ("++++ (%s) CMSetArrayElementAt [0]", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetMessageArguments with input array of uint32");
rc = CMSetMessageArguments(cmpiError, inMsgArgs);
PROV_LOG ("++++ (%s) CMSetMessageArguments", strCMPIStatus (rc));
inMsgArgs->hdl = NULL;
PROV_LOG ("Calling CMSetMessageArguments with input array with NULL handle");
rc = CMSetMessageArguments(cmpiError, inMsgArgs);
PROV_LOG ("++++ (%s) CMSetMessageArguments", strCMPIStatus (rc));
PROV_LOG ("Testing CMSetRecommendedActions");
CMRelease(inRecActions);
inRecActions = CMNewArray(_broker, 1, CMPI_uint32, &rc);
PROV_LOG ("++++ (%s) CMNewArray inRecActions of CMPI_uint32",
strCMPIStatus (rc));
raOne.uint32 = 32;
rc = CMSetArrayElementAt(inRecActions, 0, &raOne, CMPI_uint32);
PROV_LOG ("++++ (%s) CMSetArrayElementAt [0]", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetRecommendedActions with input array of CMPI_uint32");
rc = CMSetRecommendedActions(cmpiError, inRecActions);
PROV_LOG ("++++ (%s) CMSetRecommendedActions", strCMPIStatus (rc));
inRecActions->hdl = NULL;
PROV_LOG ("Calling CMSetRecommendedActions with input array"
" with NULL handle");
rc = CMSetRecommendedActions(cmpiError, inRecActions);
PROV_LOG ("++++ (%s) CMSetRecommendedActions", strCMPIStatus (rc));
/* Cases when CMPIError object handle is NULL*/
cmpiError->hdl = NULL;
PROV_LOG ("Clone the CMPIError with NULL handle.");
cmpiErrorClone = CMClone(cmpiError, &rc);
if (cmpiErrorClone == NULL)
{
PROV_LOG ("++++ (%s) CMClone", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetErrorType with NULL handle");
outErrType = CMGetErrorType(cmpiError, &rc);
if (!outErrType)
{
PROV_LOG ("++++ (%s) CMGetErrorType (%d)", strCMPIStatus (rc),
outErrType);
}
PROV_LOG ("Calling CMGetOtherErrorType with NULL handle");
outOtherErrType = CMGetOtherErrorType(cmpiError, &rc);
if (outOtherErrType == NULL)
{
PROV_LOG ("++++ (%s) CMGetOtherErrorType ", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetOwningEntity with NULL handle");
outOwningEntity = CMGetOwningEntity(cmpiError, &rc);
if (outOwningEntity == NULL)
{
PROV_LOG ("++++ (%s) CMGetOwningEntity ", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetMessageID with NULL handle");
outMsgID = CMGetMessageID(cmpiError, &rc);
if (!outMsgID)
{
PROV_LOG ("++++ (%s) CMGetMessageID", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetErrorMessage with NULL handle");
outMsg = CMGetErrorMessage(cmpiError, &rc);
if (!outMsg)
{
PROV_LOG ("++++ (%s) CMGetErrorMessage", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetPerceivedSeverity with NULL handle");
outSev = CMGetPerceivedSeverity(cmpiError, &rc);
if (!outSev)
{
PROV_LOG ("++++ (%s) CMGetPerceivedSeverity (%d)", strCMPIStatus (rc),
outSev);
}
PROV_LOG ("Calling CMGetProbableCause with NULL handle");
outPc = CMGetProbableCause(cmpiError, &rc);
if (!outPc)
{
PROV_LOG ("++++ (%s) CMGetProbableCause (%d)", strCMPIStatus (rc),
outPc);
}
PROV_LOG ("Calling CMGetProbableCauseDescription with NULL handle");
outPcd = CMGetProbableCauseDescription(cmpiError, &rc);
if (!outPcd)
{
PROV_LOG ("++++ (%s) CMGetProbableCauseDescription ",
strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetRecommendedActions with NULL handle");
outRecActions = CMGetRecommendedActions(cmpiError, &rc);
if (!outRecActions)
{
PROV_LOG ("++++ (%s) CMGetRecommendedActions", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetErrorSource with NULL handle");
outErrSource = CMGetErrorSource(cmpiError, &rc);
if (!outErrSource)
{
PROV_LOG ("++++ (%s) CMGetErrorSource", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetErrorSourceFormat with NULL handle");
outErrSourceFormat = CMGetErrorSourceFormat(cmpiError, &rc);
if (!outErrSourceFormat)
{
PROV_LOG ("++++ (%s) CMGetErrorSourceFormat (%d)", strCMPIStatus (rc),
outErrSourceFormat);
}
PROV_LOG ("Calling CMGetOtherErrorSourceFormat with NULL handle");
outOtherErrSourceFormat = CMGetOtherErrorSourceFormat(cmpiError, &rc);
if (!outOtherErrSourceFormat)
{
PROV_LOG ("++++ (%s) CMGetOtherErrorSourceFormat", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetCIMStatusCode with NULL handle");
outCIMStatusCode = CMGetCIMStatusCode(cmpiError, &rc);
if (!outCIMStatusCode)
{
PROV_LOG ("++++ (%s) CMGetCIMStatusCode (%d)", strCMPIStatus (rc),
outCIMStatusCode);
}
PROV_LOG ("Calling CMGetCIMStatusCodeDescription with NULL handle");
outCIMStatusCodeDesc = CMGetCIMStatusCodeDescription(cmpiError, &rc);
if (!outCIMStatusCodeDesc)
{
PROV_LOG ("++++ (%s) CMGetCIMStatusCodeDescription", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetMessageArguments with NULL handle");
outMsgArgs = CMGetMessageArguments(cmpiError, &rc);
if (!outMsgArgs)
{
PROV_LOG ("++++ (%s) CMGetMessageArguments", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMSetErrorType with NULL handle");
rc = CMSetErrorType(cmpiError, inErrType);
PROV_LOG ("++++ (%s) CMSetErrorType", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetOtherErrorType with NULL handle");
rc = CMSetOtherErrorType(cmpiError, inOtherErrType);
PROV_LOG ("++++ (%s) CMSetOtherErrorType", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetProbableCauseDescription with NULL handle");
rc = CMSetProbableCauseDescription(cmpiError, inPcd);
PROV_LOG ("++++ (%s) CMSetProbableCauseDescription", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetRecommendedActions with NULL handle");
rc = CMSetRecommendedActions(cmpiError, inRecActions);
PROV_LOG ("++++ (%s) CMSetRecommendedActions", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetErrorSource with NULL handle");
rc = CMSetErrorSource(cmpiError, inErrSource);
PROV_LOG ("++++ (%s) CMSetErrorSource", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetErrorSourceFormat with NULL handle");
rc = CMSetErrorSourceFormat(cmpiError, inErrSourceFormat);
PROV_LOG ("++++ (%s) CMSetErrorSourceFormat", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetOtherErrorSourceFormat with NULL handle");
rc = CMSetOtherErrorSourceFormat(cmpiError, inOtherErrSourceFormat);
PROV_LOG ("++++ (%s) CMSetOtherErrorSourceFormat", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetCIMStatusCodeDescription with NULL handle");
rc = CMSetCIMStatusCodeDescription(cmpiError, inCIMStatusCodeDesc);
PROV_LOG ("++++ (%s) CMSetCIMStatusCodeDescription", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetMessageArguments with NULL handle");
rc = CMSetMessageArguments(cmpiError, inMsgArgs);
PROV_LOG ("++++ (%s) CMSetMessageArguments", strCMPIStatus (rc));
PROV_LOG_CLOSE();
// Test case to increase coverage in CMPI_Broker.cpp
objPath = CMNewObjectPath (_broker,
"test/TestProvider",
"TestCMPI_Method",
&rc);
retData = CBInvokeMethod(_broker,
ctx,
objPath,
"testReturn",
in,
out,
&rc);
PROV_LOG_OPEN (_ClassName, _ProviderLocation);
if(retData.value.uint32 == 2 && rc.rc == CMPI_RC_OK)
{
PROV_LOG ("++++ (%s) CMInvokeMethod", strCMPIStatus (rc));
}
PROV_LOG ("--- %s CMPI InvokeMethod() exited with CMPI_RC_ERR_FAILED",
_ClassName);
PROV_LOG_CLOSE();
CMReturnWithString(inCIMStatusCode,
CMNewString(_broker, "TestError invokeMethod() expected failure", NULL));
}
CMPIStatus Linux_FanProviderGetInstance( CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * cop,
const char **properties) {
UNUSED(mi);
CMPIInstance * ci = NULL;
CMPIStatus rc = {CMPI_RC_OK, NULL};
struct cim_fan * sptr = NULL;
CMPIData data;
CMPIArray * other_identifying_info = NULL;
CMPIString * sys_path = NULL;
CMPIString * fan_name = NULL;
CMPIString * device_id = NULL;
cim_fan_error_t cmdrc;
_OSBASE_TRACE(1,("--- %s CMPI GetInstance() called",_ClassName));
_check_system_key_value_pairs(_broker, cop, "SystemCreationClassName",
"SystemName", &rc);
if (rc.rc != CMPI_RC_OK) {
_OSBASE_TRACE(1, ("--- %s CMPI GetInstance() failed : %s",
_ClassName, CMGetCharPtr(rc.msg)));
return rc;
}
data = CMGetKey(cop, "OtherIdentifyingInfo", &rc);
if ( !rc.rc
&& data.type == CMPI_stringA
&& (other_identifying_info = data.value.array)
&& !rc.rc
&& (CMGetArrayCount(other_identifying_info, &rc) > 1)
&& !rc.rc)
{
data = CMGetArrayElementAt(other_identifying_info, 0, &rc);
if (!rc.rc) sys_path = data.value.string;
data = CMGetArrayElementAt(other_identifying_info, 1, &rc);
if (!rc.rc) fan_name = data.value.string;
}
device_id = CMGetKey(cop, "DeviceID", &rc).value.string;
if ((sys_path == NULL || fan_name == NULL) && (device_id == NULL)) {
CMSetStatusWithChars(_broker, &rc,
CMPI_RC_ERR_FAILED, "Could not get fan ID." );
_OSBASE_TRACE(1, ("--- %s CMPI GetInstance() failed : %s",
_ClassName, CMGetCharPtr(rc.msg)));
return rc;
}
if (sys_path && fan_name) {
cmdrc = get_fan_data(CMGetCharPtr(sys_path), CMGetCharPtr(fan_name),
&sptr);
}
if ((cmdrc || !sptr) && device_id) {
cmdrc = get_fan_data_by_id(CMGetCharPtr(device_id), &sptr);
}
if (cmdrc || !sptr) {
CMSetStatusWithChars(_broker, &rc,
CMPI_RC_ERR_NOT_FOUND, cim_fan_strerror(cmdrc));
_OSBASE_TRACE(1, ("--- %s CMPI GetInstance() exited : %s",
_ClassName,CMGetCharPtr(rc.msg)));
return rc;
}
ci = _makeInst_Fan(_broker, ctx, cop, properties, sptr, &rc);
if (sptr) free_fan(sptr);
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;
}
static int
_testCMPIArray()
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIArray *arr_ptr = NULL;
CMPIArray *new_arr_ptr = NULL;
CMPIData data[3];
CMPIData clonedData[3];
CMPIValue value;
CMPIType initArrayType = CMPI_uint32;
CMPIType initErrArrayType = CMPI_REAL;
CMPIType returnedArrayType;
CMPICount initArraySize = 3;
CMPICount returnedArraySize;
CMPIUint32 i;
CMPIBoolean cloneSuccessful = 0;
CMPIBoolean getDataSuccessful;
void *aptr;
arr_ptr = CMNewArray(_broker, initArraySize, initArrayType, &rc);
if (arr_ptr == NULL) {
return 1;
}
returnedArraySize = CMGetArrayCount(arr_ptr, &rc);
returnedArrayType = CMGetArrayType(arr_ptr, &rc);
value.uint32 = 10;
rc = CMSetArrayElementAt(arr_ptr, 0, &value, initArrayType);
value.uint32 = 20;
rc = CMSetArrayElementAt(arr_ptr, 1, &value, initArrayType);
value.uint32 = 30;
rc = CMSetArrayElementAt(arr_ptr, 2, &value, initArrayType);
i = 0;
while (i < 3) {
data[i] = CMGetArrayElementAt(arr_ptr, i, &rc);
i++;
}
i = 0;
getDataSuccessful = 1;
while (i < 3) {
if (data[i].value.uint32 != (i + 1) * 10) {
getDataSuccessful = 0;
break;
}
i++;
}
new_arr_ptr = arr_ptr->ft->clone(arr_ptr, &rc);
i = 0;
while (i < 3) {
clonedData[i] = CMGetArrayElementAt(new_arr_ptr, i, &rc);
i++;
}
cloneSuccessful = 1;
for (i = 0; i < initArraySize; i++) {
if (data[i].value.uint32 != clonedData[i].value.uint32) {
cloneSuccessful = 0;
break;
}
}
rc = new_arr_ptr->ft->release(new_arr_ptr);
aptr = arr_ptr->hdl;
arr_ptr->hdl = NULL;
returnedArraySize = CMGetArrayCount(arr_ptr, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
returnedArrayType = CMGetArrayType(arr_ptr, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
rc = CMSetArrayElementAt(arr_ptr, 2, &value, initArrayType);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
CMGetArrayElementAt(arr_ptr, 5, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
arr_ptr->ft->clone(arr_ptr, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
rc = arr_ptr->ft->release(arr_ptr);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
arr_ptr->hdl = aptr;
CMGetArrayElementAt(arr_ptr, 5, &rc);
if (rc.rc != CMPI_RC_ERR_NO_SUCH_PROPERTY) {
return 1;
}
rc = CMSetArrayElementAt(arr_ptr, 2, &value, initErrArrayType);
if (rc.rc != CMPI_RC_ERR_TYPE_MISMATCH) {
return 1;
}
rc = arr_ptr->ft->release(arr_ptr);
return 0;
}
static CMPIStatus
enumInstances(CMPIInstanceMI * mi,
const CMPIContext *ctx, void *rslt,
const CMPIObjectPath * ref,
const char **properties,
void (*retFnc) (void *, CMPIInstance *), int ignprov)
{
CMPIStatus st = { CMPI_RC_OK, NULL };
CMPIStatus sti = { CMPI_RC_OK, NULL };
BlobIndex *bi;
CMPIString *cn = CMGetClassName(ref, NULL);
CMPIString *ns = CMGetNameSpace(ref, NULL);
const char *nss = ns->ft->getCharPtr(ns, NULL);
const char *cns = cn->ft->getCharPtr(cn, NULL);
const char *bnss = repositoryNs(nss);
int len,
i,
ac = 0;
CMPIInstance *ci;
CMPIArgs *in,
*out;
CMPIObjectPath *op;
CMPIArray *ar;
CMPIData rv;
const char **keyList;
_SFCB_ENTER(TRACE_INTERNALPROVIDER, "enumInstances");
_SFCB_TRACE(1, ("--- %s %s", nss, cns));
in = CMNewArgs(Broker, NULL);
out = CMNewArgs(Broker, NULL);
if (ignprov)
CMAddArg(in, "classignoreprov", cns, CMPI_chars);
else
CMAddArg(in, "class", cns, CMPI_chars);
op = CMNewObjectPath(Broker, bnss, "$ClassProvider$", &sti);
_SFCB_TRACE(1, ("--- getallchildren"));
rv = CBInvokeMethod(Broker, ctx, op, "getallchildren", in, out, &sti);
_SFCB_TRACE(1, ("--- getallchildren rc: %d", sti.rc));
ar = CMGetArg(out, "children", NULL).value.array;
if (ar)
ac = CMGetArrayCount(ar, NULL);
_SFCB_TRACE(1, ("--- getallchildren ar: %p count: %d", ar, ac));
for (i = 0; cns; i++) {
_SFCB_TRACE(1, ("--- looking for %s", cns));
if ((bi = _getIndex(bnss, cns)) != NULL) {
for (ci = ipGetFirst(bi, &len, NULL, 0); ci;
ci = ipGetNext(bi, &len, NULL, 0)) {
if (properties) {
keyList = getKeyList(ci->ft->getObjectPath(ci, NULL));
ci->ft->setPropertyFilter(ci, properties, keyList);
if (keyList) {
free(keyList);
}
}
_SFCB_TRACE(1, ("--- returning instance %p", ci));
retFnc(rslt, ci);
}
}
freeBlobIndex(&bi, 1);
if (i < ac)
cns = (char *) CMGetArrayElementAt(ar, i, NULL).value.string->hdl;
else
cns = NULL;
}
_SFCB_RETURN(st);
}
CMPIStatus
getRefs(const CMPIContext *ctx, const CMPIResult *rslt,
const CMPIObjectPath * cop,
const char *assocClass,
const char *resultClass,
const char *role,
const char *resultRole,
const char **propertyList, int associatorFunction)
{
UtilList *refs = UtilFactory->newList(memAddUtilList, memUnlinkEncObj);
char *ns = (char *) CMGetNameSpace(cop, NULL)->hdl;
CMPIStatus st = { CMPI_RC_OK, NULL };
_SFCB_ENTER(TRACE_INTERNALPROVIDER, "getRefs");
if (assocClass != NULL) {
CMPIObjectPath *path;
if (assocForName(ns, assocClass, role, resultRole) == NULL) {
/*
* for an unknown class we just return nothing
*/
_SFCB_RETURN(st);
}
path = CMNewObjectPath(_broker, ns, assocClass, NULL);
SafeInternalProviderAddEnumInstances(refs, NULL, ctx, path,
propertyList, &st, 1);
}
else {
CMPIData rv;
CMPIObjectPath *op =
CMNewObjectPath(Broker, ns, "$ClassProvider$", &st);
CMPIArgs *in = CMNewArgs(Broker, NULL);
CMPIArgs *out = CMNewArgs(Broker, NULL);
rv = CBInvokeMethod(Broker, ctx, op, "getassocs", in, out, &st);
if (out) {
int i,
m;
CMPIArray *ar = CMGetArg(out, "assocs", &st).value.array;
for (i = 0, m = CMGetArrayCount(ar, NULL); i < m; i++) {
char *name =
CMGetArrayElementAt(ar, i, NULL).value.string->hdl;
if (name) {
CMPIObjectPath *cop = CMNewObjectPath(Broker, ns, name, NULL);
if (cop) {
SafeInternalProviderAddEnumInstances(refs, NULL, ctx, cop,
propertyList, &st, 1);
}
}
_SFCB_TRACE(1, ("--- assoc %s", name));
}
}
}
if (role) {
// filter out the associations not matching the role property
CMPIInstance *ci;
UtilStringBuffer *pn = normalizeObjectPathStrBuf(cop);
for (ci = refs->ft->getFirst(refs); ci; ci = refs->ft->getNext(refs)) {
CMPIData data = CMGetProperty(ci, role, NULL);
if ((data.state & CMPI_notFound) ||
data.type != CMPI_ref ||
objectPathEquals(pn, data.value.ref, NULL, 0) == 0) {
refs->ft->removeCurrent(refs);
}
}
pn->ft->release(pn);
}
else {
// filter out associations not referencing pathName
CMPIInstance *ci;
int matched,
i,
m;
UtilStringBuffer *pn = normalizeObjectPathStrBuf(cop);
for (ci = refs->ft->getFirst(refs); ci; ci = refs->ft->getNext(refs)) {
for (matched = 0, i = 0, m = CMGetPropertyCount(ci, NULL); i < m;
i++) {
CMPIData data = CMGetPropertyAt(ci, i, NULL, NULL);
if (data.type == CMPI_ref
&& objectPathEquals(pn, data.value.ref, NULL, 0)) {
matched = 1;
break;
}
}
if (matched == 0)
refs->ft->removeCurrent(refs);
}
pn->ft->release(pn);
}
if (associatorFunction == REF) {
CMPIInstance *ci;
for (ci = refs->ft->getFirst(refs); ci; ci = refs->ft->getNext(refs)) {
CMReturnInstance(rslt, ci);
}
refs->ft->release(refs);
_SFCB_RETURN(st);
}
else if (associatorFunction == REF_NAME) {
CMPIInstance *ci;
for (ci = refs->ft->getFirst(refs); ci; ci = refs->ft->getNext(refs)) {
CMPIObjectPath *ref = CMGetObjectPath(ci, NULL);
CMReturnObjectPath(rslt, ref);
}
refs->ft->release(refs);
_SFCB_RETURN(st);
}
else {
// Use hashtable to avoid dup'd associators
CMPIInstance *ci;
UtilHashTable *assocs =
UtilFactory->newHashTable(61, UtilHashTable_charKey);
UtilStringBuffer *pn = normalizeObjectPathStrBuf(cop);
for (ci = refs->ft->getFirst(refs); ci; ci = refs->ft->getNext(refs)) {
// Q: for ASSOC_NAME we should not require the
// object exist if we go by the book, should we?
// The current approach retrieves the instances
// via the CIMOM handle
if (resultRole) {
CMPIData data = CMGetProperty(ci, resultRole, NULL);
UtilStringBuffer *an = NULL;
if ((data.state & CMPI_notFound) == 0 && data.type == CMPI_ref &&
objectPathEquals(pn, data.value.ref, &an, 0) == 0) {
if (resultClass == NULL
|| CMClassPathIsA(Broker, data.value.ref, resultClass,
NULL)) {
CMPIInstance *aci =
CBGetInstance(Broker, ctx, data.value.ref, propertyList,
&st);
assocs->ft->put(assocs, an->ft->getCharPtr(an), aci);
}
}
}
else {
// must loop over the properties to find ref instances
int i,
m;
for (i = 0, m = CMGetPropertyCount(ci, NULL); i < m; i++) {
CMPIData data = CMGetPropertyAt(ci, i, NULL, NULL);
if (data.type == CMPI_ref) {
CMPIObjectPath *ref = data.value.ref;
CMPIString *tns = CMGetNameSpace(ref, NULL);
if (tns == NULL || tns->hdl == NULL)
CMSetNameSpace(ref, ns);
UtilStringBuffer *an = NULL;
if (objectPathEquals(pn, ref, &an, 0) == 0) {
if (resultClass == NULL
|| CMClassPathIsA(Broker, ref, resultClass, NULL)) {
CMPIInstance *aci =
CBGetInstance(Broker, ctx, ref, propertyList, &st);
if (aci)
assocs->ft->put(assocs, an->ft->getCharPtr(an), aci);
}
}
}
}
}
}
{
HashTableIterator *it;
char *an;
CMPIInstance *aci;
for (it =
assocs->ft->getFirst(assocs, (void **) &an, (void **) &aci); it;
it =
assocs->ft->getNext(assocs, it, (void **) &an,
(void **) &aci)) {
if (associatorFunction == ASSOC)
CMReturnInstance(rslt, aci);
else {
CMPIObjectPath *op = CMGetObjectPath(aci, NULL);
CMReturnObjectPath(rslt, op);
}
}
}
refs->ft->release(refs);
assocs->ft->release(assocs);
pn->ft->release(pn);
_SFCB_RETURN(st);
}
}
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);
}
static CMPI_THREAD_RETURN CMPI_THREAD_CDECL
thread (void *args)
{
CMPIString *str = NULL;
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIStatus rc_Eval = { CMPI_RC_OK, NULL };
CMPIStatus rc_Clone = { CMPI_RC_OK, NULL };
CMPIStatus rc_Inst = { CMPI_RC_OK, NULL };
CMPIStatus rc_Pred = { CMPI_RC_OK, NULL };
CMPIStatus rc_Array = { CMPI_RC_OK, NULL };
CMPIStatus rc_CMGetPropertyAt = { CMPI_RC_OK, NULL };
CMPIString *type = NULL;
CMPISelectExp *clone = NULL;
CMPIBoolean evalRes;
CMPIInstance *inst = NULL;
CMPIObjectPath *objPath = NULL;
CMPIString *name = NULL;
CMPIData prop_data = { 0, CMPI_null, {0} };
CMPIData data = { 0, CMPI_null, {0} };
CMPIArray *projection = NULL;
/* General purpose counters */
unsigned int idx;
CMPICount cnt;
/* Select Condition and sub conditions */
CMPISelectCond *cond = NULL;
int sub_type;
CMPISubCond *subcnd = NULL;
/* Predicate operations */
CMPICount pred_cnt;
unsigned int pred_idx;
CMPIPredicate *pred = NULL;
CMPIType pred_type;
CMPIPredOp pred_op;
CMPIString *left_side = NULL;
CMPIString *right_side = NULL;
/* Thread specific data, passed in via arguments. This could also
be passed via thread specific data.. */
void **arguments = (void **) args;
CMPIContext *ctx;
CMPISelectExp *se;
char *ns;
CMPIBroker *broker;
// Copy over the CMPISelectExp, CMPIContext, CMPIBroker and the ns from the argument.
se = (CMPISelectExp *)arguments[0];
ctx = (CMPIContext *)arguments[1];
broker = (CMPIBroker *)arguments[2];
ns = (char *)arguments[3];
free(arguments);
_thread_active = 1;
// Get the CMPIContext and attach it to this thread.
rc = CBAttachThread (broker, ctx);
// Wait until we get the green signal.
while (_thread_runs == 0)
{
broker->xft->threadSleep(1000);
}
//PROV_LOG_OPEN (_IndClassName, _ProviderLocation);
PROV_LOG ("--- CBAttachThread callled.");
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc), (rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
PROV_LOG ("--- %s CMPI thread(void *) running",_IndClassName);
PROV_LOG ("-- #1 Clone");
clone = CMClone (se, &rc_Clone);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc_Clone), (rc_Clone.msg == 0) ? "" : CMGetCharPtr(rc_Clone.msg));
if (clone)
CMRelease (clone);
/*
This functionality is not used in indication providers, but instead in
ExecQuery provider API (instance providers). But for the sake
of completness this functionality is also used here. */
PROV_LOG ("-- #1.1 CMNewSelectExp");
str = CMGetSelExpString (se, &rc);
clone =
//CMPI_CQL_NewSelectExp (broker, CMGetCharPtr (str), "CIMxCQL",
CMNewSelectExp (broker, CMGetCharPtr (str), "CIM:CQL",
&projection, &rc_Clone);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc_Clone), (rc_Clone.msg == 0) ? "" : CMGetCharPtr(rc_Clone.msg));
if (clone)
{
if (projection)
{
PROV_LOG ("--- #1.2 Projection list is: ");
cnt = CMGetArrayCount (projection, &rc_Array);
PROV_LOG ("---- %s, [%s]", strCMPIStatus (rc_Array),(rc_Array.msg == 0) ? "" : CMGetCharPtr(rc_Array.msg));
PROV_LOG ("--- #1.3 CMGetArrayCount, %d", cnt);
for (idx = 0; idx < cnt; idx++)
{
PROV_LOG ("--- #1.4 CMGetArrayElementAt");
data = CMGetArrayElementAt (projection, idx, &rc_Array);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc_Array), (rc_Array.msg == 0) ? "" : CMGetCharPtr(rc_Array.msg));
PROV_LOG ("---- type is : %d", data.type);
if (data.type == CMPI_chars)
{
PROV_LOG ("---- %s (chars)", data.value.chars);
}
if (data.type == CMPI_string)
{
PROV_LOG ("---- %s (string)",
CMGetCharPtr (data.value.string));
}
}
}
else
{
PROV_LOG
("--- #1.2 No projection list, meaning it is SELECT * .... ");
}
}
// This is how an indication provider would work.
// Create an objectpath + instance and use CMEvaluateSelExp
// OR
// use CMEvaluateSelExpUsingAccessor and pass in the function that would
// provide the properties values.
PROV_LOG ("-- #2 MakeObjectPath");
// Create instance
objPath = make_ObjectPath (broker, _Namespace, _IndClassName);
type = CDGetType (broker, objPath, &rc_Inst);
PROV_LOG ("---- %s (%s) [%s]", CMGetCharPtr (type), strCMPIStatus (rc_Inst),(rc_Inst.msg == 0) ? "" : CMGetCharPtr(rc_Inst.msg));
CMRelease (type);
PROV_LOG ("-- #3 Instance");
inst = CMNewInstance (broker, objPath, &rc_Inst);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc_Inst), (rc_Inst.msg == 0) ? "" : CMGetCharPtr(rc_Inst.msg));
if (rc_Inst.rc == CMPI_RC_ERR_NOT_FOUND)
{
PROV_LOG (" --- Class %s is not found in the %s namespace!",
_IndClassName, _Namespace);
PROV_LOG (" --- Aborting!!! ");
goto exit;
}
type = CDGetType (broker, inst, &rc_Inst);
if (type)
{
PROV_LOG ("---- %s (%s) [%s]", CMGetCharPtr (type), strCMPIStatus (rc_Inst),(rc_Inst.msg == 0) ? "" : CMGetCharPtr(rc_Inst.msg));
CMRelease (type);
}
PROV_LOG ("- CMGetPropertyCount: %d", CMGetPropertyCount (inst, &rc));
// Set each property.
for (idx = 0; idx < CMGetPropertyCount (inst, &rc); idx++)
{
prop_data = CMGetPropertyAt (inst, idx, &name, &rc_CMGetPropertyAt);
// Really dumb way of doing it. Just set each property with its own property name.
if (prop_data.type == CMPI_string)
{
CMSetProperty (inst, CMGetCharPtr (name), CMGetCharPtr (name),
CMPI_chars);
}
prop_data = CMGetPropertyAt (inst, idx, &name, &rc_CMGetPropertyAt);
PROV_LOG ("-- %d: %s(%s: %s: %s) [%s]", idx,
CMGetCharPtr (name),
strCMPIType (prop_data.type),
strCMPIValueState (prop_data.state),
strCMPIValue (prop_data.value),
strCMPIStatus (rc_CMGetPropertyAt));
}
PROV_LOG ("-- #4 Evaluate using instance");
evalRes = CMEvaluateSelExp (se, inst, &rc_Eval);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc_Eval), (rc_Eval.msg == 0) ? "" : CMGetCharPtr(rc_Eval.msg));
if (evalRes == CMPI_true)
{
PROV_LOG ("--- True, sending indication");
rc_Eval = CBDeliverIndication (broker, ctx, _Namespace, inst);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc_Eval), (rc_Eval.msg == 0) ? "" : CMGetCharPtr(rc_Eval.msg));
}
else
{
PROV_LOG ("--- False");
}
PROV_LOG ("-- #4.1 Evalute using accessor");
evalRes =
CMEvaluateSelExpUsingAccessor (se, instance_accessor, broker, &rc_Eval);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc_Eval), (rc_Eval.msg == 0) ? "" : CMGetCharPtr(rc_Eval.msg));
if (evalRes == CMPI_true)
{
PROV_LOG ("--- True, but not sending indication");
}
else
{
PROV_LOG ("--- False");
}
PROV_LOG ("-- #5 CMGetSelExpString");
str = CMGetSelExpString (se, &rc);
type = CDGetType (broker, str, &rc_Inst);
if (type != NULL)
{
PROV_LOG ("---- %s (%s) [%s]", CMGetCharPtr (type), strCMPIStatus (rc_Inst), (rc_Inst.msg == 0) ? "" : CMGetCharPtr(rc_Inst.msg));
CMRelease (type);
}
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc), (rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
PROV_LOG ("-- #5.1 Query is [%s]", CMGetCharPtr (str));
PROV_LOG ("-- #5.2 Query is [%s]", ns);
PROV_LOG ("-- #6 Continue evaluating using GetDOC");
{
cond = CMGetDoc (se, &rc);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc), (rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
if (cond != NULL)
{
PROV_LOG ("--- #6.1 CMGetSubCondCountAndType ");
cnt = CMGetSubCondCountAndType (cond, &sub_type, &rc);
PROV_LOG ("---- %s %s", strCMPIStatus (rc), (rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
PROV_LOG ("---- Number of disjunctives: %d, Type: %X", cnt, sub_type);
/* Parsing the disjunctives */
for (idx = 0; idx < cnt; idx++)
{
PROV_LOG ("--- #6.2 CMGetSubCondAt @ %d ", idx);
subcnd = CMGetSubCondAt (cond, idx, &rc);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc),(rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
PROV_LOG ("--- #6.3 CMGetPredicateCount");
pred_cnt = CMGetPredicateCount (subcnd, &rc);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc), (rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
PROV_LOG ("---- Number of predicates in the conjuctives: %d",
pred_cnt);
/* Parsing throught conjuctives */
for (pred_idx = 0; pred_idx < pred_cnt; pred_idx++)
{
PROV_LOG ("--- #6.4 CMGetPredicateAt, %d", pred_idx);
pred = CMGetPredicateAt (subcnd, pred_idx, &rc);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc),(rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
PROV_LOG ("--- #6.4 CMGetPredicateData");
rc = CMGetPredicateData (pred,
&pred_type,
&pred_op, &left_side, &right_side);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc),(rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
PROV_LOG ("----- Type: %s , CMPIPredOp: %s, LS: %s, RS: %s",
strCMPIType (pred_type), strCMPIPredOp (pred_op),
CMGetCharPtr (left_side),
CMGetCharPtr (right_side));
PROV_LOG ("--- #6.5 Evaluate using predicate");
#ifdef CMPI_VER_100
// The CMEvaluatePredicate is gone in the CMPI 1.0 standard.
evalRes =
CMEvaluatePredicateUsingAccessor (pred, instance_accessor,
NULL, &rc_Pred);
#else
// One can also evaluate this specific predicate
evalRes =
CMEvaluatePredicate (pred, "PredicateEvaluation",
CMPI_chars, &rc_Pred);
#endif
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc_Pred), (rc_Pred.msg == 0) ? "" : CMGetCharPtr(rc_Pred.msg));
if (evalRes == CMPI_true)
{
PROV_LOG ("--- True");
}
else
{
PROV_LOG ("--- False");
}
}
}
}
}
PROV_LOG ("-- #7 GetCOD");
{
cond = CMGetCod (se, &rc);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc), (rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
/* Currently this is not supported in Pegasus. */
if (cond != NULL)
{
}
}
exit:
PROV_LOG ("--- CBDetachThread called");
rc = CBDetachThread (broker, ctx);
free (ns);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc), (rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
PROV_LOG ("--- %s CMPI thread(void *) exited", _IndClassName);
_thread_active = 0;
_thread_runs = 0;
return (CMPI_THREAD_RETURN) 0;
}
static CMPIBoolean __eft_hasNext ( CMPIEnumeration * enumeration,
CMPIStatus * rc )
{
struct native_enum * e = (struct native_enum *) enumeration;
return ( e->current < CMGetArrayCount ( e->data, rc ) );
}