/**
Enumerate ObjectPaths of Instances serviced by this provider.
*/
CMPIStatus TestInstanceProviderEnumInstanceNames (
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * ref)
{
CMPIStatus rc = {CMPI_RC_OK, NULL};
unsigned int j = 0;
CMPIObjectPath *local;
CMPIData data;
/* get the element from array containing created instances. */
for (j = 0; j < numOfInst; j++)
{
/*check for validity of Instance, that its not deleted */
if(valid[j] == 1)
{
/* get element(instance) from array */
data = CMGetArrayElementAt(clone_arr_ptr, j, &rc);
/* get object-path of that instance */
local = CMGetObjectPath(data.value.inst, &rc);
/* return object-path */
CMReturnObjectPath(rslt,local);
}
}
CMReturnDone (rslt);
CMReturn (CMPI_RC_OK);
}
/**
Create Instance from inst, using object-path op as reference.
*/
CMPIStatus TestInstanceProviderCreateInstance (
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * cop,
const CMPIInstance * ci)
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIInstance * inst;
CMPIValue value_inst;
CMPIData key1,key2, retInst;
CMPIObjectPath *obp;
unsigned int j = 0;
if(ci)
{
/* clone the instance to be added to the array */
inst = CMClone(ci, &rc);
key1 = CMGetProperty(inst, "Identifier", &rc);
for (j=0; j < numOfInst ; j++)
{
/* check for validity of Instance, that its not deleted */
if (valid[j] == 1)
{
/* get element(instance) from array */
retInst = CMGetArrayElementAt(clone_arr_ptr, j, &rc);
/* get object-path of instance */
obp = CMGetObjectPath(retInst.value.inst, &rc);
/* get key from this object-path */
key2 = CMGetKey(obp, "Identifier", &rc);
/*compare key values.
If they match throw exception as two instance with same key
properties cannot exists. */
if(key1.value.uint8 == key2.value.uint8)
{
CMRelease(inst);
CMReturn (CMPI_RC_ERR_ALREADY_EXISTS);
}
}
}
value_inst.inst = inst;
/* If instance doesnot exists in array add it */
rc = CMSetArrayElementAt(
clone_arr_ptr,
numOfInst,
&value_inst,
CMPI_instance);
valid[numOfInst]=1;
numOfInst++;
/* return object-path of instance */
CMReturnObjectPath(rslt, cop);
CMReturnDone(rslt);
}
else
{
CMReturn (CMPI_RC_ERR_NOT_SUPPORTED);
}
CMRelease(inst);
CMReturn (CMPI_RC_OK);
}
/**
Replace an existing Instance from inst, using object-path op as reference.
*/
CMPIStatus TestInstanceProviderModifyInstance (
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * cop,
const CMPIInstance * ci,
const char **properties)
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIInstance * inst;
CMPIValue val1, val2;
CMPIData key1, key2, retData1, retInst;
CMPIObjectPath *obp;
unsigned int j = 0, flag = 0;
if(ci)
{
inst = CMClone(ci, &rc);
/* get key from the object-path */
key1 = CMGetKey(cop, "Identifier", &rc);
val1.uint8 = key1.value.uint8;
/* get the value of Message property */
retData1 = CMGetProperty(inst, "Message", &rc);
val2.string = retData1.value.string;
for (j=0; j < numOfInst; j++)
{
/* check for validity of Instance, that its not deleted */
if (valid[j] == 1)
{
/* get element(instance) from array */
retInst = CMGetArrayElementAt(clone_arr_ptr, j, &rc);
/* get object-path of instance */
obp = CMGetObjectPath(retInst.value.inst, &rc);
/* get key from this object-path */
key2 = CMGetKey(obp, "Identifier", &rc);
/*compare key values.
If they match then set the properties received from client */
if(key1.value.uint8 == key2.value.uint8)
{
CMSetProperty(
retInst.value.inst,
"Message",
&val2,
CMPI_string);
flag = 1;
}
}
}
CMRelease(inst);
/*If match fails, throw exception, as instance to be mmodified is not
found */
if(!flag)
{
CMReturn (CMPI_RC_ERR_NOT_FOUND);
}
}
CMReturnDone (rslt);
CMReturn (CMPI_RC_OK);
}
CMPIStatus TestInstanceProviderDeleteInstance (
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * result,
const CMPIObjectPath * cop)
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIData key1, key2, retInst;
CMPIObjectPath *obp;
unsigned int j = 0, flag = 0;
/* get key from the object-path */
key1 = CMGetKey(cop, "Identifier", &rc);
for (j=0; j < numOfInst ; j++)
{
/*check for validity of Instance, that its not deleted */
if(valid[j] == 1)
{
/*get element(instance) from array */
retInst = CMGetArrayElementAt(clone_arr_ptr, j, &rc);
/*get object-path of instance */
obp = CMGetObjectPath(retInst.value.inst, &rc);
/*get key from this object-path */
key2 = CMGetKey(obp, "Identifier" , &rc);
/*compare key values.
If they match, release the object(instance)
Also set its validity to zero, marking it as deleted */
if (key1.value.uint8 == key2.value.uint8)
{
if(retInst.value.inst)
{
flag =1;
CMRelease(retInst.value.inst);
CMSetArrayElementAt(
clone_arr_ptr,
j,
&retInst.value.inst,
CMPI_null);
valid[j] = 0;
}
}
}
}
if(!flag)
{
CMReturn (CMPI_RC_ERR_NOT_FOUND);
}
CMReturn (CMPI_RC_OK);
}
int
enum2xml(CMPIEnumeration *enm, UtilStringBuffer * sb, CMPIType type,
int xmlAs, unsigned int flags)
{
CMPIObjectPath *cop;
CMPIInstance *ci;
CMPIConstClass *cl;
_SFCB_ENTER(TRACE_CIMXMLPROC, "enum2xml");
while (CMHasNext(enm, NULL)) {
if (type == CMPI_ref) {
cop = CMGetNext(enm, NULL).value.ref;
if (xmlAs == XML_asClassName)
className2xml(cop, sb);
else if (xmlAs == XML_asObjectPath) {
SFCB_APPENDCHARS_BLOCK(sb, "<OBJECTPATH>\n");
SFCB_APPENDCHARS_BLOCK(sb, "<INSTANCEPATH>\n");
nsPath2xml(cop, sb);
instanceName2xml(cop, sb);
SFCB_APPENDCHARS_BLOCK(sb, "</INSTANCEPATH>\n");
SFCB_APPENDCHARS_BLOCK(sb, "</OBJECTPATH>\n");
} else
instanceName2xml(cop, sb);
} else if (type == CMPI_class) {
cl = (CMPIConstClass *) CMGetNext(enm, NULL).value.inst;
cls2xml(cl, sb, flags);
} else if (type == CMPI_instance) {
ci = CMGetNext(enm, NULL).value.inst;
cop = CMGetObjectPath(ci, NULL);
if (xmlAs == XML_asObj) {
SFCB_APPENDCHARS_BLOCK(sb, "<VALUE.OBJECTWITHPATH>\n");
SFCB_APPENDCHARS_BLOCK(sb, "<INSTANCEPATH>\n");
nsPath2xml(cop, sb);
} else
SFCB_APPENDCHARS_BLOCK(sb, "<VALUE.NAMEDINSTANCE>\n");
instanceName2xml(cop, sb);
if (xmlAs == XML_asObj)
SFCB_APPENDCHARS_BLOCK(sb, "</INSTANCEPATH>\n");
instance2xml(ci, sb, flags);
if (xmlAs == XML_asObj)
SFCB_APPENDCHARS_BLOCK(sb, "</VALUE.OBJECTWITHPATH>\n");
else
SFCB_APPENDCHARS_BLOCK(sb, "</VALUE.NAMEDINSTANCE>\n");
cop->ft->release(cop);
}
}
_SFCB_RETURN(0);
}
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);
}
/**
Get the Instances defined by object-path op.
*/
CMPIStatus TestInstanceProviderGetInstance (
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * op,
const char **properties)
{
CMPIData data,key1,key2;
CMPIObjectPath *local;
unsigned int j = 0;
CMPIBoolean flag = 0;
CMPIStatus rc = {CMPI_RC_OK, NULL};
/* get the kay from object-path */
key1 = CMGetKey(op, "Identifier", &rc);
/* get the element from array containing created instances */
for(j = 0; j < numOfInst; j++)
{
/* check for validity of Instance, that its not deleted */
if (valid[j] == 1)
{
/* get element(instance) from array */
data = CMGetArrayElementAt(clone_arr_ptr, j, &rc);
/* get object-path of instance */
local = CMGetObjectPath(data.value.inst, &rc);
/* get key from this object-path */
key2 = CMGetKey(local, "Identifier", &rc);
/* compare key values.
If they match return instance */
if (key1.value.uint8 == key2.value.uint8)
{
CMReturnInstance(rslt, data.value.inst);
flag =1;
}
}
}
/* key values did not match so throw exception */
if(!flag)
{
CMReturn (CMPI_RC_ERR_NOT_FOUND);
}
CMReturnDone (rslt);
CMReturn (CMPI_RC_OK);
}
/*****************************************************************************
* Modify a backend xen resource identified by the the CIM instance based
* on the instance's properties
*
* @param in broker - CMPI factory service broker
* @param in ft - xen backend provider function table
* @param in res_id - opaque data identifying the CIM object being modified
* @param in caller_id - CIM caller's credentials
* @param in modified_res - modifed version of the xen resource
* @param in properties - CIM properties that caller cares about
* @return CMPIrc error codes
*****************************************************************************/
CMPIrc prov_pxy_modify(
const CMPIBroker *broker,
const XenProviderInstanceFT* ft,
const void *res_id,
struct xen_call_context *caller_id,
const void *modified_res,
const char **properties)
{
(void)properties;
CMPIData data;
CMPIStatus status = {CMPI_RC_OK, NULL};
char *inst_id;
xen_utils_session *session = NULL;
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_INFO,("Modify an Instance"));
CMPIInstance *inst = (CMPIInstance *)res_id;
if(CMIsNullObject(inst)) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("input parameter res_id is invalid"));
return CMPI_RC_ERR_FAILED;
}
CMPIObjectPath *op = CMGetObjectPath(inst, &status);
CMPIString *cn = CMGetClassName(op, &status);
/* Get target resource */
const char *key_prop = ft->xen_resource_get_key_property(broker, CMGetCharPtr(cn));
data = CMGetProperty(inst, key_prop, &status);
if((status.rc != CMPI_RC_OK) || CMIsNullValue(data)) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("Could not get target resource"));
return CMPI_RC_ERR_FAILED;
}
inst_id = CMGetCharPtr(data.value.string);
if((inst_id == NULL) || (*inst_id == '\0')) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("Could not get inst id"));
return CMPI_RC_ERR_FAILED;
}
if(!xen_utils_validate_session(&session, caller_id)) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("--- Unable to establish connection with Xen"));
return CMPI_RC_ERR_FAILED;
}
/* Call the target provider */
status.rc = ft->xen_resource_modify(broker, res_id, modified_res, properties, status, inst_id, session);
xen_utils_cleanup_session(session);
return status.rc;
}
CMPIObjectPath * _makePath_ServiceProcess( const CMPIBroker * _broker,
const CMPIObjectPath * service,
CMPIObjectPath * process,
CMPIStatus * rc) {
CMPIObjectPath * op = NULL;
CMPIInstance * ci = NULL;
_OSBASE_TRACE(4,("--- _makePath_ServiceProcess() called"));
ci = _makeInst_ServiceProcess(_broker, service, process, rc);
if( ci == NULL ) { return NULL; }
op = CMGetObjectPath(ci,rc);
CMSetNameSpace(op,CMGetCharPtr(CMGetNameSpace(service,rc)));
_OSBASE_TRACE(4,("--- _makePath_ServiceProcess() exited"));
return op;
}
/*****************************************************************************
* Delete a backend xen resource identified by the the CIM instance
*
* @param in broker - CMPI factory service broker
* @param in ft - xen backend provider function table
* @param in res_id - opaque data identifying the CIM object being deleted
* @param in caller_id - CIM caller's credentials
* @return CMPIrc error codes
*****************************************************************************/
CMPIrc prov_pxy_delete(
const CMPIBroker *broker,
const XenProviderInstanceFT* ft,
const void *res_id,
struct xen_call_context *caller_id
)
{
CMPIInstance *inst = (CMPIInstance *)res_id;
CMPIData data;
CMPIStatus status = {CMPI_RC_OK, NULL};
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_INFO, ("Delete an instance"));
CMPIObjectPath *op = CMGetObjectPath(inst, &status);
CMPIString *cn = CMGetClassName(op, &status);
xen_utils_session *session = NULL;
if(CMIsNullObject(inst)) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("Invalid parameter"));
return CMPI_RC_ERR_FAILED;
}
const char *key_prop = ft->xen_resource_get_key_property(broker, CMGetCharPtr(cn));
data = CMGetProperty(inst, key_prop ,&status);
if((status.rc != CMPI_RC_OK) || CMIsNullValue(data)) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("Could not get property"));
return CMPI_RC_ERR_FAILED;
}
char *inst_id = CMGetCharPtr(data.value.string);
if((inst_id == NULL) || (*inst_id == '\0')) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("Could not get inst id"));
return CMPI_RC_ERR_FAILED;
}
if(!xen_utils_validate_session(&session, caller_id)) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR,("Unable to establish connection with Xen"));
return CMPI_RC_ERR_FAILED;
}
/* get the object and delete it */
status.rc = ft->xen_resource_delete(broker, session, inst_id);
xen_utils_cleanup_session(session);
return status.rc;
}
static CMPIStatus _DefaultGI_returnInstance(
const CMPIResult* self,
const CMPIInstance* ci)
{
DefaultGI_Handle* handle =
(DefaultGI_Handle*)(((DefaultGI_Result*)self)->hdl);
const CMPIResult* result = handle->result;
const CMPIObjectPath* cop;
CMPIStatus status;
if (!(cop = CMGetObjectPath(ci, &status)))
return status;
if (KMatch(cop, handle->cop))
{
handle->found = 1;
return result->ft->returnInstance(result, ci);
}
KReturn(OK);
}
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);
}
}
cimSLPService
getSLPData(cimomConfig cfg, const CMPIBroker *_broker,
const CMPIContext *ctx, const char *urlsyntax)
{
CMPIInstance **ci;
//CMPIStatus status;
//CMPIConstClass *ccls;
cimSLPService rs; // service which is going to be returned
// to the calling function
char *sn;
#ifdef SLP_HOSTNAME_LIB
static void *hostnameLib = NULL;
static getSlpHostname gethostname;
char *ln;
char dlName[512];
int err;
err = 1;
if (getControlChars("slpHostnamelib", &ln) == 0) {
libraryName(NULL, ln, dlName, 512);
if ((hostnameLib = dlopen(dlName, RTLD_LAZY))) {
gethostname = dlsym(hostnameLib, "_sfcGetSlpHostname");
if (gethostname)
err = 0;
}
}
if (err)
mlogf(M_ERROR, M_SHOW,
"--- SLP Hostname exit %s not found. Defaulting to system hostname.\n",
dlName);
#endif
_SFCB_ENTER(TRACE_SLP, "getSLPData");
memset(&rs, 0, sizeof(cimSLPService));
// first of all, get the interop namespace, needed for all further
// connections
// this call fills the array as well as sets the global interOpNS
// variable
rs.InteropSchemaNamespace = getInterOpNS();
// extract all relavant stuff for SLP out of CIM_ObjectManager
// construct the server string
ci = myGetInstances(_broker, ctx, interOpNS, "CIM_ObjectManager",
urlsyntax);
if (ci) {
sn = myGetProperty(ci[0], "SystemName");
#ifdef SLP_HOSTNAME_LIB
if (!err) {
char *tmp;
if ((err = gethostname(&tmp))) {
free(sn);
sn = tmp;
} else {
printf
("-#- SLP call to %s for hostname failed. Defaulting to system hostname.\n",
dlName);
}
}
#endif
rs.url_syntax = getUrlSyntax(sn, cfg.commScheme, cfg.port);
rs.service_hi_name = myGetProperty(ci[0], "ElementName");
rs.service_hi_description = myGetProperty(ci[0], "Description");
rs.service_id = myGetProperty(ci[0], "Name");
freeInstArr(ci);
}
// extract all relavant stuff for SLP out of
// CIM_ObjectManagerCommunicationMechanism
ci = myGetInstances(_broker, ctx, interOpNS,
"CIM_ObjectManagerCommunicationMechanism",
urlsyntax);
if (ci) {
rs.CommunicationMechanism =
myGetProperty(ci[0], "CommunicationMechanism");
rs.OtherCommunicationMechanismDescription =
myGetProperty(ci[0], "OtherCommunicationMechanism");
rs.ProtocolVersion = myGetProperty(ci[0], "Version");
rs.FunctionalProfilesSupported =
myGetPropertyArray(ci[0], "FunctionalProfilesSupported");
rs.FunctionalProfileDescriptions =
myGetPropertyArray(ci[0], "FunctionalProfileDescriptions");
rs.MultipleOperationsSupported =
myGetProperty(ci[0], "MultipleOperationsSupported");
rs.AuthenticationMechanismsSupported =
myGetPropertyArray(ci[0], "AuthenticationMechanismsSupported");
rs.AuthenticationMechansimDescriptions =
myGetPropertyArray(ci[0], "AuthenticationMechansimDescriptions");
// do the transformations from numbers to text via the qualifiers
//CMPIStatus myRc;
//CMPIObjectPath *myOp = CMGetObjectPath(ci[0], &myRc);
//CMPIData qd = CMGetPropertyQualifier(myOp, "CommunicationMechanism", "ValueMap", &myRc);
rs.CommunicationMechanism = transformValue(rs.CommunicationMechanism,
CMGetObjectPath(ci[0], NULL),
"CommunicationMechanism");
rs.FunctionalProfilesSupported =
transformValueArray(rs.FunctionalProfilesSupported,
CMGetObjectPath(ci[0], NULL),
"FunctionalProfilesSupported");
rs.AuthenticationMechanismsSupported =
transformValueArray(rs.AuthenticationMechanismsSupported,
CMGetObjectPath(ci[0], NULL),
"AuthenticationMechanismsSupported");
freeInstArr(ci);
}
// extract all relavant stuff for SLP out of CIM_Namespace
ci = myGetInstances(_broker, ctx, interOpNS, "CIM_Namespace", urlsyntax);
if (ci) {
rs.Namespace = myGetPropertyArrayFromArray(ci, "Name");
rs.Classinfo = myGetPropertyArrayFromArray(ci, "ClassInfo");
freeInstArr(ci);
}
// extract all relavant stuff for SLP out of CIM_RegisteredProfile
//CMPIContext *ctxLocal = prepareUpcall(ctx);
//ci = myGetInstances(_broker, ctxLocal, interOpNS, "CIM_RegisteredProfile", urlsyntax);
ci = myGetInstances(_broker, ctx, interOpNS, "CIM_RegisteredProfile", urlsyntax);
if (ci) {
rs.RegisteredProfilesSupported = myGetRegProfiles(_broker, ci, ctx);
//rs.RegisteredProfilesSupported = myGetRegProfiles(_broker, ci, ctxLocal);
freeInstArr(ci);
}
//CMRelease(ctxLocal);
_SFCB_RETURN(rs);
}
CMPIStatus KDefaultGetInstance(
const CMPIBroker* mb,
CMPIInstanceMI* mi,
const CMPIContext* cc,
const CMPIResult* cr,
const CMPIObjectPath* cop,
const char** properties)
{
#if defined(DIRECT_CALL)
static CMPIResultFT _ft =
{
CMPICurrentVersion,
_DefaultGI_release,
_DefaultGI_clone,
_DefaultGI_returnData,
_DefaultGI_returnInstance,
_DefaultGI_returnObjectPath,
_DefaultGI_returnDone,
_DefaultGI_returnError
};
DefaultGI_Result result;
DefaultGI_Handle handle;
CMPIStatus st;
handle.result = cr;
handle.cop = cop;
handle.found = 0;
result.hdl = (void*)&handle;
result.ft = &_ft;
st = (*mi->ft->enumerateInstances)(
mi, cc, (CMPIResult*)(void*)&result, cop, NULL);
if (!st.rc)
return st;
if (!handle.found)
{
KReturn(ERR_NOT_FOUND);
}
KReturn(OK);
#else /* defined(DIRECT_CALL) */
CMPIEnumeration* e;
CMPIStatus st;
CMPIObjectPath* ccop;
/* Create an object path with just the class from cop */
ccop = CMNewObjectPath(mb, KNameSpace(cop), KClassName(cop), &st);
if (!ccop)
KReturn(ERR_FAILED);
/* Enumerate all instances of this class */
if (!(e = mb->bft->enumerateInstances(mb, cc, ccop, properties, &st)))
KReturn(ERR_FAILED);
while (CMHasNext(e, &st))
{
CMPIData cd;
CMPIObjectPath* tcop;
cd = CMGetNext(e, &st);
if (st.rc || cd.type != CMPI_instance || (cd.state & CMPI_nullValue))
KReturn(ERR_FAILED);
if (!(tcop = CMGetObjectPath(cd.value.inst, &st)))
KReturn(ERR_FAILED);
if (KMatch(tcop, cop))
{
CMReturnInstance(cr, cd.value.inst);
KReturn(OK);
}
}
KReturn(ERR_NOT_FOUND);
#endif /* !defined(DIRECT_CALL) */
}
CMPIStatus
TestAssociationProviderReferenceNames(CMPIAssociationMI * mi,
const CMPIContext *ctx,
const CMPIResult *rslt,
const CMPIObjectPath * ref,
const char *resultClass,
const char *role)
{
CMPIInstance *ci = NULL;
CMPIObjectPath *op = NULL;
CMPIObjectPath *rop = NULL;
CMPIObjectPath *cop = NULL;
CMPIEnumeration *en = NULL;
CMPIData data;
const char *targetName = NULL;
const char *_thisClassName;
const char *_RefLeftClass = NULL;
const char *_RefRightClass = NULL;
CMPIStatus rc = { CMPI_RC_OK, NULL };
_thisClassName = _ClassName;
/*
* get object path of the target class
*/
op = get_assoc_targetClass_ObjectPath(_broker,
ref,
_RefLeftClass,
_RefRightClass, &rc);
/*
* check for a failure in creating the object path
*/
if (rc.rc != CMPI_RC_OK)
return rc;
/*
* the target class does not belong to us so just return CMPI_RC_OK
*/
if (!op) {
CMSetStatusWithChars( _broker, &rc, CMPI_RC_OK, NULL );
return rc;
}
/*
* create new object path of association
*/
rop = CMNewObjectPath(_broker,
CMGetCharsPtr(CMGetNameSpace(ref, &rc), NULL),
_thisClassName, &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
*/
if (!rc.rc)
while (CMHasNext(en, &rc)) {
/*
* get the object path
*/
data = CMGetNext(en, &rc);
/*
* create new instance of the association
*/
ci = CMNewInstance(_broker, rop, &rc);
/*
* get name of the target class
*/
targetName = get_assoc_targetClass_Name(_broker,
ref,
_RefLeftClass,
_RefRightClass, &rc);
/*
* set the properties of the association instance depending on the
* constellation of the source class (parameter ref) and the target
* class (see targetName)
*/
if (strcmp(targetName, "CMPI_TEST_Person") == 0) {
CMSetProperty(ci,
"model", (CMPIValue *) & (data.value.ref), CMPI_ref);
CMSetProperty(ci, "driver", (CMPIValue *) & (ref), CMPI_ref);
} else if (strcmp(targetName, "CMPI_TEST_Vehicle") == 0) {
CMSetProperty(ci,
"model", (CMPIValue *) & (data.value.ref), CMPI_ref);
CMSetProperty(ci, "driver", (CMPIValue *) & (ref), CMPI_ref);
}
/*
* get object path of association instance
*/
cop = CMGetObjectPath(ci, &rc);
/*
* set namespace in object path of association
*/
CMSetNameSpace(cop, CMGetCharsPtr(CMGetNameSpace(ref, &rc), NULL));
/*
* and return the association object path as result of the
* referenceNames() call
*/
CMReturnObjectPath(rslt, cop);
}
return rc;
}
/*****************************************************************************
* Gets a specific xen resource identified by the CIM Instance passed in
*
* @param in broker - CMPI Broker services
* @param in ft - xen backend provider function table
* @param in res_id - resource identifying xen object being requested
* @param in caller_id - CIM Caller's credentials
* @param in properties - CIM properties caller's interested in
* @param out res - xen provider resource
* @return CMPIrc error codes
*****************************************************************************/
CMPIrc prov_pxy_get(
const CMPIBroker *broker,
const XenProviderInstanceFT* ft,
const void *res_id,
struct xen_call_context * caller_id,
const char **properties,
void **res
)
{
CMPIInstance *inst = (CMPIInstance *)res_id;
xen_utils_session *session = NULL;
CMPIData data;
static CMPIrc rc = CMPI_RC_OK;
char *res_uuid=NULL;
CMPIStatus status = {CMPI_RC_OK, NULL};
(void)properties;
CMPIObjectPath *op = CMGetObjectPath(inst, &status);
CMPIString *cn = CMGetClassName(op, &status);
if(CMIsNullObject(inst) || res == NULL) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR,("Error get(): inst or res is NULL"));
return CMPI_RC_ERR_FAILED;
}
const char *key_prop = ft->xen_resource_get_key_property(broker,
CMGetCharPtr(cn));
data = CMGetProperty(inst, key_prop ,&status);
if((status.rc != CMPI_RC_OK) || CMIsNullValue(data)) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR,
("Error key_property %s couldnt be found for class %s",
key_prop, CMGetCharPtr(cn)));
return CMPI_RC_ERR_INVALID_PARAMETER;
}
/* Extract the resource identifier string from the CMPIString. */
res_uuid = CMGetCharPtr(data.value.string);
if(res_uuid == NULL) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("Unable to extrace resource identifier string"));
return CMPI_RC_ERR_FAILED;
}
if(!xen_utils_validate_session(&session, caller_id)) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("Unable to establish connection with Xen"));
return CMPI_RC_ERR_FAILED;
}
provider_resource *prov_res = calloc(1, sizeof(provider_resource));
if(prov_res == NULL) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("Out of memory"));
return CMPI_RC_ERR_FAILED;
}
prov_res->broker = broker;
prov_res->classname = CMGetCharPtr(cn);
prov_res->session = session;
prov_res->cleanupsession = true;
rc = ft->xen_resource_record_get_from_id(res_uuid, session, prov_res);
if(rc != CMPI_RC_OK)
{
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR,("Error get(): get_xen_resource_record_from_id failed"));
ft->xen_resource_record_cleanup(prov_res);
xen_utils_cleanup_session(session);
free(prov_res);
return rc;
}
*res = (void *)prov_res;
rc = CMPI_RC_OK;
return rc;
}
CMPIStatus TestCMPIBrokerInstanceProviderCreateInstance (CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * cop,
const CMPIInstance * ci)
{
const CMPIString* retNamespace;
const CMPIString* retClassname;
CMPIString* type;
const char* str1;
const char* str2;
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIData retData;
CMPIObjectPath *obj;
CMPIBoolean bol = 0;
PROV_LOG_OPEN (_ClassName, _ProviderLocation);
PROV_LOG("CreateInstance");
retNamespace = CMGetNameSpace(cop, &rc);
retClassname = CMGetClassName(cop, &rc);
str1 = CMGetCharsPtr(retNamespace, &rc);
str2 = CMGetCharsPtr(retClassname, &rc);
PROV_LOG("++++Obtained Namespace : (%s) Class (%s)", str1, str2);
if(ci)
{
/* Test to increase coverage in Broker_Enc.cpp*/
type = CDToString (_broker, ci, &rc);
PROV_LOG ("++++ Passing CMPIInstance with CMPI_InstanceOnStack_Ftab "
"to mbEncToString successes : "
"(%s)",
strCMPIStatus (rc));
type = CDGetType (_broker, ci, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIInstance"
" : (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
bol = CDIsOfType (_broker, ci, "CMPIInstance", &rc);
if ( bol )
{
PROV_LOG ("++++ CDIsOfType for CMPIInstance with "
"CMPI_InstanceOnStack_Ftab status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
type = CDToString (_broker, cop, &rc);
PROV_LOG ("++++ Passing CMPIObjectPath with "
"CMPI_ObjectPathOnStack_Ftab to mbEncToString successes : (%s)",
strCMPIStatus (rc));
type = CDGetType (_broker, cop, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type "
"CMPIObjectPath : (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
bol = CDIsOfType (_broker, cop, "CMPIObjectPath", &rc);
if ( bol )
{
PROV_LOG ("++++ CDIsOfType for CMPIObjectPath with "
"CMPI_ObjectPathOnStack_Ftab status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
type = CDGetType (_broker, rslt, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type "
"CMPIResult with CMPI_ResultRefOnStack_Ftab : (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
bol = CDIsOfType (_broker, rslt, "CMPIResult", &rc);
if ( bol )
{
PROV_LOG ("++++ CDIsOfType for CMPIResult with "
"CMPI_ResultRefOnStack_Ftab status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
_inst = CMClone(ci, &rc);
PROV_LOG("++++ Status of CMClone(ci) : (%s)",
strCMPIStatus(rc));
CMSetObjectPath (_inst, cop);
PROV_LOG("++++ Status of CMSetObjectPath(_inst) : (%s)",
strCMPIStatus(rc));
_setProperty1(_inst, "*");
retData = CMGetProperty(_inst, "n64", &rc);
PROV_LOG("++++ Status of CMGetProperty : (%s)",
strCMPIStatus(rc));
PROV_LOG("n64 = %" PEGASUS_64BIT_CONVERSION_WIDTH "u",
retData.value.uint64);
retData = CMGetProperty(_inst, "n32", &rc);
PROV_LOG("++++ Status of CMGetProperty : (%s)",
strCMPIStatus(rc));
PROV_LOG("n32 = %d", retData.value.uint32);
obj = CMGetObjectPath(_inst, &rc);
PROV_LOG("++++ Status of CMGetObjectPath : (%s)",
strCMPIStatus(rc));
retNamespace = CMGetNameSpace(obj, &rc);
PROV_LOG("++++ Status of CMGetNameSpace : (%s)",
strCMPIStatus(rc));
retClassname = CMGetClassName(obj, &rc);
PROV_LOG("++++ Status of CMGetClassName : (%s)",
strCMPIStatus(rc));
str1 = CMGetCharsPtr(retNamespace, &rc);
PROV_LOG("++++ Status of CMGetCharsPtr : (%s)",
strCMPIStatus(rc));
str2 = CMGetCharsPtr(retClassname, &rc);
PROV_LOG("++++ Status of CMGetCharsPtr : (%s)",
strCMPIStatus(rc));
PROV_LOG("++++Namespace (_inst): (%s) Class (*%s)", str1, str2);
retData = CMGetProperty(_inst, "n64", &rc);
PROV_LOG("++++ Status of CMGetProperty : (%s)",
strCMPIStatus(rc));
PROV_LOG("n64 = %" PEGASUS_64BIT_CONVERSION_WIDTH "u",
retData.value.uint64);
PROV_LOG_CLOSE ();
CMReturnObjectPath(rslt, cop);
CMReturnDone(rslt);
CMReturn (CMPI_RC_OK);
}
else
{
PROV_LOG_CLOSE ();
CMReturn (CMPI_RC_ERR_NOT_SUPPORTED);
}
}
static CMPIStatus raise_indication(const CMPIBroker *broker,
const CMPIContext *ctx,
const CMPIObjectPath *ref,
const CMPIInstance *ind)
{
struct std_indication_ctx *_ctx = NULL;
CMPIStatus s = {CMPI_RC_OK, NULL};
struct ind_args *args = NULL;
CMPIObjectPath *_ref = NULL;
_ctx = malloc(sizeof(struct std_indication_ctx));
if (_ctx == NULL) {
cu_statusf(broker, &s,
CMPI_RC_ERR_FAILED,
"Unable to allocate indication context");
goto out;
}
_ctx->brkr = broker;
_ctx->handler = NULL;
_ctx->filters = filters;
_ctx->enabled = 1;
args = malloc(sizeof(struct ind_args));
if (args == NULL) {
cu_statusf(broker, &s,
CMPI_RC_ERR_FAILED,
"Unable to allocate ind_args");
goto out;
}
_ref = CMGetObjectPath(ind, &s);
if (_ref == NULL) {
cu_statusf(broker, &s,
CMPI_RC_ERR_FAILED,
"Got a null object path");
goto out;
}
/* FIXME: This is a Pegasus work around. Pegsus loses the namespace
when an ObjectPath is pulled from an instance */
CMSetNameSpace(_ref, "root/virt");
args->ns = strdup(NAMESPACE(_ref));
args->classname = strdup(CLASSNAME(_ref));
args->_ctx = _ctx;
/* This is a workaround for Pegasus, it loses its objectpath by
CMGetObjectPath. So set it back. */
ind->ft->setObjectPath((CMPIInstance *)ind, _ref);
s = stdi_deliver(broker, ctx, args, (CMPIInstance *)ind);
if (s.rc == CMPI_RC_OK) {
CU_DEBUG("Indication delivered");
} else {
if (s.msg == NULL) {
CU_DEBUG("Not delivered: msg is NULL.");
} else {
CU_DEBUG("Not delivered: %s", CMGetCharPtr(s.msg));
}
}
out:
if (args != NULL)
stdi_free_ind_args(&args);
if (_ctx != NULL)
free(_ctx);
return s;
}
static int
_testCMPIInstance()
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIInstance *instance = NULL;
CMPIInstance *clonedInstance = NULL;
CMPIObjectPath *objPath = NULL;
CMPIObjectPath *newObjPath = NULL;
CMPIObjectPath *returnedObjPath = NULL;
CMPIData returnedData1;
CMPIData returnedData2;
CMPIData clonedData1;
CMPIString *returnedName = NULL;
unsigned int count = 0;
const char *name1 = "firstPropertyName";
CMPIValue value1;
const char *name2 = "secondPropertyName";
CMPIValue value2;
CMPIType type = CMPI_uint64;
CMPIBoolean dataEqual = 0;
CMPIBoolean objectPathEqual = 0;
CMPIBoolean cloneSuccessful = 0;
CMPIString *beforeObjPath = NULL;
CMPIString *afterObjPath = NULL;
const char *beforeString = NULL;
const char *afterString = NULL;
objPath = make_ObjectPath(_broker, _Namespace, _ClassName);
instance = make_Instance(objPath);
value1.uint32 = 10;
rc = CMSetProperty(instance, name1, &value1, type);
value2.uint32 = 20;
rc = CMSetProperty(instance, name2, &value2, type);
count = CMGetPropertyCount(instance, &rc);
returnedData1 = CMGetProperty(instance, name1, &rc);
if (returnedData1.value.uint32 == 10) {
dataEqual = 1;
}
returnedData2 = CMGetPropertyAt(instance, 2, &returnedName, &rc);
if (returnedData2.value.uint32 == 20) {
dataEqual = 1;
}
newObjPath = make_ObjectPath(_broker, _Namespace, _ClassName);
returnedObjPath = CMGetObjectPath(instance, &rc);
beforeObjPath = CMObjectPathToString(returnedObjPath, &rc);
beforeString = CMGetCharsPtr(beforeObjPath, &rc);
rc = CMSetNameSpace(newObjPath, "newNamespace");
rc = CMSetObjectPath(instance, newObjPath);
returnedObjPath = CMGetObjectPath(instance, &rc);
afterObjPath = CMObjectPathToString(returnedObjPath, &rc);
afterString = CMGetCharsPtr(afterObjPath, &rc);
afterString = CMGetCharsPtr(CMGetNameSpace(returnedObjPath, &rc), &rc);
if (strcmp("newNamespace", afterString) == 0) {
objectPathEqual = 1;
}
clonedInstance = instance->ft->clone(instance, &rc);
clonedData1 = CMGetProperty(clonedInstance, name1, &rc);
rc = clonedInstance->ft->release(clonedInstance);
if (returnedData1.value.uint32 == clonedData1.value.uint32) {
cloneSuccessful = 1;
} else {
cloneSuccessful = 0;
}
CMGetProperty(instance, "noProperty", &rc);
if (rc.rc != CMPI_RC_ERR_NO_SUCH_PROPERTY) {
return 1;
}
CMGetPropertyAt(instance, 100, &returnedName, &rc);
if (rc.rc != CMPI_RC_ERR_NO_SUCH_PROPERTY) {
return 1;
}
rc = instance->ft->release(instance);
return 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);
}
static CMPIStatus __rft_returnInstance(const CMPIResult * result,
const CMPIInstance * instance)
{
int size,isInst=isInstance(instance);
void *ptr;
NativeResult *r = (NativeResult*) result;
int releaseInstance=0;
CMPIStatus st={CMPI_RC_OK,NULL};
_SFCB_ENTER(TRACE_PROVIDERDRV, "__rft_returnInstance");
if (r->qs) {
int irc;
if (r->qs->where) {
r->qs->propSrc.data=(CMPIInstance *)instance;
irc=r->qs->where->ft->evaluate(r->qs->where,&r->qs->propSrc);
if (irc==1) {
if (r->qs->allProps==0) {
instance=
r->qs->ft->cloneAndFilter(r->qs,(CMPIInstance *)instance,CMGetObjectPath(instance, NULL),r->qs->keys);
releaseInstance=1;
}
}
else CMReturn(CMPI_RC_OK);
}
else {
if (r->qs->allProps==0) {
instance=r->qs->ft->cloneAndFilter(r->qs,(CMPIInstance *)instance,CMGetObjectPath(instance,NULL), r->qs->keys);
releaseInstance=1;
}
}
}
if (r->legacy) {
CMPIValue v;
CMPIStatus rc;
_SFCB_TRACE(1,("--- Legacy Mode"));
if(isInst) {
v.inst = CMClone(instance,NULL);
memLinkInstance(v.inst);
}
else v.inst = (CMPIInstance *) instance;
rc=returnData(result, &v, CMPI_instance);
if (releaseInstance) instance->ft->release((CMPIInstance*)instance);
_SFCB_RETURN(rc);
}
if (isInst) {
size=getInstanceSerializedSize(instance);
ptr=nextResultBufferPos(r, MSG_SEG_INSTANCE, (unsigned long)size);
_SFCB_TRACE(1,("--- Moving instance %d",size));
getSerializedInstance(instance,ptr); /* memcpy inst to ptr */
}
else {
size=getConstClassSerializedSize((CMPIConstClass*)instance);
ptr=nextResultBufferPos(r, MSG_SEG_CONSTCLASS, (unsigned long)size);
_SFCB_TRACE(1,("--- Moving class %d",size));
getSerializedConstClass((CMPIConstClass*)instance,ptr);
}
if (releaseInstance) instance->ft->release((CMPIInstance*)instance);
_SFCB_RETURN(st);
}
CMPIStatus TestCMPIBrokerInstanceProviderGetInstance (CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * cop,
const char **properties)
{
CMPIStatus rc = {CMPI_RC_OK, NULL};
CMPIString* retNamespace;
CMPIString* retClassname;
CMPIString* type;
CMPIData retData;
CMPIObjectPath* obj;
CMPIBoolean bol = 0;
const char* str1;
const char* str2;
PROV_LOG_OPEN (_ClassName, _ProviderLocation);
PROV_LOG("GetInstance");
PROV_LOG("++++Namespace ");
obj = CMGetObjectPath(_inst, &rc);
PROV_LOG("++++ Status of CMGetObjectPath : (%s)",
strCMPIStatus(rc));
retNamespace = CMGetNameSpace(obj, &rc);
PROV_LOG("++++ Status of CMGetNameSpace : (%s)",
strCMPIStatus(rc));
retClassname = CMGetClassName(obj, &rc);
PROV_LOG("++++ Status of CMGetClassName : (%s)",
strCMPIStatus(rc));
str1 = CMGetCharsPtr(retNamespace, &rc);
PROV_LOG("++++ Status of CMGetCharsPtr : (%s)",
strCMPIStatus(rc));
str2 = CMGetCharsPtr(retClassname, &rc);
PROV_LOG("++++ Status of CMGetCharsPtr : (%s)",
strCMPIStatus(rc));
retData = CMGetProperty(_inst, "n64", &rc);
PROV_LOG("++++ Status of CMGetProperty : (%s)",
strCMPIStatus(rc));
PROV_LOG("n64 = %" PEGASUS_64BIT_CONVERSION_WIDTH "u",
retData.value.uint64);
/* Test cases for increasing coverage in CMPI_BrokerEnc.cpp*/
type = CDGetType (_broker, rslt, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type "
"CMPIResult with CMPI_ResultInstOnStack_Ftab : (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
bol = CDIsOfType (_broker, rslt, "CMPIResult", &rc);
if ( bol )
{
PROV_LOG ("++++ CDIsOfType for CMPIResult with "
"CMPI_ResultInstOnStack_Ftab status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
PROV_LOG_CLOSE();
if (_inst)
{
CMReturnInstance(rslt, _inst);
CMReturnDone(rslt);
CMReturn (CMPI_RC_OK);
}
else
{
CMReturn (CMPI_RC_ERR_NOT_SUPPORTED);
}
}
CMPIStatus KBase_FromInstance(KBase* self, const CMPIInstance* ci)
{
CMPIObjectPath* cop;
CMPIString* cn;
CMPIString* ns;
CMPIStatus st = KSTATUS_INIT;
CMPICount count;
CMPICount i;
KValue* kv;
if (!self || self->magic != KMAGIC)
KReturn(ERR_FAILED);
/* Get object path */
if (!(cop = CMGetObjectPath(ci, &st)))
return st;
/* Set namespace */
if (!(ns = CMGetNameSpace(cop, &st)))
return st;
self->ns = ns;
/* Get classname */
if (!(cn = CMGetClassName(cop, &st)))
return st;
/* For each property */
count = CMGetPropertyCount(ci, &st);
if (!KOkay(st))
return st;
for (i = 0; i < count; i++)
{
CMPIData cd;
CMPIString* pn = NULL;
KTag tag;
/* Get i-th property */
cd = CMGetPropertyAt(ci, i, &pn, &st);
if (!KOkay(st))
return st;
if (!pn)
KReturn(ERR_FAILED);
/* Find the given property */
if ((kv = _find_property(self, KChars(pn), &tag)))
{
_set_value(kv, tag, &cd);
}
}
KReturn(OK);
}
