static void loopOnChildren(ClassRegister *cReg, char *cn, CMPIResult * rslt)
{
UtilList *ul = getChildren(cReg,cn);
char *child;
ReadCtl ctl;
if (ul) for (child = (char *) ul->ft->getFirst(ul); child; child = (char *) ul->ft->getNext(ul)) {
ctl=tempRead;
CMPIConstClass *cl = getResolvedClass(cReg,child,NULL, &ctl);
CMReturnInstance(rslt, (CMPIInstance *) cl);
if (ctl!=cached) CMRelease(cl);
loopOnChildren(cReg,child,rslt);
}
}
static CMPIStatus
ClassProviderGetClass(CMPIClassMI * mi,
const CMPIContext *ctx,
const CMPIResult *rslt,
const CMPIObjectPath * ref, const char **properties)
{
CMPIStatus st = { CMPI_RC_OK, NULL };
CMPIString *cn = CMGetClassName(ref, NULL);
CMPIConstClass *cl,
*clLocal;
ClassRegister *cReg;
int rc;
ReadCtl ctl;
_SFCB_ENTER(TRACE_PROVIDERS, "ClassProviderGetClass");
_SFCB_TRACE(1, ("--- ClassName=\"%s\"", (char *) cn->hdl));
cReg = getNsReg(ref, &rc);
if (cReg == NULL) {
CMPIStatus st = { CMPI_RC_ERR_INVALID_NAMESPACE, NULL };
_SFCB_RETURN(st);
}
cReg->ft->wLock(cReg);
ctl = stdRead;
clLocal = getResolvedClass(cReg, (char *) cn->hdl, NULL, &ctl);
if (clLocal) {
/*
* Make a cloned copy of the cached results to prevent thread
* interference.
*/
_SFCB_TRACE(1, ("--- Class found"));
cl = clLocal->ft->clone(clLocal, NULL);
memLinkInstance((CMPIInstance *) cl);
CMReturnInstance(rslt, (CMPIInstance *) cl);
if (ctl != cached)
CMRelease(cl);
} else {
_SFCB_TRACE(1, ("--- Class not found"));
st.rc = CMPI_RC_ERR_NOT_FOUND;
}
cReg->ft->wUnLock(cReg);
_SFCB_RETURN(st);
}
static CMPIStatus
ClassProviderEnumClasses(CMPIClassMI * mi,
const CMPIContext *ctx,
const CMPIResult *rslt, const CMPIObjectPath * ref)
{
CMPIStatus st = { CMPI_RC_OK, NULL };
char *cn = NULL;
CMPIFlags flgs = 0;
CMPIString *cni;
ClassBase *cb;
Iterator it;
char *key;
int rc;
CMPIConstClass *cls;
ClassRegister *cReg;
ReadCtl rctl;
ClassRecord *crec;
_SFCB_ENTER(TRACE_PROVIDERS, "ClassProviderEnumClasss");
cReg = getNsReg(ref, &rc);
if (cReg == NULL) {
CMPIStatus st = { CMPI_RC_ERR_INVALID_NAMESPACE, NULL };
_SFCB_RETURN(st);
}
cReg->ft->wLock(cReg);
flgs = ctx->ft->getEntry(ctx, CMPIInvocationFlags, NULL).value.uint32;
cni = ref->ft->getClassName(ref, NULL);
if (cni) {
cn = (char *) cni->hdl;
if (cn && *cn == 0)
cn = NULL;
}
cb = (ClassBase *) cReg->hdl;
if (cn == NULL) {
for (it = cReg->ft->getFirstClassRecord(cReg, &key, &crec);
key && it && crec;
it = cReg->ft->getNextClassRecord(cReg, it, &key, &crec)) {
char *cn = key;
char *pcn = crec->parent;
if ((flgs & CMPI_FLAG_DeepInheritance) || pcn == NULL) {
rctl = tempRead;
CMPIConstClass *rcls = getResolvedClass(cReg, cn, crec, &rctl);
CMReturnInstance(rslt, (CMPIInstance *) rcls);
if (rctl != cached)
CMRelease(rcls);
}
}
}
else {
rctl = tempRead;
cls = getResolvedClass(cReg, cn, NULL, &rctl);
if (cls == NULL) {
st.rc = CMPI_RC_ERR_INVALID_CLASS;
} else if ((flgs & CMPI_FLAG_DeepInheritance) == 0) {
UtilList *ul = getChildren(cReg, cn);
char *child;
if (ul)
for (child = (char *) ul->ft->getFirst(ul); child;
child = (char *) ul->ft->getNext(ul)) {
rctl = tempRead;
cls = getResolvedClass(cReg, child, NULL, &rctl);
CMReturnInstance(rslt, (CMPIInstance *) cls);
if (rctl != cached)
CMRelease(cls);
}
} else if (cn && (flgs & CMPI_FLAG_DeepInheritance)) {
loopOnChildren(cReg, cn, rslt);
}
}
cReg->ft->wUnLock(cReg);
_SFCB_RETURN(st);
}
