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); }
CMPIStatus IndCIMXMLHandlerCreateInstance(CMPIInstanceMI * mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath * cop, const CMPIInstance *ci) { CMPIStatus st = { CMPI_RC_OK, NULL }; CMPIArgs *in, *out = NULL; CMPIObjectPath *op; CMPIData rv; unsigned short persistenceType; _SFCB_ENTER(TRACE_INDPROVIDER, "IndCIMXMLHandlerCreateInstance"); if (interOpNameSpace(cop, &st) == 0) _SFCB_RETURN(st); internalProviderGetInstance(cop, &st); if (st.rc == CMPI_RC_ERR_FAILED) _SFCB_RETURN(st); if (st.rc == CMPI_RC_OK) { setStatus(&st, CMPI_RC_ERR_ALREADY_EXISTS, NULL); _SFCB_RETURN(st); } CMPIInstance *ciLocal = CMClone(ci, NULL); memLinkInstance(ciLocal); CMPIObjectPath* copLocal = CMClone(cop, NULL); memLinkObjectPath(copLocal); setCCN(copLocal,ciLocal,"CIM_ComputerSystem"); CMPIString *sysname=ciLocal->ft->getProperty(ciLocal,"SystemName",&st).value.string; if (sysname == NULL || sysname->hdl == NULL) { char hostName[512]; hostName[0]=0; gethostname(hostName,511); /* should be the same as SystemName of IndicationService */ CMAddKey(copLocal, "SystemName", hostName, CMPI_chars); CMSetProperty(ciLocal,"SystemName",hostName,CMPI_chars); } CMPIString *dest = CMGetProperty(ciLocal, "destination", &st).value.string; if (dest == NULL || CMGetCharPtr(dest) == NULL) { setStatus(&st, CMPI_RC_ERR_FAILED, "Destination property not found; is required"); CMRelease(ciLocal); _SFCB_RETURN(st); } else { /* if no scheme is given, assume http (as * req. for param by mof) */ char *ds = CMGetCharPtr(dest); if (strstr(ds, "://") == NULL) { char *prefix = "http://"; int n = strlen(ds) + strlen(prefix) + 1; char *newdest = (char *) malloc(n * sizeof(char)); strcpy(newdest, prefix); strcat(newdest, ds); CMSetProperty(ciLocal, "destination", newdest, CMPI_chars); free(newdest); } } CMPIData persistence = CMGetProperty(ciLocal, "persistencetype", &st); if (persistence.state == CMPI_nullValue || persistence.state == CMPI_notFound) { persistenceType = 2; /* default is 2 = permanent */ } else if (persistence.value.uint16 < 1 || persistence.value.uint16 > 3) { setStatus(&st, CMPI_RC_ERR_FAILED, "PersistenceType property must be 1, 2, or 3"); CMRelease(ciLocal); _SFCB_RETURN(st); } else { persistenceType = persistence.value.uint16; } CMSetProperty(ciLocal, "persistencetype", &persistenceType, CMPI_uint16); if (CMClassPathIsA(_broker, copLocal, "cim_listenerdestination", NULL)) { //get the creation timestamp struct timeval tv; struct timezone tz; char context[100]; gettimeofday(&tv, &tz); struct tm cttm; char * gtime = (char *) malloc(15 * sizeof(char)); memset(gtime, 0, 15 * sizeof(char)); if (gmtime_r(&tv.tv_sec, &cttm) != NULL) { strftime(gtime, 15, "%Y%m%d%H%M%S", &cttm); } // Even though reliable indications may be disabled, we need to do this // in case it ever gets enabled. // Get the IndicationService name CMPIObjectPath * isop = CMNewObjectPath(_broker, "root/interop", "CIM_IndicationService", NULL); CMPIEnumeration * isenm = _broker->bft->enumerateInstances(_broker, ctx, isop, NULL, NULL); CMPIData isinst = CMGetNext(isenm, NULL); CMPIData mc = CMGetProperty(isinst.value.inst, "Name", NULL); // build the context string sprintf (context,"%s#%s#",mc.value.string->ft->getCharPtr(mc.value.string,NULL),gtime); CMPIValue scontext; scontext.string = sfcb_native_new_CMPIString(context, NULL, 0); free(gtime); // set the properties CMSetProperty(ciLocal, "SequenceContext", &scontext, CMPI_string); CMPIValue zarro = {.sint64 = -1 }; CMSetProperty(ciLocal, "LastSequenceNumber", &zarro, CMPI_sint64); } CMPIString *str = CDToString(_broker, copLocal, NULL); CMPIString *ns = CMGetNameSpace(copLocal, NULL); _SFCB_TRACE(1, ("--- handler %s %s", (char *) ns->hdl, (char *) str->hdl)); in = CMNewArgs(_broker, NULL); CMAddArg(in, "handler", &ciLocal, CMPI_instance); CMAddArg(in, "key", &copLocal, CMPI_ref); op = CMNewObjectPath(_broker, "root/interop", "cim_indicationsubscription", &st); rv = CBInvokeMethod(_broker, ctx, op, "_addHandler", in, out, &st); if (st.rc == CMPI_RC_OK) { st = InternalProviderCreateInstance(NULL, ctx, rslt, copLocal, ciLocal); } else { rv=CBInvokeMethod(_broker,ctx,op,"_removeHandler",in,out,NULL); } _SFCB_RETURN(st); } CMPIStatus IndCIMXMLHandlerModifyInstance(CMPIInstanceMI * mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath * cop, const CMPIInstance *ci, const char **properties) { CMPIStatus st = { CMPI_RC_ERR_NOT_SUPPORTED, NULL }; _SFCB_ENTER(TRACE_INDPROVIDER, "IndCIMXMLHandlerSetInstance"); _SFCB_RETURN(st); }
static CMPIStatus __rft_returnInstance(const CMPIResult * result, const CMPIInstance * instance) { int size,isInst=isInstance(instance); void *ptr; NativeResult *r = (NativeResult*) result; int releaseInstance=0; CMPIStatus st={CMPI_RC_OK,NULL}; _SFCB_ENTER(TRACE_PROVIDERDRV, "__rft_returnInstance"); if (r->qs) { int irc; if (r->qs->where) { r->qs->propSrc.data=(CMPIInstance *)instance; irc=r->qs->where->ft->evaluate(r->qs->where,&r->qs->propSrc); if (irc==1) { if (r->qs->allProps==0) { instance= r->qs->ft->cloneAndFilter(r->qs,(CMPIInstance *)instance,CMGetObjectPath(instance, NULL),r->qs->keys); releaseInstance=1; } } else CMReturn(CMPI_RC_OK); } else { if (r->qs->allProps==0) { instance=r->qs->ft->cloneAndFilter(r->qs,(CMPIInstance *)instance,CMGetObjectPath(instance,NULL), r->qs->keys); releaseInstance=1; } } } if (r->legacy) { CMPIValue v; CMPIStatus rc; _SFCB_TRACE(1,("--- Legacy Mode")); if(isInst) { v.inst = CMClone(instance,NULL); memLinkInstance(v.inst); } else v.inst = (CMPIInstance *) instance; rc=returnData(result, &v, CMPI_instance); if (releaseInstance) instance->ft->release((CMPIInstance*)instance); _SFCB_RETURN(rc); } if (isInst) { size=getInstanceSerializedSize(instance); ptr=nextResultBufferPos(r, MSG_SEG_INSTANCE, (unsigned long)size); _SFCB_TRACE(1,("--- Moving instance %d",size)); getSerializedInstance(instance,ptr); /* memcpy inst to ptr */ } else { size=getConstClassSerializedSize((CMPIConstClass*)instance); ptr=nextResultBufferPos(r, MSG_SEG_CONSTCLASS, (unsigned long)size); _SFCB_TRACE(1,("--- Moving class %d",size)); getSerializedConstClass((CMPIConstClass*)instance,ptr); } if (releaseInstance) instance->ft->release((CMPIInstance*)instance); _SFCB_RETURN(st); }