CMPIData internalGetPropQualAt(CMPIConstClass * cc, CMPICount p, CMPICount i, CMPIString **name, CMPIStatus *rc) { ClClass *cls = (ClClass *) cc->hdl; char *n; CMPIData rv = { 0, CMPI_notFound, {0} }; if (ClClassGetPropQualifierAt(cls, p, i, &rv, name ? &n : NULL)) { if (rc) CMSetStatus(rc, CMPI_RC_ERR_NOT_FOUND); if (name) *name = sfcb_native_new_CMPIString(NULL, NULL, 0); return rv; } if (rv.type == CMPI_chars) { rv.value.string = sfcb_native_new_CMPIString(ClObjectGetClString (&cls->hdr, (ClString *) & rv.value. chars), NULL, 0); rv.type = CMPI_string; } if (rv.type & CMPI_ARRAY && rv.value.dataPtr.ptr) { rv.value.array = native_make_CMPIArray((CMPIData *) rv.value.dataPtr.ptr, NULL, &cls->hdr); } if (name) { *name = sfcb_native_new_CMPIString(n, NULL, 0); } if (rc) CMSetStatus(rc, CMPI_RC_OK); return rv; }
static CMPIData __aft_getArgAt(const CMPIArgs * args, unsigned int i, CMPIString **name, CMPIStatus *rc) { ClArgs *ca = (ClArgs *) args->hdl; char *n; CMPIData rv = { 0, CMPI_notFound, {0} }; if (ClArgsGetArgAt(ca, i, &rv, name ? &n : NULL)) { if (rc) CMSetStatus(rc, CMPI_RC_ERR_NOT_FOUND); return rv; } if (rv.type == CMPI_chars) { rv.value.string = sfcb_native_new_CMPIString(rv.value.chars, NULL, 0); rv.type = CMPI_string; } else if (rv.type == CMPI_ref) { rv.value.ref = getObjectPath((char *) ClObjectGetClString(&ca->hdr, (ClString *) & rv.value.chars), NULL); } else if (rv.type & CMPI_ARRAY && rv.value.array) { rv.value.array = internal_native_make_CMPIArray((CMPIData *) rv.value.array, NULL, &ca->hdr, MEM_TRACKED); } if (name) { *name = sfcb_native_new_CMPIString(n, NULL, 0); } if (rc) CMSetStatus(rc, CMPI_RC_OK); return rv; }
static int testNameSpace(const char *ns, CMPIStatus *st) { char **nsp = nsTab; if (interOpProvInfoPtr == forceNoProvInfoPtr) { if (strcasecmp(ns, interopNs) == 0) { st->msg = sfcb_native_new_CMPIString("Interop namespace disabled", NULL, 0); st->rc = CMPI_RC_ERR_FAILED; return 0; } } while (nsTabLen && *nsp) { if (strcasecmp(*nsp, ns) == 0) return 1; nsp++; } if (existingNameSpace(ns)) { nsTab = nsp = realloc(nsTab, sizeof(nsp) * (nsTabLen + 2)); nsp[nsTabLen++] = strdup(ns); nsp[nsTabLen] = NULL; return 1; } st->rc = CMPI_RC_ERR_INVALID_NAMESPACE; return 0; }
static CMPIData getQualifierDeclData(CMPIQualifierDecl * cq, CMPIStatus *rc) { ClQualifierDeclaration *q = (ClQualifierDeclaration *) cq->hdl; CMPIData rv = { 0, CMPI_notFound, {0} }; if (ClQualifierDeclarationGetQualifierData(q, &rv)) { if (rc) CMSetStatus(rc, CMPI_RC_ERR_NOT_FOUND); return rv; } if (rv.type == CMPI_chars) { rv.value.string = sfcb_native_new_CMPIString(ClObjectGetClString (&q->hdr, (ClString *) & rv.value. chars), NULL, 0); rv.type = CMPI_string; } if (rv.type & CMPI_ARRAY && rv.value.array) { rv.value.array = native_make_CMPIArray((CMPIData *) rv.value.array, NULL, &q->hdr); } if (rc) CMSetStatus(rc, CMPI_RC_OK); return rv; }
static CMPIString * __dtft_getStringFormat(const CMPIDateTime *dt, CMPIStatus *rc) { struct native_datetime *ndt = (struct native_datetime *) dt; if (rc) CMSetStatus(rc, CMPI_RC_OK); return sfcb_native_new_CMPIString(ndt->cimDt, rc, 0); }
CMPIData getPropertyQualsAt(CMPIConstClass * cc, CMPICount i, CMPIString **name, unsigned long *quals, CMPIString **refName, CMPIStatus *rc) { ClClass *cls = (ClClass *) cc->hdl; char *n; char *rName = NULL; CMPIData rv = { 0, CMPI_notFound, {0} }; if (ClClassGetPropertyAt(cls, i, &rv, name ? &n : NULL, quals, &rName)) { if (rc) CMSetStatus(rc, CMPI_RC_ERR_NOT_FOUND); return rv; } if (rv.type == CMPI_chars) { rv.value.string = sfcb_native_new_CMPIString(rv.value.chars, NULL, 0); rv.type = CMPI_string; } else if (rv.type == CMPI_ref) { if ((rv.state & CMPI_nullValue) == 0) rv.value.ref = getObjectPath((char *) ClObjectGetClString(&cls->hdr, (ClString *) & rv.value.chars), NULL); } if (rv.type & CMPI_ARRAY && rv.value.array) { rv.value.array = native_make_CMPIArray((CMPIData *) rv.value.array, NULL, &cls->hdr); } if (name) { *name = sfcb_native_new_CMPIString(n, NULL, 0); } if (refName && rName) { *refName = sfcb_native_new_CMPIString(rName, NULL, 0); } else { if (refName) { *refName = NULL; } } if (rc) CMSetStatus(rc, CMPI_RC_OK); return rv; }
static CMPIContext* prepareUpcall(CMPIContext *ctx) { /* used to invoke the internal provider in upcalls, otherwise we will * * be routed here (interOpProvider) again*/ CMPIContext *ctxLocal; ctxLocal = native_clone_CMPIContext(ctx); CMPIValue val; val.string = sfcb_native_new_CMPIString("$DefaultProvider$", NULL,0); ctxLocal->ft->addEntry(ctxLocal, "rerouteToProvider", &val, CMPI_string); return ctxLocal; }
static CMPIStatus __eft_getData(const CMPIPredicate *pred, CMPIType *type, CMPIPredOp * opc, CMPIString **lhs, CMPIString **rhs) { NativePredicate *p = (NativePredicate *) pred; QLOperation *op = p->op, *o; CMPIStatus irc = { CMPI_RC_OK, NULL }; if (op) { if (op->opr == QL_bin) { QLOpd type = QL_Invalid; if (op->lhon) o = op->lhon; else o = op->rhon; if (o->lhod && o->lhod->type != QL_PropertyName) type = o->lhod->type; else if (o->rhod && o->rhod->type != QL_PropertyName) type = o->rhod->type; if (opc) *opc = o->opr; if (lhs) { char* lstr = o->lhod->ft->toString(o->lhod); *lhs = sfcb_native_new_CMPIString(lstr, NULL, 0); } if (rhs) { char* rstr = o->rhod->ft->toString(o->rhod); *rhs = sfcb_native_new_CMPIString(rstr, NULL, 0); } } else { printf("--- NOT QL_bin\n"); CMSetStatusWithString(&irc, CMPI_RC_ERR_FAILED, sfcb_native_new_CMPIString ("Predicate has no a binary operator.", NULL, 0)); } } return irc; }
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; }
static CMPIData getQualifier(CMPIConstClass * cc, const char *name, CMPIStatus *rc) { ClClass *cls = (ClClass *) cc->hdl; CMPIData rv_notfound = { 0, CMPI_notFound, {0} }; CMPIData rv; char *qname; int i; CMPICount cnt = ClClassGetQualifierCount(cls); for (i = 0; i < cnt; i++) { if (ClClassGetQualifierAt(cls, i, &rv, &qname)) { if (rc) CMSetStatus(rc, CMPI_RC_ERR_NOT_FOUND); return rv_notfound; } if (strcasecmp(name, qname) == 0) { if (rv.type == CMPI_chars) { rv.value.string = sfcb_native_new_CMPIString(ClObjectGetClString (&cls->hdr, (ClString *) & rv.value.chars), NULL, 0); rv.type = CMPI_string; } if (rv.type & CMPI_ARRAY && rv.value.array) { rv.value.array = native_make_CMPIArray((CMPIData *) rv.value.array, NULL, &cls->hdr); } if (rc) CMSetStatus(rc, CMPI_RC_OK); return rv; }; } if (rc) CMSetStatus(rc, CMPI_RC_ERR_NOT_FOUND); return rv_notfound; }
static CMPIString * getSuperClassName(CMPIConstClass * cc, CMPIStatus *rc) { const char *cn = getCharSuperClassName(cc); return sfcb_native_new_CMPIString(cn, rc, 0); }
static CMPIData getPropQualifier(CMPIConstClass * cc, const char *cp, const char *cpq, CMPIStatus *rc) { ClClass *cls = (ClClass *) cc->hdl; ClSection *prps = &cls->properties; char *n = NULL; CMPIData rv_notFound = { 0, CMPI_notFound, {0} }; CMPIData rv; CMPICount p = ClObjectLocateProperty(&cls->hdr, prps, cp); CMPICount num = ClClassGetPropQualifierCount(cls, p - 1); CMPICount i; /* * special qualifier handling */ if (strcasecmp(cpq, "key") == 0) { unsigned long quals; getPropertyQualsAt(cc, p - 1, NULL, &quals, NULL, rc); if (quals & ClProperty_Q_Key) { rv.type = CMPI_boolean; rv.state = CMPI_goodValue; rv.value.boolean = 1; if (rc) CMSetStatus(rc, CMPI_RC_OK); return rv; } else { if (rc) CMSetStatus(rc, CMPI_RC_ERR_NOT_FOUND); return rv_notFound; } } if (strcasecmp(cpq, "embeddedobject") == 0) { unsigned long quals; getPropertyQualsAt(cc,p-1,NULL,&quals,NULL,rc); if (quals & ClProperty_Q_EmbeddedObject) { rv.type = CMPI_boolean; rv.state = CMPI_goodValue; rv.value.boolean = 1; if (rc) CMSetStatus(rc, CMPI_RC_OK); return rv; } else { if (rc) CMSetStatus(rc, CMPI_RC_ERR_NOT_FOUND); return rv_notFound; } } for (i = 0; i < num; i++) { if (ClClassGetPropQualifierAt(cls, p - 1, i, &rv, &n) == 0 && strcasecmp(cpq, n) == 0) { if (rv.type == CMPI_chars) { rv.value.string = sfcb_native_new_CMPIString(ClObjectGetClString (&cls->hdr, (ClString *) & rv.value.chars), NULL, 0); rv.type = CMPI_string; } else if ((rv.type & CMPI_ARRAY) && rv.value.dataPtr.ptr) { rv.value.array = native_make_CMPIArray((CMPIData *) rv.value.dataPtr.ptr, NULL, &cls->hdr); } if (rc) CMSetStatus(rc, CMPI_RC_OK); return rv; } if (n && isMallocedStrBuf(&cls->hdr)) { free(n); } } if (rc) { CMSetStatus(rc, CMPI_RC_ERR_NOT_FOUND); } return rv_notFound; }
CMPIString * args2String(CMPIArgs * arg, CMPIStatus *rc) { char *argstr = ClArgsToString((ClArgs *) arg->hdl); return sfcb_native_new_CMPIString(argstr, NULL, 0); }
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 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); }
CMPIStatus InternalProviderCreateInstance(CMPIInstanceMI * mi, const CMPIContext *ctx, const CMPIResult *rslt, const CMPIObjectPath * cop, const CMPIInstance *ci) { CMPIStatus st = { CMPI_RC_OK, NULL }; unsigned long len; void *blob; CMPIString *cn = CMGetClassName(cop, NULL); CMPIString *ns = CMGetNameSpace(cop, NULL); char *key = normalizeObjectPathCharsDup(cop); const char *nss = ns->ft->getCharPtr(ns, NULL); const char *cns = cn->ft->getCharPtr(cn, NULL); const char *bnss = repositoryNs(nss); _SFCB_ENTER(TRACE_INTERNALPROVIDER, "InternalProviderCreateInstance"); if (testNameSpace(bnss, &st) == 0) { free(key); _SFCB_RETURN(st); } CMPIConstClass *cc = getConstClass(nss, cns); /* * per DSP0004 2.5.2 */ if (cc != NULL && cc->ft->isAbstract(cc) != 0) { CMPIStatus st = { CMPI_RC_ERR_NOT_SUPPORTED, NULL }; free(key); _SFCB_RETURN(st); } if (existingBlob(bnss, cns, key)) { CMPIStatus st = { CMPI_RC_ERR_ALREADY_EXISTS, NULL }; free(key); _SFCB_RETURN(st); } len = getInstanceSerializedSize(ci); blob = malloc(len + 64); getSerializedInstance(ci, blob); if (addBlob(bnss, cns, key, blob, (int) len)) { CMPIStatus st = { CMPI_RC_ERR_FAILED, NULL }; st.msg = sfcb_native_new_CMPIString("Unable to write to repository", NULL, 0); free(blob); free(key); _SFCB_RETURN(st); } free(blob); if (rslt) { CMReturnObjectPath(rslt, cop); } free(key); _SFCB_RETURN(st); }
CMPIString * __eft_getString(const CMPISelectExp *exp, CMPIStatus *rc) { NativeSelectExp *e = (NativeSelectExp *) exp; return sfcb_native_new_CMPIString(e->queryString, rc, 0); }
int cls2xml(CMPIConstClass * cls, UtilStringBuffer * sb, unsigned int flags) { ClClass *cl = (ClClass *) cls->hdl; int i, m, q, qm, p, pm; char *type, *superCls; CMPIString *name, *qname, *refName; CMPIData data, qdata; CMPIType mtype; unsigned long quals; UtilStringBuffer *qsb = UtilFactory->newStrinBuffer(1024); _SFCB_ENTER(TRACE_CIMXMLPROC, "cls2xml"); SFCB_APPENDCHARS_BLOCK(sb, "<CLASS NAME=\""); sb->ft->appendChars(sb, cls->ft->getCharClassName(cls)); superCls = (char *) cls->ft->getCharSuperClassName(cls); if (superCls) { SFCB_APPENDCHARS_BLOCK(sb, "\" SUPERCLASS=\""); sb->ft->appendChars(sb, superCls); } SFCB_APPENDCHARS_BLOCK(sb, "\">\n"); if (flags & FL_includeQualifiers) quals2xml(cl->quals, sb); if (flags & FL_includeQualifiers) for (i = 0, m = ClClassGetQualifierCount(cl); i < m; i++) { data = cls->ft->getQualifierAt(cls, i, &name, NULL); DATA2XML(&data, cls, name, NULL, "<QUALIFIER NAME=\"", "</QUALIFIER>\n", sb, NULL, 0, 0); } for (i = 0, m = ClClassGetPropertyCount(cl); i < m; i++) { qsb->ft->reset(qsb); data = getPropertyQualsAt(cls, i, &name, &quals, &refName, NULL); if (flags & FL_includeQualifiers) quals2xml(quals << 8, qsb); if (flags & FL_includeQualifiers) for (q = 0, qm = ClClassGetPropQualifierCount(cl, i); q < qm; q++) { qdata = internalGetPropQualAt(cls, i, q, &qname, NULL); DATA2XML(&qdata, cls, qname, NULL, "<QUALIFIER NAME=\"", "</QUALIFIER>\n", qsb, NULL, 0, 0); CMRelease(qname); sfcb_native_release_CMPIValue(qdata.type, &qdata.value); } if (data.type & CMPI_ARRAY) DATA2XML(&data, cls, name, NULL, "<PROPERTY.ARRAY NAME=\"", "</PROPERTY.ARRAY>\n", sb, qsb, 0, 0); else { type = dataType(data.type); if (*type == '*') { DATA2XML(&data, cls, name, refName, "<PROPERTY.REFERENCE NAME=\"", "</PROPERTY.REFERENCE>\n", sb, qsb, 0, 0); } else DATA2XML(&data, cls, name, NULL, "<PROPERTY NAME=\"", "</PROPERTY>\n", sb, qsb, 0, 0); } CMRelease(name); } for (i = 0, m = ClClassGetMethodCount(cl); i < m; i++) { ClMethod *meth; ClParameter *parm; char *sname, *smname; CMPIString *name, *mname; qsb->ft->reset(qsb); ClClassGetMethodAt(cl, i, &mtype, &smname, &quals); mname = sfcb_native_new_CMPIString(smname, NULL, 2); meth = ((ClMethod *) ClObjectGetClSection(&cl->hdr, &cl->methods)) + i; if (flags & FL_includeQualifiers) { for (q = 0, qm = ClClassGetMethQualifierCount(cl, i); q < qm; q++) { ClClassGetMethQualifierAt(cl, meth, q, &qdata, &sname); name = sfcb_native_new_CMPIString(sname, NULL, 2); DATA2XML(&qdata, cls, name, NULL, "<QUALIFIER NAME=\"", "</QUALIFIER>\n", qsb, NULL, 0, 0); } } for (p = 0, pm = ClClassGetMethParameterCount(cl, i); p < pm; p++) { CMPIParameter pdata; ClClassGetMethParameterAt(cl, meth, p, &pdata, &sname); name = sfcb_native_new_CMPIString(sname, NULL, 2); parm = ((ClParameter *) ClObjectGetClSection(&cl->hdr, &meth->parameters)) + p; param2xml(&pdata, cls, parm, name, qsb, flags); } method2xml(mtype, mname, "<METHOD NAME=\"", "</METHOD>\n", sb, qsb); } SFCB_APPENDCHARS_BLOCK(sb, "</CLASS>\n"); qsb->ft->release(qsb); _SFCB_RETURN(0); }
CMPIValue str2CMPIValue(CMPIType type, XtokValue val, XtokValueReference * ref, char *ns, CMPIStatus *status) { CMPIValue value; CMPIType t = 0; CMPIStatus rc = {CMPI_RC_OK, NULL}; if (type == 0) { type = guessType(val.value); } if (type & CMPI_ARRAY) { /* * array type received -- needs special handling */ int i, max; CMPIValue v; XtokValueArray *arr = (XtokValueArray *) ref; XtokValueRefArray *refarr = (XtokValueRefArray *) arr; max = arr->next; if ((type & CMPI_ref) == CMPI_ref) { t = CMPI_ref; } else if (type & ~CMPI_ARRAY) { t = type & ~CMPI_ARRAY; } else { /* * the guess type can go wrong */ if (max > 0) { t = guessType(arr->values[0].value); } } /* * build an array by looping thru the elements */ value.array = TrackedCMPIArray(max, t, NULL); if (value.array != NULL) { for (i = 0; i < max; i++) { v = str2CMPIValue(t, arr->values[i], refarr->values + i, ns, &rc); CMSetArrayElementAt(value.array, i, &v, t); } return value; } } /* Feature 75543 - set and return status->rc on failures */ switch (type) { case CMPI_char16: value.char16 = *val.value; break; case CMPI_string: value.string = sfcb_native_new_CMPIString(val.value, NULL, 0); break; case CMPI_sint64: if (invalid_int(val.value, type)) status->rc = CMPI_RC_ERR_INVALID_PARAMETER; else sscanf(val.value, "%lld", &value.sint64); break; case CMPI_uint64: if (invalid_uint(val.value, type)) status->rc = CMPI_RC_ERR_INVALID_PARAMETER; else sscanf(val.value, "%llu", &value.uint64); break; case CMPI_sint32: if (invalid_int(val.value, type)) status->rc = CMPI_RC_ERR_INVALID_PARAMETER; else sscanf(val.value, "%d", &value.sint32); break; case CMPI_uint32: if (invalid_uint(val.value, type)) status->rc = CMPI_RC_ERR_INVALID_PARAMETER; else sscanf(val.value, "%u", &value.uint32); break; case CMPI_sint16: if (invalid_int(val.value, type)) status->rc = CMPI_RC_ERR_INVALID_PARAMETER; else sscanf(val.value, "%hd", &value.sint16); break; case CMPI_uint16: if (invalid_uint(val.value, type)) status->rc = CMPI_RC_ERR_INVALID_PARAMETER; else sscanf(val.value, "%hu", &value.uint16); break; case CMPI_uint8: if (invalid_uint(val.value, type)) status->rc = CMPI_RC_ERR_INVALID_PARAMETER; else { sscanf(val.value, "%u", &value.uint32); value.uint8 = value.uint32; } break; case CMPI_sint8: if (invalid_int(val.value, type)) status->rc = CMPI_RC_ERR_INVALID_PARAMETER; else { sscanf(val.value, "%d", &value.sint32); value.sint8 = value.sint32; } break; case CMPI_boolean: if (invalid_boolean(val.value, type)) status->rc = CMPI_RC_ERR_INVALID_PARAMETER; else { value.boolean = strcasecmp(val.value, "false"); if (value.boolean) value.boolean = 1; } break; case CMPI_real32: if (invalid_real(val.value, type)) status->rc = CMPI_RC_ERR_INVALID_PARAMETER; else sscanf(val.value, "%f", &value.real32); break; case CMPI_real64: if (invalid_real(val.value, type)) status->rc = CMPI_RC_ERR_INVALID_PARAMETER; else sscanf(val.value, "%lf", &value.real64); break; case CMPI_dateTime: value.dateTime = sfcb_native_new_CMPIDateTime_fromChars(val.value, NULL); break; case CMPI_ref: getKeyValueTypePtr("ref", NULL, ref, &value, &t, ns); break; case CMPI_instance: value = makeFromEmbeddedObject(val, ns); break; default: mlogf(M_ERROR, M_SHOW, "%s(%d): invalid value %d-%p\n", __FILE__, __LINE__, (int) type, val); abort(); } return value; }