CMPIStatus IndCIMXMLHandlerEnumInstanceNames(CMPIInstanceMI * mi, const CMPIContext * ctx, const CMPIResult * rslt, const CMPIObjectPath * ref) { CMPIStatus st; CMPIEnumeration *enm; CMPIContext *ctxLocal; _SFCB_ENTER(TRACE_INDPROVIDER, "IndCIMXMLHandlerEnumInstanceNames"); if (interOpNameSpace(ref,&st)!=1) _SFCB_RETURN(st); ctxLocal = prepareUpcall((CMPIContext *)ctx); #ifdef HAVE_OPTIMIZED_ENUMERATION CMPIString* cn; CMPIObjectPath* refLocal; cn = CMGetClassName(ref, &st); if (strcasecmp(CMGetCharPtr(cn), "cim_listenerdestination") == 0) { enm = _broker->bft->enumerateInstanceNames(_broker, ctxLocal, ref, &st); while(enm && enm->ft->hasNext(enm, &st)) { CMReturnObjectPath(rslt, (enm->ft->getNext(enm, &st)).value.ref); } refLocal = CMNewObjectPath(_broker,"root/interop","cim_listenerdestinationcimxml",&st); enm = _broker->bft->enumerateInstanceNames(_broker, ctxLocal, refLocal, &st); while(enm && enm->ft->hasNext(enm, &st)) { CMReturnObjectPath(rslt, (enm->ft->getNext(enm, &st)).value.ref); } refLocal = CMNewObjectPath(_broker,"root/interop","cim_indicationhandlercimxml",&st); enm = _broker->bft->enumerateInstanceNames(_broker, ctxLocal, refLocal, &st); while(enm && enm->ft->hasNext(enm, &st)) { CMReturnObjectPath(rslt, (enm->ft->getNext(enm, &st)).value.ref); } CMRelease(refLocal); } else { enm = _broker->bft->enumerateInstanceNames(_broker, ctxLocal, ref, &st); while(enm && enm->ft->hasNext(enm, &st)) { CMReturnObjectPath(rslt, (enm->ft->getNext(enm, &st)).value.ref); } } #else enm = _broker->bft->enumerateInstanceNames(_broker, ctxLocal, ref, &st); while(enm && enm->ft->hasNext(enm, &st)) { CMReturnObjectPath(rslt, (enm->ft->getNext(enm, &st)).value.ref); } #endif CMRelease(ctxLocal); if(enm) CMRelease(enm); _SFCB_RETURN(st); }
CMPIObjectPath * get_assoc_targetClass_ObjectPath(const CMPIBroker * broker, const CMPIObjectPath * ref, const char *_RefLeftClass, const char *_RefRightClass, CMPIStatus *rc) { CMPIObjectPath *op = NULL; const char *targetName = NULL; /* * get name of the target class */ targetName = get_assoc_targetClass_Name(broker, ref, _RefLeftClass, _RefRightClass, rc); if (targetName != NULL) { /* * create new object path of the target class */ op = CMNewObjectPath(broker, CMGetCharsPtr(CMGetNameSpace(ref, rc), NULL), targetName, rc); } return op; }
CMPIInstance * _makeInst_ServiceProcess( const CMPIBroker * _broker, const CMPIObjectPath * service, CMPIObjectPath * process, CMPIStatus * rc) { CMPIObjectPath * op = NULL; CMPIInstance * ci = NULL; _OSBASE_TRACE(4,("--- _makeInst_ServiceProcess() called")); /* create CMPIObjectPath of this association <_ClassName> */ op = CMNewObjectPath( _broker, CMGetCharPtr(CMGetNameSpace(service,rc)), _ClassName, rc ); if( CMIsNullObject(op) ) { CMSetStatusWithChars( _broker, rc, CMPI_RC_ERR_FAILED, "Create CMPIObjectPath failed." ); goto exit; } ci = CMNewInstance( _broker, op, rc); if( CMIsNullObject(ci) ) { CMSetStatusWithChars( _broker, rc, CMPI_RC_ERR_FAILED, "Create CMPIInstance failed." ); _OSBASE_TRACE(4,("--- _makeInst_ServiceProcess() failed : %s",CMGetCharPtr(rc->msg))); goto exit; } CMSetProperty( ci, _RefLeft, (CMPIValue*)&(service), CMPI_ref ); CMSetProperty( ci, _RefRight, (CMPIValue*)&(process), CMPI_ref ); exit: _OSBASE_TRACE(4,("--- _makeInst_ServiceProcess() exited")); return ci; }
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); }
CMPIObjectPath * get_assoc_targetClass_ObjectPath(const CMPIBroker * broker, const CMPIObjectPath * ref, const char *_RefLeftClass, const char *_RefRightClass, CMPIStatus *rc) { CMPIObjectPath *op = NULL; const char *targetName = NULL; /* * get name of the target class */ targetName = get_assoc_targetClass_Name(broker, ref, _RefLeftClass, _RefRightClass, rc); if (targetName != NULL) { /* * create new object path of the target class */ op = CMNewObjectPath(broker, CMGetCharsPtr(CMGetNameSpace(ref, rc), NULL), targetName, rc); if (!op) CMSetStatusWithChars(_broker, rc, CMPI_RC_ERR_FAILED, "Create CMPIObjectPath failed in cmpiTestAssociationProvider"); } return op; }
int dqRetry(CMPIContext * ctx, RTElement * cur) { _SFCB_ENTER(TRACE_INDPROVIDER, "dqRetry"); // Delete the instance in the repo CMPIObjectPath * op=CMNewObjectPath(_broker,"root/interop","SFCB_IndicationElement",NULL); CMAddKey(op,"IndicationID",&cur->instanceID,CMPI_uint32); CBDeleteInstance(_broker,ctx,op); CBDeleteInstance(_broker,ctx,cur->ind); CMRelease(op); // Remove the entry from the queue, closing the hole if (cur->next == cur) { // queue is empty free(cur); RQhead = NULL; } else { // not last cur->prev->next = cur->next; cur->next->prev = cur->prev; CMRelease(cur->ref); CMRelease(cur->sub); if (cur) free(cur); } _SFCB_RETURN(0); }
CMPIObjectPath * _makePath_TestClass( const CMPIBroker * _broker, const CMPIContext * ctx, const CMPIObjectPath * ref, CMPIStatus * rc, unsigned int theKey) { CMPIObjectPath * op = NULL; op = CMNewObjectPath( _broker, CMGetCharsPtr(CMGetNameSpace(ref,rc), NULL), _ClassName, rc ); if (CMIsNullObject(op)) { CMSetStatusWithChars( _broker, rc, CMPI_RC_ERR_FAILED, "Create CMPIObjectPath failed." ); goto exit; } CMAddKey(op, "theKey", &theKey, CMPI_uint32); exit: return op; }
const char * get_assoc_targetClass_Name(const CMPIBroker * broker, const CMPIObjectPath * ref, const char *_RefLeftClass, const char *_RefRightClass, CMPIStatus *rc) { CMPIString *sourceClass = NULL; CMPIObjectPath *op = NULL; /* * get name of source class */ sourceClass = CMGetClassName(ref, rc); op = CMNewObjectPath(broker, CMGetCharsPtr(CMGetNameSpace(ref, rc), NULL), _RefLeftClass, rc); if (strcmp(CMGetCharsPtr(sourceClass, NULL), "CMPI_TEST_Person") == 0) { return "CMPI_TEST_Vehicle"; } else if (strcmp(CMGetCharsPtr(sourceClass, NULL), "CMPI_TEST_Vehicle") == 0) { return "CMPI_TEST_Person"; } else { return NULL; } }
CMPIStatus IndCIMXMLHandlerDeleteInstance(CMPIInstanceMI * mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath * cop) { CMPIStatus st = { CMPI_RC_OK, NULL }; CMPIArgs *in, *out = NULL; CMPIObjectPath *op; CMPIData rv; _SFCB_ENTER(TRACE_INDPROVIDER, "IndCIMXMLHandlerDeleteInstance"); if (interOpNameSpace(cop, &st) == 0) _SFCB_RETURN(st); internalProviderGetInstance(cop, &st); if (st.rc) _SFCB_RETURN(st); in = CMNewArgs(_broker, NULL); CMAddArg(in, "key", &cop, CMPI_ref); op = CMNewObjectPath(_broker, "root/interop", "cim_indicationsubscription", &st); rv = CBInvokeMethod(_broker, ctx, op, "_removeHandler", in, out, &st); if (st.rc == CMPI_RC_OK) { st = InternalProviderDeleteInstance(NULL, ctx, rslt, cop); } _SFCB_RETURN(st); }
static void generateIndication2(const char *methodname, const CMPIContext *ctx) { CMPIInstance *inst; CMPIObjectPath *cop; CMPIDateTime *dat; CMPIArray *ar; CMPIStatus rc; char buffer[32]; if (enabled && activated2) { cop = CMNewObjectPath(broker, "root/interop2", "Test_Indication", &rc); inst = CMNewInstance(broker, cop, &rc); sprintf(buffer, "%d", _nextUID++); CMSetProperty(inst, "IndicationIdentifier", buffer, CMPI_chars); dat = CMNewDateTime(broker, &rc); CMSetProperty(inst, "IndicationTime", &dat, CMPI_dateTime); CMSetProperty(inst, "MethodName", methodname, CMPI_chars); ar = CMNewArray(broker, 0, CMPI_string, &rc); CMSetProperty(inst, "CorrelatedIndications", &ar, CMPI_stringA); rc = CBDeliverIndication(broker, ctx, "root/interop", inst); if (rc.rc != CMPI_RC_OK) { fprintf(stderr, "+++ Could not send the indication!\n"); } gen2++; } fprintf(stderr, "+++ generateIndication2() done %d\n", gen2); }
CMPIStatus TestCMPIAssociationProviderAssociatorNames( CMPIAssociationMI* mi, const CMPIContext* ctx, const CMPIResult* rslt, const CMPIObjectPath* ref, const char* _RefLeftClass, const char* _RefRightClass, const char* role, const char* resultRole) { CMPIObjectPath* op = NULL; CMPIObjectPath* rop = NULL; CMPIEnumeration* en = NULL; CMPIData data ; CMPIStatus rc = { CMPI_RC_OK, NULL }; PROV_LOG_OPEN (_ClassName, _ProviderLocation); PROV_LOG ("\n\n********************* %s CMPI AssociatorNames() called", _ClassName); /* get object path of the target class */ op = get_assoc_targetClass_ObjectPath( _broker, ref, _RefLeftClass, _RefRightClass, &rc); PROV_LOG (" New Object Path [%s]", CMGetCharsPtr (CMGetNameSpace (ref, &rc),NULL)); /* create new object path of association */ rop = CMNewObjectPath( _broker, CMGetCharsPtr(CMGetNameSpace(ref,&rc),NULL), _ClassName, &rc ); /* upcall to CIMOM; call enumInstanceNames() of the target class */ en = CBEnumInstanceNames( _broker, ctx, op, &rc); /* as long as object path entries are found in the enumeration */ while( CMHasNext( en, &rc) ) { /* get the object path */ data = CMGetNext(en, &rc); /* and return the target class object path as result of the * associatorNames() call */ CMReturnObjectPath( rslt, data.value.ref ); } PROV_LOG ("\n\n********************* %s CMPI AssociatorNames() exited", _ClassName); PROV_LOG_CLOSE (); return rc; }
CMPIObjectPath *RegisteredProfileCreateObjectPath( const char *ns, const char *name, CMPIStatus *status) { CMPIObjectPath *cop; char buf[256]; _SMI_TRACE(1,("RegisteredProfileCreateObjectPath() called")); if (strcasecmp(name, VolumeManagementName) == 0 || strcasecmp(name, ArrayName) == 0 || strcasecmp(name, ServerName) == 0) { cop = CMNewObjectPath( _BROKER, ns, RegisteredProfileName, status); } else { cop = CMNewObjectPath( _BROKER, ns, RegisteredSubProfileName, status); } if ((status->rc != CMPI_RC_OK) || CMIsNullObject(cop)) { _SMI_TRACE(1,("RegisteredProfileCreateObjectPath(): CMNewObjectPath() failed - %s", CMGetCharPtr(status->msg))); CMSetStatusWithChars(_BROKER, status, CMPI_RC_ERROR_SYSTEM, "Cannot create new objectpath"); goto exit; } CMAddKey(cop, InstanceIDName, cmpiutilMakeInstanceID(name, buf, 256), CMPI_chars); /* *buf = 0; strncat(buf, "SNIA:", 256); strncat(buf, name , 256); CMAddKey(cop, "InstanceID", buf , CMPI_chars); */ exit: _SMI_TRACE(1,("RegisteredProfileCreateObjectPath() done")); return cop; }
CMPIObjectPath * make_ObjectPath(const CMPIBroker * broker, const char *ns, const char *className) { CMPIObjectPath *objPath = NULL; CMPIStatus rc = { CMPI_RC_OK, NULL }; objPath = CMNewObjectPath(broker, ns, className, &rc); CMAddKey(objPath, "ElementName", (CMPIValue *) className, CMPI_chars); return objPath; }
int enqRetry(RTElement * element, const CMPIContext * ctx, int repo) { _SFCB_ENTER(TRACE_INDPROVIDER, "enqRetry"); // Put this one on the retry queue if (pthread_mutex_lock(&RQlock) != 0) { // lock failed return 1; } if (RQhead == NULL) { // Queue is empty _SFCB_TRACE(1,("--- Adding indication to new retry queue.")); RQhead = element; RQtail = element; RQtail->next = element; RQtail->prev = element; } else { _SFCB_TRACE(1,("--- Adding indication to retry queue.")); element->next = RQtail->next; element->next->prev = element; RQtail->next = element; element->prev = RQtail; RQtail = element; } if (repo==1) { // If this needs to be persisted in the repo // (not the initial fill from refillRetryQ) _SFCB_TRACE(1,("--- Creating SFCB_IndicationElement instance.")); CMPIObjectPath * op=CMNewObjectPath(_broker,"root/interop","SFCB_IndicationElement",NULL); // Add the indID as the only key CMAddKey(op,"IndicationID",&element->instanceID,CMPI_uint32); // Create the instance //element->SFCBIndEle=op; element->SFCBIndEle=op->ft->clone(op,NULL); CMPIInstance * ci=CMNewInstance(_broker,op,NULL); // Set all the properties CMSetProperty(ci,"IndicationID",&element->instanceID,CMPI_uint32); CMSetProperty(ci,"RetryCount",&(RQtail->count),CMPI_uint32); CMSetProperty(ci,"LastDelivery",&(RQtail->lasttry),CMPI_sint32); CMSetProperty(ci,"ld",&(element->ref),CMPI_ref); CMSetProperty(ci,"ind",&element->ind,CMPI_ref); CMSetProperty(ci,"sub",&element->sub,CMPI_ref); CBCreateInstance(_broker, ctx, op, ci, NULL); CMRelease(op); CMRelease(ci); } if (pthread_mutex_unlock(&RQlock) != 0) { // lock failed return 1; } _SFCB_RETURN(0); }
static void loopOnChildNames(ClassRegister *cReg, char *cn, CMPIResult * rslt) { CMPIObjectPath *op; UtilList *ul = getChildren(cReg,cn); char *child; if (ul) for (child = (char *) ul->ft->getFirst(ul); child; child = (char *) ul->ft->getNext(ul)) { op=CMNewObjectPath(_broker,NULL,child,NULL); CMReturnObjectPath(rslt,op); loopOnChildNames(cReg,child,rslt); } }
CMPIObjectPath* KBase_ToObjectPath( const KBase* self, CMPIStatus* st) { KPos pos; CMPIObjectPath* cop; /* Check parameters */ if (self->magic != KMAGIC) { KSetStatus(st, ERR_FAILED); return NULL; } /* Create object path */ KFirst(&pos, self); if (!(cop = CMNewObjectPath(self->cb, KChars(self->ns), pos.classname, st))) { return NULL; } /* Set keys */ while (KMore(&pos)) { CMPIData cd; const KValue* value = (const KValue*)pos.field; if (value->exists && (pos.tag & KTAG_KEY)) { CMPIStatus st; cd = _data(value, pos.tag); if (value->null) st = CMAddKey(cop, pos.name, NULL, cd.type); else st = CMAddKey(cop, pos.name, &cd.value, cd.type); if (!KOkay(st)) { /* ATTN: log this but do not return! */ } } KNext(&pos); } return cop; }
void ElementCapabilitiesInitInstances(const CMPIContext *ctx) { CMPIObjectPath *op = NULL, *opLeft = NULL, *opRight = NULL, *left = NULL, *right = NULL; CMPIValue val; CMPIEnumeration *enm = NULL; CMPIInstance *ci = NULL; CMPIContext *ctxLocal; ctxLocal = native_clone_CMPIContext(ctx); val.string = sfcb_native_new_CMPIString("$DefaultProvider$", NULL, 0); ctxLocal->ft->addEntry(ctxLocal, "rerouteToProvider", &val, CMPI_string); op = CMNewObjectPath(_broker, "root/interop", "SFCB_ElementCapabilities", NULL); ci = CMNewInstance(_broker, op, NULL); opLeft = CMNewObjectPath(_broker, "root/interop", "CIM_IndicationService", NULL); enm = CBEnumInstanceNames(_broker, ctx, opLeft, NULL); left = CMGetNext(enm, NULL).value.ref; opRight = CMNewObjectPath(_broker, "root/interop", "SFCB_IndicationServiceCapabilities", NULL); enm = CBEnumInstanceNames(_broker, ctx, opRight, NULL); right = CMGetNext(enm, NULL).value.ref; CMAddKey(op, "ManagedElement", &left, CMPI_ref); CMAddKey(op, "Capabilities", &right, CMPI_ref); CMSetProperty(ci, "ManagedElement", &left, CMPI_ref); CMSetProperty(ci, "Capabilities", &right, CMPI_ref); CBCreateInstance(_broker, ctxLocal, op, ci, NULL); CMRelease(ctxLocal); return; }
CMPIObjectPath * make_ObjectPath (const CMPIBroker *broker, const char *ns, const char *clss) { CMPIObjectPath *objPath = NULL; CMPIStatus rc = { CMPI_RC_OK, NULL }; PROV_LOG ("--- make_ObjectPath: CMNewObjectPath"); objPath = CMNewObjectPath (broker, ns, clss, &rc); PROV_LOG ("----- %s", strCMPIStatus (rc)); return objPath; }
CMPIObjectPath *SoftwareIdentityCreateObjectPath( const char *ns, const char *name, CMPIStatus *status) { CMPIObjectPath *cop; char buf[256]; _SMI_TRACE(1,("SoftwareIdentityCreateObjectPath() called")); if (strcasecmp(name, SMIArrayName) == 0) { cop = CMNewObjectPath( _BROKER, ns, ArraySoftwareName, status); } else if (strcasecmp(name, SMIVolumeManagementName) == 0) { cop = CMNewObjectPath( _BROKER, ns, VolumeManagementSoftwareName, status); } if ((status->rc != CMPI_RC_OK) || CMIsNullObject(cop)) { _SMI_TRACE(1,("SoftwareIdentityCreateObjectPath(): CMNewObjectPath() failed - %s", CMGetCharPtr(status->msg))); CMSetStatusWithChars(_BROKER, status, CMPI_RC_ERROR_SYSTEM, "Cannot create new objectpath"); goto exit; } CMAddKey(cop, InstanceIDName, cmpiutilMakeInstanceID(name, buf, 256), CMPI_chars); exit: _SMI_TRACE(1,("SoftwareIdentityCreateObjectPath() done")); return cop; }
int refillRetryQ (const CMPIContext * ctx) { _SFCB_ENTER(TRACE_INDPROVIDER, "refillRetryQ"); int qfill=0; if (RQhead==NULL) { // The queue is empty, check if there are instances to be restored CMPIObjectPath * op=CMNewObjectPath(_broker,"root/interop","SFCB_IndicationElement",NULL); CMPIEnumeration * enm = _broker->bft->enumerateInstances(_broker, ctx, op, NULL, NULL); while(enm && enm->ft->hasNext(enm, NULL)) { // get the properties from the repo instance CMPIData inst=CMGetNext(enm,NULL); CMPIData indID=CMGetProperty(inst.value.inst,"indicationID",NULL); CMPIData rcount=CMGetProperty(inst.value.inst,"retryCount",NULL); CMPIData last=CMGetProperty(inst.value.inst,"lastDelivery",NULL); CMPIData ind=CMGetProperty(inst.value.inst,"ind",NULL); CMPIData sub=CMGetProperty(inst.value.inst,"sub",NULL); CMPIData ld=CMGetProperty(inst.value.inst,"ld",NULL); _SFCB_TRACE(1,("--- Requeueing indication id:%d",indID.value.Int)); // Rebuild the queue element RTElement *element; element = (RTElement *) malloc(sizeof(*element)); element->instanceID=indID.value.Int; element->lasttry=last.value.Int; element->count=rcount.value.Int; element->ind=ind.value.ref->ft->clone(ind.value.ref,NULL); element->ref=ld.value.ref->ft->clone(ld.value.ref,NULL); element->sub=sub.value.ref->ft->clone(sub.value.ref,NULL); CMPIObjectPath * indele=CMGetObjectPath(inst.value.inst,NULL); element->SFCBIndEle=indele->ft->clone(indele,NULL); // call enq enqRetry(element,ctx,0); qfill=1; } // spawn thread if we queued anything if ((qfill == 1 ) && (retryRunning == 0)) { retryRunning=1; _SFCB_TRACE(1,("--- Starting retryExport thread")); pthread_attr_init(&tattr); pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED); CMPIContext * pctx = native_clone_CMPIContext(ctx); pthread_create(&t, &tattr,&retryExport,(void *) pctx); } } _SFCB_RETURN(0); }
CMPIInstance *makeInstance(const CMPIBroker *broker, const char * classname, const char * Namespace, CWS_FILE *cwsf) { CMPIInstance *in = NULL; CMPIValue val; CMPIObjectPath *op = CMNewObjectPath(broker, (char*)Namespace, (char*)classname, NULL); CMSetHostname(op,CSName()); if (!CMIsNullObject(op)) { in = CMNewInstance(broker,op,NULL); if (!CMIsNullObject(in)) { CMSetProperty(in,"CSCreationClassName",CSCreationClassName(),CMPI_chars); CMSetProperty(in,"CSName",CSName(),CMPI_chars); CMSetProperty(in,"FSCreationClassName",FSCreationClassName(),CMPI_chars); CMSetProperty(in,"FSName",FSName(),CMPI_chars); CMSetProperty(in,"CreationClassName",classname,CMPI_chars); CMSetProperty(in,"Name",cwsf->cws_name,CMPI_chars); CMSetProperty(in,"FileSize",(CMPIValue*)&cwsf->cws_size,CMPI_uint64); #ifndef SIMULATED /* We don't want this code in the simulated env - time is dynamic (diff timezones) and the testing system might using a diff timezone and report failure */ val.uint64 = cwsf->cws_ctime; val.dateTime = CMNewDateTimeFromBinary(broker,val.uint64*1000000,0,NULL); CMSetProperty(in,"CreationDate",&val,CMPI_dateTime); val.uint64 = cwsf->cws_mtime; val.dateTime = CMNewDateTimeFromBinary(broker,val.uint64*1000000,0,NULL); CMSetProperty(in,"LastModified",&val,CMPI_dateTime); val.uint64 = cwsf->cws_atime; val.dateTime = CMNewDateTimeFromBinary(broker,val.uint64*1000000,0,NULL); CMSetProperty(in,"LastAccessed",&val,CMPI_dateTime); #endif val.uint64=0L; val.boolean=(cwsf->cws_mode & 0400) != 0; CMSetProperty(in,"Readable",&val,CMPI_boolean); val.boolean=(cwsf->cws_mode & 0200) != 0; CMSetProperty(in,"Writeable",&val,CMPI_boolean); val.boolean=(cwsf->cws_mode & 0100) != 0; CMSetProperty(in,"Executable",&val,CMPI_boolean); } } return in; }
CMPIObjectPath * _makePath_TestClassA( const CMPIBroker * _broker, const CMPIContext * ctx, const CMPIObjectPath * cop) { CMPIObjectPath * op = NULL; CMPIValue theKey; theKey.uint32 = 2; op=CMNewObjectPath( _broker, CMGetCharsPtr(CMGetNameSpace(cop,NULL), NULL), _ClassName, NULL); CMAddKey(op, "theKey", &theKey, CMPI_uint32); return op; }
CMPIObjectPath *makePath( const CMPIBroker *broker, const char * classname, const char * Namespace, CWS_FILE *cwsf) { CMPIObjectPath *op; op = CMNewObjectPath(broker, (char*)Namespace, (char*)classname, NULL); CMSetHostname(op,CSName()); if (!CMIsNullObject(op)) { CMAddKey(op,"CSCreationClassName",CSCreationClassName(),CMPI_chars); CMAddKey(op,"CSName",CSName(),CMPI_chars); CMAddKey(op,"FSCreationClassName",FSCreationClassName(),CMPI_chars); CMAddKey(op,"FSName",FSName(),CMPI_chars); CMAddKey(op,"CreationClassName",classname,CMPI_chars); CMAddKey(op,"Name",cwsf->cws_name,CMPI_chars); } return op; }
CMPIObjectPath *kvp_rasd_create_ref( const CMPIBroker *broker, const char *name_space, xen_utils_session *session, xen_vm_record *vm_rec, kvp *kvp_rec ) { char inst_id[MAX_INSTANCEID_LEN]; CMPIObjectPath *result_setting = NULL; result_setting = CMNewObjectPath(broker, name_space, "Xen_KVPSettingData", NULL); if (result_setting) { _CMPICreateNewDeviceInstanceID(inst_id, MAX_INSTANCEID_LEN, kvp_rec->vm_uuid, kvp_rec->key); CMAddKey(result_setting, "InstanceID", (CMPIValue *)inst_id, CMPI_chars); } return result_setting; }
CMPIObjectPath * _makePath_Service( const CMPIBroker * _broker, const CMPIContext * ctx, const CMPIObjectPath * ref, LXS_Service * lxssvc, CMPIStatus * rc) { CMPIObjectPath * op = NULL; _OSBASE_TRACE(2,("--- _makePath_Service() called")); /* the sblim-cmpi-base package offers some tool methods to get common * system data */ if( !get_system_name() ) { CMSetStatusWithChars( _broker, rc, CMPI_RC_ERR_FAILED, "no host name found" ); _OSBASE_TRACE(2,("--- _makePath_Service() failed : %s",CMGetCharPtr(rc->msg))); goto exit; } op = CMNewObjectPath( _broker, CMGetCharPtr(CMGetNameSpace(ref,rc)), _ClassName, rc ); if( CMIsNullObject(op) ) { CMSetStatusWithChars( _broker, rc, CMPI_RC_ERR_FAILED, "Create CMPIObjectPath failed." ); _OSBASE_TRACE(2,("--- _makePath_Service() failed : %s",CMGetCharPtr(rc->msg))); goto exit; } CMAddKey(op, "SystemCreationClassName", CSCreationClassName, CMPI_chars); CMAddKey(op, "SystemName", get_system_name(), CMPI_chars); CMAddKey(op, "CreationClassName", _ClassName, CMPI_chars); CMAddKey(op, "Name", lxssvc->svName, CMPI_chars); exit: _OSBASE_TRACE(2,("--- _makePath_Service() exited")); return op; }
// To increase the coverage in CMPIBrokerEnc.cpp static int _testBrokerEnc (const CMPIContext * ctx, const CMPIResult * rslt) { int flag = 1 ; int count; char* msgId; char* illegal; char path[100]; void* hdl; CMPIStatus rc = { CMPI_RC_OK, NULL }; CMPIString *type; CMPIString *cmpiStr; CMPIBoolean bol=0; CMPIBoolean bool=0; CMPIArray* cmpiArray = NULL ; CMPIInstance* instance = NULL; CMPIInstance* instance1 = NULL; CMPIInstance* instanceErr = NULL; CMPIObjectPath* objPath = NULL; CMPIObjectPath* objPath1 = NULL; CMPICount cmpiCnt = 5; CMPIType cmpiType = CMPI_uint64; CMPIDateTime* cmpiDateTime = NULL ; CMPIMsgFileHandle msgFileHandle; CMPIEnumeration* cmpiEnum; CMPISelectExp* selExp; CMPIValue val; CMPIError* err; CMPIStatus* rc1 = NULL; CMPIArgs* args = NULL; void* handle; CMPIInstanceFT* funcTable; PROV_LOG ("++++ _testBrokerEnc "); PROV_LOG ("++++ ObjectPath testing"); objPath1 = CMNewObjectPath (_broker, NULL, _ClassName, &rc); PROV_LOG ("++++ New object path with NULL namespace creation : (%s)", strCMPIStatus (rc)); CMRelease(objPath1); objPath1 = CMNewObjectPath (_broker, _Namespace, "abc", &rc); PROV_LOG ("++++ New object path with wrong classname : (%s)", strCMPIStatus (rc)); instance = CMNewInstance(_broker, NULL, &rc); PROV_LOG ("++++ New Instance with NULL object path : (%s)", strCMPIStatus (rc)); handle = objPath1->hdl; objPath1->hdl=NULL; instance = CMNewInstance(_broker, objPath1, &rc); PROV_LOG ("++++ New Instance with object path handle set to NULL: (%s)", strCMPIStatus (rc)); objPath1->hdl = handle; objPath = make_ObjectPath(_broker, _Namespace, _ClassName); instance = CMNewInstance(_broker, objPath, &rc); PROV_LOG ("++++ New Instance creation status: (%s)", strCMPIStatus (rc)); instance1 = CMClone(instance, &rc); instanceErr = CMClone(instance, &rc); cmpiStr = CMNewString(_broker, NULL, &rc); PROV_LOG ("++++ Status of mbNewString with NULL parameter:(%s)", strCMPIStatus (rc)); err = CMNewCMPIError(_broker, "abc", "abc", "abc", 4, 5, 6, rc1); if (err) { PROV_LOG ("++++ CMNewCMPIError called with null rc"); } cmpiDateTime = CMNewDateTimeFromChars(_broker, "datetime", &rc); PROV_LOG ("++++ Status of CMNewDateTimeFromChars with junk parameter:(%s)", strCMPIStatus (rc)); if (!CMClassPathIsA(_broker, NULL, NULL, &rc)) { PROV_LOG ("++++ Error Status of CMClassPathIsA:(%s)", strCMPIStatus (rc)); } if (!CMClassPathIsA(_broker, objPath, NULL, &rc)) { PROV_LOG ("++++ Error Status of CMClassPathIsA:(%s)", strCMPIStatus (rc)); } illegal = "$"; if (!CMClassPathIsA(_broker, objPath, illegal, &rc)) { PROV_LOG ("++++ Error Status of CMClassPathIsA:(%s)", strCMPIStatus (rc)); } rc = CMLogMessage(_broker, 2, "TestProvider", "Testing Severity 2 in TestCMPIBrokerEnc", NULL); PROV_LOG ("++++ Status of CMLogMessage with Severity 2:(%s)", strCMPIStatus (rc)); rc = CMLogMessage(_broker, 3, "TestProvider", "Testing Severity 3 in TestCMPIBrokerEnc", NULL); PROV_LOG ("++++ Status of CMLogMessage with Severity 3:(%s)", strCMPIStatus (rc)); rc = CMLogMessage(_broker, 4, "TestProvider", "Testing Severity 4 in TestCMPIBrokerEnc", NULL); PROV_LOG ("++++ Status of CMLogMessage with Severity 4:(%s)", strCMPIStatus (rc)); rc = CMTraceMessage(_broker, 2, "CMPIProvider", "Tracing for level 2", NULL); PROV_LOG ("++++ Status of CMTraceMessage with level 2:(%s)", strCMPIStatus (rc)); rc = CMTraceMessage(_broker, 3, "CMPIProvider", "Tracing for level 3", NULL); PROV_LOG ("++++ Status of CMTraceMessage with level 3:(%s)", strCMPIStatus (rc)); rc = CMTraceMessage(_broker, 4, "CMPIProvider", "Tracing for level 4", NULL); PROV_LOG ("++++ Status of CMTraceMessage with level 4:(%s)", strCMPIStatus (rc)); cmpiStr = CMNewString(_broker, "Tracing for level 5", &rc); rc = CMTraceMessage(_broker, 5, "CMPIProvider", NULL, cmpiStr); PROV_LOG ("++++ Status of CMTraceMessage with level 5:(%s)", strCMPIStatus (rc)); CMRelease(cmpiStr); PROV_LOG ("++++ Calling mbEncToString function "); type = CDToString (_broker, _broker, &rc); PROV_LOG ("++++ Error status of mbEncToString with wrong object path:" " (%s)", strCMPIStatus (rc)); type = CDToString (_broker, NULL, &rc); PROV_LOG ("++++ Error status of mbEncToString with NULL parameter:" " (%s)", strCMPIStatus (rc)); type = CDToString (_broker, type, &rc); PROV_LOG ("++++ Passing CMPIString to mbEncToString successes : (%s)", strCMPIStatus (rc)); type = CDToString (_broker, objPath, &rc); PROV_LOG ("++++ Passing CMPIObjectPath to mbEncToString successes : (%s)", strCMPIStatus (rc)); handle = objPath1->hdl; objPath1->hdl = NULL; type = CDToString (_broker, objPath1, &rc); if ( rc.rc == CMPI_RC_ERR_INVALID_PARAMETER) { PROV_LOG ("++++ Error status of mbEncToString with object path with " "NULL handle: (%s)", strCMPIStatus (rc)); } objPath1->hdl = handle; val.boolean = 1; rc = CMSetProperty (instance, "Boolean", &val, CMPI_boolean); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_boolean : (%s)", strCMPIStatus (rc)); val.uint8 = 8; rc = CMSetProperty (instance, "Uint8", &val, CMPI_uint8); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_uint8 : (%s)", strCMPIStatus (rc)); val.uint16 = 16; rc = CMSetProperty (instance, "Uint16", &val, CMPI_uint16); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_uint16 : (%s)", strCMPIStatus (rc)); val.uint32 = 32; rc = CMSetProperty (instance, "Uint32", &val, CMPI_uint32); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_uint32 : (%s)", strCMPIStatus (rc)); val.uint64 = 64; rc = CMSetProperty (instance, "Uint64", &val, CMPI_uint64); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_uint64 : (%s)", strCMPIStatus (rc)); val.sint8 = -8; rc = CMSetProperty (instance, "Sint8", &val, CMPI_sint8); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_sint8 : (%s)", strCMPIStatus (rc)); val.sint16 = -16; rc = CMSetProperty (instance, "Sint16", &val, CMPI_sint16); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_sint16 : (%s)", strCMPIStatus (rc)); val.sint32 = -32; rc = CMSetProperty (instance, "Sint32", &val, CMPI_sint32); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_sint32 : (%s)", strCMPIStatus (rc)); val.sint64 = -64; rc = CMSetProperty (instance, "Sint64", &val, CMPI_sint64); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_sint64 : (%s)", strCMPIStatus (rc)); val.real32 = 32.32; rc = CMSetProperty (instance, "Real32", &val, CMPI_real32); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_real32 : (%s)", strCMPIStatus (rc)); val.real64 = 64.64; rc = CMSetProperty (instance, "Real64", &val, CMPI_real64); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_real64 : (%s)", strCMPIStatus (rc)); val.char16 = 'c'; rc = CMSetProperty (instance, "Char16", &val, CMPI_char16); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_char16 : (%s)", strCMPIStatus (rc)); cmpiDateTime = CMNewDateTime (_broker, &rc); val.dateTime = cmpiDateTime; rc = CMSetProperty (instance, "DateTime", &val, CMPI_dateTime); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_dateTime : (%s)", strCMPIStatus (rc)); val.ref = objPath; rc = CMSetProperty (instance, "Ref", &val, CMPI_ref); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_ref : (%s)", strCMPIStatus (rc)); val.inst = instance1; rc = CMSetProperty (instance, "Instance", &val, CMPI_instance); PROV_LOG ("++++ Status of CMSetProperty of type CMPI_instance : (%s)", strCMPIStatus (rc)); type = CDToString (_broker, instance, &rc); PROV_LOG ("++++ Passing CMPIInstance to mbEncToString successes : (%s)", strCMPIStatus (rc)); args = CMNewArgs(_broker, &rc); PROV_LOG ("++++ Status of CMNewArgs : (%s)", strCMPIStatus (rc)); type = CDToString (_broker, args, &rc); PROV_LOG ("++++ Passing CMPIArgs to mbEncToString successes : (%s)", strCMPIStatus (rc)); PROV_LOG ("++++ Calling mbEncGetType function "); rc1 = NULL; type = CDGetType (_broker, NULL, rc1); if (!type) { PROV_LOG ("++++ Error calling mbEncGetType with NULL rc"); } rc1 = NULL; funcTable = instanceErr->ft; instanceErr->ft = NULL; type = CDGetType (_broker, instanceErr, rc1); if (!type) { PROV_LOG ("++++ Error calling mbEncGetType with wrong parameter and" " NULL rc"); } type = CDGetType (_broker, instanceErr, &rc); PROV_LOG ("++++ Error status of mbEncGetType with wrong input : (%s)", strCMPIStatus (rc)); instanceErr->ft = funcTable; type = CDGetType (_broker, NULL, &rc); PROV_LOG ("++++ Error status of mbEncGetType with NULL input : (%s)", strCMPIStatus (rc)); type = CDGetType (_broker, instance, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIInstance" " : (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CDGetType (_broker, objPath, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIObjectPath:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); cmpiStr = CMNewString(_broker, "Test1", & rc); type = CDGetType (_broker, cmpiStr, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIString:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CDGetType (_broker, _broker, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIBroker:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); cmpiArray = CMNewArray(_broker, cmpiCnt,cmpiType, &rc); type = CDGetType (_broker, cmpiArray, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIArray:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CDGetType (_broker, cmpiDateTime, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIDateTime:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CDGetType (_broker, ctx, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIContext:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CDGetType (_broker, rslt, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIResult:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); rc1 = NULL; selExp = CMNewSelectExp(_broker, "SELECT c,b FROM TestCMPI_Indication WHERE c='c' OR b=1", "WQL", NULL, rc1); PROV_LOG ("++++ CMNewSelectExp with rc set to NULL Called"); selExp = CMNewSelectExp(_broker, "SELECT c,b FROM TestCMPI_Indication", "WQL", NULL, &rc); PROV_LOG ("++++ Status of CMNewSelectExp: (%s) ", strCMPIStatus (rc)); type = CDGetType (_broker, selExp, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPISelectExp:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); handle = objPath1->hdl; objPath1->hdl = NULL; rc = CMRelease(objPath1); PROV_LOG ("++++ Status of CMRelease(objPath1): (%s)", strCMPIStatus (rc)); objPath1->hdl = handle; rc = CMRelease(objPath1); PROV_LOG ("++++ Status of CMRelease(objPath1): (%s)", strCMPIStatus (rc)); objPath1 = CMNewObjectPath(_broker, "test/TestProvider", "TestCMPI_Instance", &rc); PROV_LOG ("++++ Status of CMNewObjectPath for TestCMPI_Instance : (%s)", strCMPIStatus (rc)); PROV_LOG_CLOSE(); cmpiEnum = CBEnumInstances(_broker, ctx, objPath1, NULL, &rc); PROV_LOG_OPEN (_ClassName, _ProviderLocation); PROV_LOG ("++++ Status of CBEnumInstances : (%s)", strCMPIStatus (rc)); type = CDGetType (_broker, cmpiEnum, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIEnumeration:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CDGetType (_broker, args, &rc); PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIArgs:" " (%s) type(%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); PROV_LOG ("++++ Calling mbEncIsOfType function "); bol = CDIsOfType (_broker, NULL, "No object", rc1); if(!bol) { PROV_LOG ("++++Calling mbEncIsOfType with NULL rc and wrong" " parameters"); } bol = CDIsOfType (_broker, instance, "CMPIInstance", rc1); if(!bol) { PROV_LOG ("++++ Calling mbEncIsOfType with NULL rc"); } bol = CDIsOfType (_broker, NULL, "No object", &rc); PROV_LOG ("++++ Error Status of mbEncIsOfType : (%s)", strCMPIStatus (rc)); bol = CDIsOfType (_broker, instance, "CMPIInstance", &rc); if ( bol ) { PROV_LOG ("++++ CDIsOfType for CMPIInstance status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, instance, "CMPI", &rc); if ( !bol ) { PROV_LOG ("++++ CDIsOfType for CMPIInstance status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, objPath, "CMPIObjectPath", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIObjectPath status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, objPath, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPIObjectPath status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, cmpiDateTime, "CMPIDateTime", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIDateTime status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, cmpiDateTime, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPIDateTime status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, cmpiStr, "CMPIString", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIString status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, cmpiStr, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPIString status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, _broker, "CMPIBroker", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIBroker status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, _broker, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPIBroker status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, cmpiArray, "CMPIArray", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIArray status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, cmpiArray, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPIArray status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, rslt, "CMPIResult", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIResult status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, rslt, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPIResult status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, ctx, "CMPIContext", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIContext status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, ctx, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPIContext status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, cmpiEnum, "CMPIEnumeration", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIEnumeration status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, cmpiEnum, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPIEnumeration status is (%s) : %d", strCMPIStatus (rc), bol); } /* Testcase to increase coverage in CMPI_Enumeration.cpp*/ rc = CMRelease(cmpiEnum); PROV_LOG ("++++ Status of CMRelease on cmpiEnum :(%s)", strCMPIStatus (rc)); /**********************************************************/ bol = CDIsOfType (_broker, selExp, "CMPISelectExp", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPISelectExp status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, selExp, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CDIsOfType for CMPISelectExp status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, args, "CMPIArgs", &rc); if (bol) { PROV_LOG ("++++ CDIsOfType for CMPIArgs status is (%s) : %d", strCMPIStatus (rc), bol); } bol = CDIsOfType (_broker, args, "CMPI", &rc); if (!bol) { PROV_LOG ("++++ CdIsOfType for CMPIArgs status is (%s) : %d", strCMPIStatus (rc), bol); } type = CMGetMessage (_broker, "msgid", "Test 0 arguments", &rc, 0); PROV_LOG ("++++ Status of GetMessage with 0 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0", &rc, CMFmtArgs1(CMFmtChars("one argument"))); PROV_LOG ("++++ Status of GetMessage with 1 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0 $1", &rc, CMFmtArgs2(CMFmtChars("Sint32 ::"), CMFmtSint(-1))); PROV_LOG ("++++ Status of GetMessage with 2 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0 $1, $2", &rc, CMFmtArgs3(CMFmtChars("Sint32, Uint32 ::"), CMFmtSint(-1), CMFmtUint(1))); PROV_LOG ("++++ Status of GetMessage with 3 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0 $1, $2, $3", &rc, CMFmtArgs4(CMFmtChars("Sint32, Uint32, Sint64 ::"), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64))); PROV_LOG ("++++ Status of GetMessage with 4 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0 $1, $2, $3, $4", &rc, CMFmtArgs5(CMFmtChars("Sint32, Uint32, Sint64, Uint64 ::"), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64))); PROV_LOG ("++++ Status of GetMessage with 5 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0 $1, $2, $3, $4, $5", &rc, CMFmtArgs6(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64 ::"), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64), CMFmtReal(64.64))); PROV_LOG ("++++ Status of GetMessage with 6 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0 $1, $2, $3, $4, $5, $6", &rc, CMFmtArgs7(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64," " Boolean:: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64), CMFmtReal(64.64), CMFmtBoolean(1))); PROV_LOG ("++++ Status of GetMessage with 7 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0 $1, $2, $3, $4, $5, $6, $7", &rc, CMFmtArgs8(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64," " Boolean, chars:: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64), CMFmtReal(64.64), CMFmtBoolean(1), CMFmtChars("chars"))); PROV_LOG ("++++ Status of GetMessage with 8 arguments(%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage (_broker, "msgid", "Test $0 $1, $2, $3, $4, $5, $6, $7, $8", &rc, CMFmtArgs9(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64," " Boolean, chars, String :: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64), CMFmtReal(64.64), CMFmtBoolean(1), CMFmtChars("chars"), CMFmtString(cmpiStr))); PROV_LOG ("++++ Status of GetMessage with 9 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); strcpy(path,"path"); rc = CMOpenMessageFile(_broker, path, &msgFileHandle); PROV_LOG ("++++ Status of CMOpenMessageFile (%s) ", strCMPIStatus (rc)); type = CMGetMessage2(_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test zero arguments", &rc, 0); PROV_LOG ("++++ Status of GetMessage2 with 0 argument (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2(_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0", &rc, CMFmtArgs1(CMFmtChars("Single argument"))); PROV_LOG ("++++ Status of GetMessage2 with 1 argument (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2(_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0 $1", &rc, CMFmtArgs2(CMFmtChars("Sint32 ::"),CMFmtSint(1))); PROV_LOG ("++++ Status of GetMessage2 with 2 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2 (_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0 $1, $2", &rc, CMFmtArgs3(CMFmtChars("Sint32, Uint32 :: "), CMFmtSint(-1), CMFmtUint(1))); PROV_LOG ("++++ Status of GetMessage2 with 3 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2 (_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0 $1, $2, $3", &rc, CMFmtArgs4(CMFmtChars("Sint32, Uint32, Sint64 :: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64))); PROV_LOG ("++++ Status of GetMessage2 with 4 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2 (_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0 $1, $2, $3, $4", &rc, CMFmtArgs5(CMFmtChars("Sint32, Uint32, Sint64, Uint64 :: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64))); PROV_LOG ("++++ Status of GetMessage2 with 5 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2 (_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0 $1, $2, $3, $4, $5", &rc, CMFmtArgs6(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64 :: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64), CMFmtReal(64.64))); PROV_LOG ("++++ Status of GetMessage2 with 6 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2 (_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0 $1, $2, $3, $4, $5, $6", &rc, CMFmtArgs7(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64," " Boolean :: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64), CMFmtReal(64.64), CMFmtBoolean(1))); PROV_LOG ("++++ Status of GetMessage2 with 7 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2 (_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0 $1, $2, $3, $4, $5, $6, $7", &rc, CMFmtArgs8(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64," " Boolean, chars :: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64), CMFmtReal(64.64), CMFmtBoolean(1), CMFmtChars("chars"))); PROV_LOG ("++++ Status of GetMessage2 with 8 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); type = CMGetMessage2 (_broker, "Common.CIMStatusCode.CIM_ERR_SUCCESS", msgFileHandle, "Test $0 $1, $2, $3, $4, $5, $6, $7, $8", &rc, CMFmtArgs9(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64," " Boolean, chars, String :: "), CMFmtSint(-1), CMFmtUint(1), CMFmtSint64(-64), CMFmtUint64(64), CMFmtReal(64.64), CMFmtBoolean(1), CMFmtChars("chars"), CMFmtString(cmpiStr))); PROV_LOG ("++++ Status of GetMessage2 with 9 arguments (%s) type (%s)", strCMPIStatus (rc), CMGetCharsPtr(type, NULL)); rc = CMCloseMessageFile(_broker, msgFileHandle); PROV_LOG ("++++ Status of CMCloseMessageFile (%s) ", strCMPIStatus (rc)); CMRelease(instance1); CMRelease(instanceErr); return flag ; }
static CMPIStatus ClassProviderEnumClassNames(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, n; ClassRecord *crec; CMPIObjectPath *op; ClassRegister *cReg; char *ns; _SFCB_ENTER(TRACE_PROVIDERS, "ClassProviderEnumClassNames"); cReg = getNsReg(ref, &rc); if (cReg == NULL) { CMPIStatus st = { CMPI_RC_ERR_INVALID_NAMESPACE, NULL }; _SFCB_RETURN(st); } ns = (char *) CMGetNameSpace(ref, NULL)->hdl; 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; cReg->ft->wLock(cReg); if (cn && strcasecmp(cn, "$ClassProvider$") == 0) cn = NULL; if (cn == NULL) { n = 0; for (it = cReg->ft->getFirstClassRecord(cReg, &key, &crec); key && it && crec; it = cReg->ft->getNextClassRecord(cReg, it, &key, &crec)) { if ((flgs & CMPI_FLAG_DeepInheritance) || crec->parent == NULL) { if (((flgs & FL_assocsOnly) == 0) || crec->flags & CREC_isAssociation) { op = CMNewObjectPath(_broker, ns, key, NULL); CMReturnObjectPath(rslt, op); } } } } else { CMPIConstClass *cls = getClass(cReg, cn, NULL); 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)) { op = CMNewObjectPath(_broker, ns, child, NULL); CMReturnObjectPath(rslt, op); } } else if (flgs & CMPI_FLAG_DeepInheritance) { if (((flgs & FL_assocsOnly) == 0) || crec->flags & CREC_isAssociation) loopOnChildNames(cReg, cn, rslt); } } cReg->ft->wUnLock(cReg); _SFCB_RETURN(st); }
CMPIStatus IndCIMXMLHandlerInvokeMethod(CMPIMethodMI * mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath * ref, const char *methodName, const CMPIArgs * in, CMPIArgs * out) { _SFCB_ENTER(TRACE_INDPROVIDER, "IndCIMXMLHandlerInvokeMethod"); CMPIStatus st = { CMPI_RC_OK, NULL }; CMPIStatus circ = { CMPI_RC_OK, NULL }; struct timeval tv; struct timezone tz; static unsigned int indID=1; if (interOpNameSpace(ref, &st) == 0) _SFCB_RETURN(st); if (strcasecmp(methodName, "_deliver") == 0) { // On the first indication, check if reliable indications are enabled. if (RIEnabled == -1) { CMPIObjectPath *op=CMNewObjectPath(_broker,"root/interop","CIM_IndicationService",NULL); CMPIEnumeration *isenm = _broker->bft->enumerateInstances(_broker, ctx, op, NULL, NULL); CMPIData isinst=CMGetNext(isenm,NULL); CMPIData mc=CMGetProperty(isinst.value.inst,"DeliveryRetryAttempts",NULL); RIEnabled=mc.value.uint16; } CMPIInstance *indo=CMGetArg(in,"indication",NULL).value.inst; CMPIInstance *ind=CMClone(indo,NULL); CMPIContext *ctxLocal=NULL; CMPIObjectPath *iop=NULL,*subop=NULL; CMPIInstance *sub=NULL; if (RIEnabled) { ctxLocal = prepareUpcall((CMPIContext *) ctx); // Set the indication sequence values iop=CMGetObjectPath(ind,NULL); CMAddKey(iop,"SFCB_IndicationID",&indID,CMPI_uint32); CMSetProperty(ind,"SFCB_IndicationID",&indID,CMPI_uint32); // Prevent this property from showing up in the indication filterFlagProperty(ind, "SFCB_IndicationID"); sub=CMGetArg(in,"subscription",NULL).value.inst; CMPIData handler=CMGetProperty(sub, "Handler", &st); CMPIObjectPath *hop=handler.value.ref; CMPIInstance *hdlr=CBGetInstance(_broker, ctxLocal, hop, NULL, &st); // Build the complete sequence context // Get the stub from the handler CMPIString *context = CMGetProperty(hdlr, "SequenceContext", &st).value.string; // and add the sfcb start time char *cstr=malloc( (strlen(context->ft->getCharPtr(context,NULL)) + strlen(sfcBrokerStart) + 1) * sizeof(char)); sprintf(cstr,"%s%s",context->ft->getCharPtr(context,NULL),sfcBrokerStart); context = sfcb_native_new_CMPIString(cstr, NULL, 0); // and put it in the indication CMSetProperty(ind, "SequenceContext", &context, CMPI_string); free(cstr); CMRelease(context); // Get the proper sequence number CMPIValue lastseq = CMGetProperty(hdlr, "LastSequenceNumber", &st).value; lastseq.sint64++; // Handle wrapping of the signed int if (lastseq.sint64 < 0) lastseq.sint64=0; // Update the last used number in the handler CMSetProperty(hdlr, "LastSequenceNumber", &lastseq.sint64, CMPI_sint64); CBModifyInstance(_broker, ctxLocal, hop, hdlr, NULL); // And the indication CMSetProperty(ind, "SequenceNumber", &lastseq, CMPI_sint64); } // Now send the indication st = deliverInd(ref, in, ind); if (st.rc != 0) { if (RIEnabled){ _SFCB_TRACE(1,("--- Indication delivery failed, adding to retry queue")); // Indication delivery failed, send to retry queue // build an element RTElement *element; element = (RTElement *) malloc(sizeof(*element)); element->ref=ref->ft->clone(ref,NULL); // Get the OP of the subscription and indication subop=CMGetObjectPath(sub,NULL); element->sub=subop->ft->clone(subop,NULL); element->ind=iop->ft->clone(iop,NULL); // Store other attrs element->instanceID=indID; element->count=0; gettimeofday(&tv, &tz); element->lasttry=tv.tv_sec; // Push the indication to the repo CBCreateInstance(_broker, ctxLocal, iop, ind, &circ); if (circ.rc != 0) { mlogf(M_ERROR,M_SHOW,"Pushing indication instance to repository failed, rc:%d\n",circ.rc); } indID++; // Add it to the retry queue enqRetry(element,ctx,1); // And launch the thread if it isn't already running pthread_attr_init(&tattr); pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED); if (retryRunning == 0) { retryRunning = 1; _SFCB_TRACE(1,("--- Starting retryExport thread")); CMPIContext *pctx = native_clone_CMPIContext(ctx); pthread_create(&t, &tattr, &retryExport, (void *) pctx); } CMRelease(ctxLocal); } } CMRelease(ind); } else { printf("--- ClassProvider: Invalid request %s\n", methodName); st.rc = CMPI_RC_ERR_METHOD_NOT_FOUND; } _SFCB_RETURN(st); }
void * retryExport(void *lctx) { _SFCB_ENTER(TRACE_INDPROVIDER, "retryExport"); CMPIObjectPath *ref; CMPIArgs *in; CMPIInstance *sub; CMPIContext *ctx = (CMPIContext *) lctx; CMPIContext *ctxLocal; RTElement *cur, *purge; struct timeval tv; struct timezone tz; int rint, maxcount, ract, rtint; CMPIUint64 sfc = 0; CMPIObjectPath *op; CMPIEnumeration *isenm = NULL; //Setup signal handlers struct sigaction sa; sa.sa_handler = handle_sig_retry; sa.sa_flags = 0; sigemptyset(&sa.sa_mask); sigaction(SIGUSR2, &sa, NULL); CMPIStatus st = { CMPI_RC_OK, NULL }; ctxLocal = prepareUpcall(ctx); // Get the retry params from IndService op = CMNewObjectPath(_broker, "root/interop", "CIM_IndicationService", NULL); isenm = _broker->bft->enumerateInstances(_broker, ctx, op, NULL, NULL); CMPIData isinst = CMGetNext(isenm, NULL); CMPIData mc = CMGetProperty(isinst.value.inst, "DeliveryRetryAttempts", NULL); CMPIData ri = CMGetProperty(isinst.value.inst, "DeliveryRetryInterval", NULL); CMPIData ra = CMGetProperty(isinst.value.inst, "SubscriptionRemovalAction", NULL); CMPIData rti = CMGetProperty(isinst.value.inst, "SubscriptionRemovalTimeInterval", NULL); maxcount = mc.value.uint16; // Number of times to retry delivery rint = ri.value.uint32; // Interval between retries rtint = rti.value.uint32; // Time to allow sub to keep failing until ract = ra.value.uint16; // ... this action is taken // Now, run the queue sleep(5); //Prevent deadlock on startup when localmode is used. pthread_mutex_lock(&RQlock); cur = RQhead; while (RQhead != NULL) { if(retryShutdown) break; // Provider shutdown ref = cur->ref; // Build the CMPIArgs that deliverInd needs CMPIInstance *iinst=internalProviderGetInstance(cur->ind,&st); if (st.rc != 0 ) { mlogf(M_ERROR,M_SHOW,"Failed to retrieve indication instance from repository, rc:%d\n",st.rc); purge=cur; cur=cur->next; dqRetry(ctx,purge); continue; } in=CMNewArgs(_broker,NULL); CMAddArg(in,"indication",&iinst,CMPI_instance); sub=internalProviderGetInstance(cur->sub,&st); if (st.rc == CMPI_RC_ERR_NOT_FOUND) { // sub got deleted, purge this indication and move on _SFCB_TRACE(1,("--- Subscription for indication gone, deleting indication.")); purge = cur; cur = cur->next; dqRetry(ctx,purge); } else { // Still valid, retry gettimeofday(&tv, &tz); if ((cur->lasttry + rint) > tv.tv_sec) { _SFCB_TRACE(1,("--- sleeping.")); // no retries are ready, release the lock // and sleep for an interval, then relock pthread_mutex_unlock(&RQlock); sleep(rint); if(retryShutdown) break; // Provider shutdown pthread_mutex_lock(&RQlock); } st = deliverInd(ref, in, iinst); if ((st.rc == 0) || (cur->count >= maxcount - 1)) { // either it worked, or we maxed out on retries // If it succeeded, clear the failtime if (st.rc == 0) { _SFCB_TRACE(1,("--- Indication succeeded.")); sfc = 0; CMSetProperty(sub, "DeliveryFailureTime", &sfc, CMPI_uint64); CBModifyInstance(_broker, ctxLocal, cur->sub, sub, NULL); } // remove from queue in either case _SFCB_TRACE(1,("--- Indication removed.")); purge = cur; cur = cur->next; dqRetry(ctx,purge); } else { // still failing, leave on queue _SFCB_TRACE(1,("--- Indication still failing.")); cur->count++; gettimeofday(&tv, &tz); cur->lasttry = tv.tv_sec; CMPIInstance * indele=internalProviderGetInstance(cur->SFCBIndEle,&st); CMSetProperty(indele,"LastDelivery",&cur->lasttry,CMPI_sint32); CMSetProperty(indele,"RetryCount",&cur->count,CMPI_uint32); CBModifyInstance(_broker, ctxLocal, cur->SFCBIndEle, indele, NULL); CMPIData sfcp = CMGetProperty(sub, "DeliveryFailureTime", NULL); sfc = sfcp.value.uint64; if (sfc == 0) { // if the time isn't set, this is the first failure sfc = tv.tv_sec; CMSetProperty(sub, "DeliveryFailureTime", &sfc, CMPI_uint64); CBModifyInstance(_broker, ctxLocal, cur->sub, sub, NULL); cur = cur->next; } else if (sfc + rtint < tv.tv_sec) { // Exceeded subscription removal threshold, if action is: // 2, delete the sub; 3, disable the sub; otherwise, nothing if (ract == 2) { _SFCB_TRACE(1,("--- Subscription threshold reached, deleting.")); CBDeleteInstance(_broker, ctx, cur->sub); purge = cur; cur = cur->next; dqRetry(ctx,purge); } else if (ract == 3) { // Set sub state to disable(4) _SFCB_TRACE(1,("--- Subscription threshold reached, disable.")); CMPIUint16 sst = 4; CMSetProperty(sub, "SubscriptionState", &sst, CMPI_uint16); CBModifyInstance(_broker, ctx, cur->sub, sub, NULL); purge = cur; cur = cur->next; dqRetry(ctx,purge); } } else { cur = cur->next; } } } } // Queue went dry, cleanup and exit _SFCB_TRACE(1,("--- Indication retry queue empty, thread exitting.")); pthread_mutex_unlock(&RQlock); retryRunning = 0; CMRelease(ctxLocal); CMRelease(ctx); _SFCB_RETURN(NULL); }
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); }