static void TCPCOMM_getInstance(int socket, CONST CMPIBroker * broker, CONST CMPIContext * context) { CMPIInstance *inst; CMPIStatus rc; CONST CMPIObjectPath *cop; char **props; cop = (__sft)->deserialize_CMPIObjectPath(socket, broker); props = socketcomm_deserialize_props(socket, (__sft), broker); inst = CBGetInstance(broker, context, cop, (CONST char**) props, &rc); (__sft)->serialize_CMPIStatus(socket, &rc); (__sft)->serialize_CMPIInstance(socket, inst); free(props); }
static bool _proc( const Instance* cimple_inst, Enum_Associator_Names_Status status, void* client_data) { Data* data = (Data*)client_data; if (!cimple_inst) return false; // Ignore if an error was already encountered. if (data->rc != CMPI_RC_OK) return false; // Convert to a CMPI object path and deliver: CMPIObjectPath* cmpi_op = 0; data->rc = make_cmpi_object_path( data->broker, cimple_inst, data->name_space, cmpi_op); // Now use the CMPI broker to get the full instance. CMPIInstance* cmpi_inst = CBGetInstance( data->broker, data->context, cmpi_op, data->properties, NULL); if (!cmpi_inst) { data->rc = CMPI_RC_ERR_FAILED; return false; } // Deliver instance to requestor: CMReturnInstance(data->result, cmpi_inst); return true; }
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); }
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); } }
int assoc_ServiceProcess( const CMPIBroker * _broker, const CMPIContext * ctx, const CMPIResult * rslt, const CMPIObjectPath * ref, int assocType, CMPIStatus * rc ) { CMPIString * sourceClass = NULL; CMPIData serviceName; CMPIObjectPath * op = NULL; CMPIObjectPath * rop = NULL; CMPIInstance * rci = NULL; CMPIInstance * sci = NULL; LXS_Handle lhdl; LXS_Service * lxssvc = NULL; int i = 0; _OSBASE_TRACE(2,("--- assoc_ServiceProcess() called")); /* check if source instance does exist */ sci = CBGetInstance(_broker, ctx, ref, NULL, rc); if( sci == NULL ) { if( rc->rc == CMPI_RC_ERR_FAILED ) { CMSetStatusWithChars( _broker, rc, CMPI_RC_ERR_FAILED, "GetInstance of source object failed."); } if( rc->rc == CMPI_RC_ERR_NOT_FOUND ) { CMSetStatusWithChars( _broker, rc, CMPI_RC_ERR_NOT_FOUND, "Source object not found."); } _OSBASE_TRACE(2,("--- assoc_ServiceProcess() failed : %s",CMGetCharPtr(rc->msg))); return -1; } sourceClass = CMGetClassName(ref, rc); if (CMGetCharPtr(sourceClass) == NULL) { CMSetStatusWithChars( _broker, rc, CMPI_RC_ERR_FAILED, "Could not get source class name."); _OSBASE_TRACE(2,("--- assoc_ServiceProcess() failed : %s",CMGetCharPtr(rc->msg))); return -1; } /* source class is Linux_UnixProcess; target class is Linux_Service */ if( strcasecmp(CMGetCharPtr(sourceClass),_RefRightClass) == 0 ) { /* NOT_SUPPORTED - association is uni-directional */ } /* source class is Linux_Service; target class is Linux_UnixProcess */ else if( strcasecmp(CMGetCharPtr(sourceClass),_RefLeftClass) == 0 ) { serviceName = CMGetKey(ref, "Name", rc); if( serviceName.value.string == NULL ) { CMSetStatusWithChars( _broker, rc, CMPI_RC_ERR_FAILED, "Could not get Name of Service" ); _OSBASE_TRACE(2,("--- assoc_ServiceProcess() failed : %s",CMGetCharPtr(rc->msg))); return -1; } lhdl=LXS_InitFiltered(CMGetCharPtr(serviceName.value.string)); if (lhdl==NULL) { _OSBASE_TRACE(2,("--- assoc_ServiceProcess() exited : Could not find associated Service.")); return 0; } lxssvc=LXS_Next(lhdl); if (lxssvc==NULL) { _OSBASE_TRACE(2,("--- assoc_ServiceProcess() exited : Could not find associated Service.")); return 0; } /* get the list of associated processe */ for (i=0;lxssvc->svProcesses[i]!=NULL;i++) { op = CMNewObjectPath( _broker, CMGetCharPtr(CMGetNameSpace(ref,rc)), _RefRightClass, rc ); if( CMIsNullObject(op) ) { CMSetStatusWithChars( _broker, rc, CMPI_RC_ERR_FAILED, "Create CMPIObjectPath failed." ); _OSBASE_TRACE(2,("--- assoc_ServiceProcess() failed : %s",CMGetCharPtr(rc->msg))); return -1; } CMAddKey(op, "CSCreationClassName", CSCreationClassName, CMPI_chars); CMAddKey(op, "CSName", get_system_name(), CMPI_chars); CMAddKey(op, "OSCreationClassName", OSCreationClassName, CMPI_chars); CMAddKey(op, "OSName", get_os_name(), CMPI_chars); CMAddKey(op, "CreationClassName", _RefRightClass, CMPI_chars); CMAddKey(op, "Handle", lxssvc->svProcesses[i], CMPI_chars); if (assocType&ATYPE_ASSOC) { /* the process (name) */ if (assocType&ATYPE_NAME) { CMReturnObjectPath(rslt, op); } else { rci = CBGetInstance(_broker, ctx, op, NULL, rc); if(rci==NULL) { return -1; } CMReturnInstance( rslt, rci ); } } else { /* the reference object (name) */ if (assocType&ATYPE_NAME) { rop = _makePath_ServiceProcess(_broker, ref, op, rc); CMReturnObjectPath(rslt, rop); } else { rci = _makeInst_ServiceProcess(_broker, ref, op, rc); CMReturnInstance( rslt, rci ); } } } LXS_Term(lhdl); } _OSBASE_TRACE(2,("--- assoc_ServiceProcess() exited")); return 0; }