int main()
{
CMCIClient *cc;
CMPIObjectPath * objectpath;
CMPIEnumeration * enumeration;
CMPIStatus status;
char *cim_host, *cim_host_passwd, *cim_host_userid;
/* Setup a connection to the CIMOM */
cim_host = getenv("CIM_HOST");
if (cim_host == NULL)
cim_host = "localhost";
cim_host_userid = getenv("CIM_HOST_USERID");
if (cim_host_userid == NULL)
cim_host_userid = "root";
cim_host_passwd = getenv("CIM_HOST_PASSWD");
if (cim_host_passwd == NULL)
cim_host_passwd = "password";
cc = cmciConnect(cim_host, NULL, "5988",
cim_host_userid, cim_host_passwd, NULL);
/* Test references() */
printf("\n----------------------------------------------------------\n");
printf("--> Testing references() ...\n");
objectpath = newCMPIObjectPath("root/cimv2", "Linux_ComputerSystem", NULL);
printf( "--> Adding keys to object path\n" );
CMAddKey(objectpath, "CreationClassName", "Linux_ComputerSystem", CMPI_chars);
CMAddKey(objectpath, "Name", "localhost.localdomain", CMPI_chars);
printf( "--> Enumerating Instances\n" );
enumeration = cc->ft->references(cc, objectpath, NULL, NULL, 0, NULL, &status);
printf( "--> Print the results \n" );
printf( "--> references() rc=%d, msg=%s\n",
status.rc, (status.msg)? (char *)status.msg->hdl : NULL);
if (!status.rc) {
printf("--> result(s):\n");
while (enumeration->ft->hasNext(enumeration, NULL))
{
CMPIData data = enumeration->ft->getNext(enumeration, NULL);
showInstance(data.value.inst);
}
}
if (enumeration) CMRelease(enumeration);
if (objectpath) CMRelease(objectpath);
if (status.msg) CMRelease(status.msg);
if (cc) CMRelease(cc);
return 0;
}
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;
}
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;
}
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 *
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);
}
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 * _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;
}
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 *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 *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;
}
void createPath(CMPIObjectPath **op, XtokInstanceName *p)
{
int i;
CMPIValue val,*valp;
CMPIType type;
XtokKeyBinding *b;
*op = newCMPIObjectPath(NULL, p->className, NULL);
for (b = p->bindings.first; b; b = b->next) {
valp = getKeyValueTypePtr(b->type,
b->val.keyValue.value,
&b->val.ref,
&val, &type);
CMAddKey(*op, b->name, valp, type);
if (type == CMPI_ref) {
CMRelease(valp->ref);
}
}
}
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;
}
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;
}
int main()
{
CMCIClient * cc;
CMPIObjectPath * objectpath;
CMPIStatus status;
CMPIArgs * args;
char *cim_host, *cim_host_passwd, *cim_host_userid;
CMPIData retval;
CMPIValue arg;
/* Setup a connection to the CIMOM */
cim_host = getenv("CIM_HOST");
if (cim_host == NULL)
cim_host = "localhost";
cim_host_userid = getenv("CIM_HOST_USERID");
if (cim_host_userid == NULL)
cim_host_userid = "root";
cim_host_passwd = getenv("CIM_HOST_PASSWD");
if (cim_host_passwd == NULL)
cim_host_passwd = "password";
cc = cmciConnect(cim_host, NULL, "5988",
cim_host_userid, cim_host_passwd, NULL);
printf("\n----------------------------------------------------------\n");
printf("Testing invokeMethod() ...\n");
objectpath = newCMPIObjectPath("root/cimv2", "TST_MethodProperties", NULL);
CMAddKey(objectpath, "CreationClassName", "TST_MethodProperties", CMPI_chars);
CMAddKey(objectpath, "Id", "Instance #1", CMPI_chars);
/*---------------------------------------------------------------------*/
printf("+++T1:passing IN int16_t argument\n");
args = newCMPIArgs(NULL);
arg.sint16 = 65535;
args->ft->addArg(args, "Property_int16", &arg, CMPI_sint16);
retval = cc->ft->invokeMethod(
cc, objectpath, "Method_sint16_in", args, NULL, &status);
/* Print the results */
printf( "invokeMethod() rc=%d, msg=%s\n",
status.rc, (status.msg)? (char *)status.msg->hdl : NULL);
if (args) CMRelease(args);
if (status.msg) CMRelease(status.msg);
if (!status.rc) {
char *cv = value2Chars(retval.type,&(retval.value));
printf("result(s):\n\treturn value:%s\n", cv);
if (cv != NULL) free(cv);
}
else
goto done;
/*---------------------------------------------------------------------*/
printf("+++T2:returning int16_t value\n");
retval = cc->ft->invokeMethod(
cc, objectpath, "Method_sint16", NULL, NULL, &status);
/* Print the results */
printf( "invokeMethod() rc=%d, msg=%s\n",
status.rc, (status.msg)? (char *)status.msg->hdl : NULL);
if (!status.rc) {
char *cv = value2Chars(retval.type,&(retval.value));
printf("result(s):\n\treturn value:%s\n", cv);
if (cv != NULL) free(cv);
}
if (status.msg) CMRelease(status.msg);
/*---------------------------------------------------------------------*/
printf("+++ T3:passing OUT int16_t value\n");
args = newCMPIArgs(NULL);
retval = cc->ft->invokeMethod(
cc, objectpath, "Method_sint16_out", NULL, args, &status);
/* Print the results */
printf( "invokeMethod() rc=%d, msg=%s\n",
status.rc, (status.msg)? (char *)status.msg->hdl : NULL);
if (args) {
char *cv;
CMPIData data = CMGetArg(args, "Arg_int16", NULL);
if (!CMIsNullValue(data))
{
cv = value2Chars(data.type,&(data.value));
printf("\n result(s): OUT Parm:Arg_int16 type: %d value:%s\n",
data.type, cv);
if (cv != NULL) free(cv);
CMRelease(args);
}
}
if (status.msg) CMRelease(status.msg);
if (!status.rc) {
char *cv = value2Chars(retval.type,&(retval.value));
printf("result(s):\n\treturn value:%s\n", cv);
if (cv != NULL) free(cv);
}
else
goto done;
/*---------------------------------------------------------------------*/
done:
if (objectpath) CMRelease(objectpath);
if (cc) CMRelease(cc);
return 0;
}
int main()
{
CIMCEnv *ce;
char *msg = NULL;
int rc;
CIMCStatus status;
CIMCClient *client;
CIMCObjectPath *op, *objectpath_r;
CMPIConstClass* clas ;
CMPIInstance *instance;
CIMCString *path;
CMPIString * classname ;
CIMCData data;
CMPIData cdata ;
char *cim_host, *cim_host_passwd, *cim_host_userid , *cim_host_port;
int i = 0 ;
int retc = 0;
int count = 0;
int numproperties = 0;
CMPIString * propertyname;
char *cv;
/* Setup a connection to the CIMOM */
cim_host = getenv("CIM_HOST");
if (cim_host == NULL)
cim_host = "localhost";
cim_host_userid = getenv("CIM_HOST_USERID");
if (cim_host_userid == NULL)
cim_host_userid = "root";
cim_host_passwd = getenv("CIM_HOST_PASSWD");
if (cim_host_passwd == NULL)
cim_host_passwd = "password";
cim_host_port = getenv("CIM_HOST_PORT");
if (cim_host_port == NULL)
cim_host_port = "5988";
printf(" Testing Get instance \n") ;
printf(" using SfcbLocal interface : host = %s userid = %s\n",
cim_host,cim_host_userid) ;
ce = NewCIMCEnv("SfcbLocal",0,&rc,&msg);
if(ce == NULL) {
printf(" local connect failed call to NewCIMCEnv rc = %d , message = [%s] \n",retc,msg) ;
return 1;
}
client = ce->ft->connect(ce, cim_host , "http", cim_host_port, cim_host_userid, cim_host_passwd , &status);
op = ce->ft->newObjectPath(ce, "root/cimv2", "Linux_ComputerSystem" , &status);
CMAddKey(op, "CreationClassName", "Linux_ComputerSystem", CMPI_chars);
CMAddKey(op, "Name", "localhost.localdomain", CMPI_chars);
instance = client->ft->getInstance(client, op, 0, NULL, &status);
/* Print the results */
printf( "getInstance() rc=%d, msg=%s\n",
status.rc, (status.msg)? (char *)status.msg->hdl : NULL);
if (!status.rc) {
printf("result:\n");
showInstance(instance);
}
if (instance) CMRelease(instance);
if (op) CMRelease(op);
if (status.msg) CMRelease(status.msg);
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);
}
/**
initialize function will create three instances and add them to array.
"numOfInst" will represent the number of instances in the array.
*/
static void initialize()
{
CMPIStatus rc = { CMPI_RC_OK, NULL};
CMPIArray *arr_ptr;
CMPIValue value1, value2, value_inst1, value_inst2;
CMPIInstance *instance1, *instance2, *instance3;
CMPIObjectPath *cop1, *cop2, *cop3;
CMPIObjectPath *embeddedObjPath;
CMPIInstance *emInst1;
CMPIValue valueEmInst;
value1.uint8 = 1;
value2.string = CMNewString(_broker, "\\x0C9C\\x0CA8\\x0CCD\\x0CAE"
"\\x0CA6\\x0CBF\\x0CA8\\x0CA6 \\x0CB6\\x0CC1\\x0CAD\\x0CBE"
"\\x0CB6\\x0CAF\\x0C97\\x0CB3\\x0CC1", &rc);
/* Create an embedded instance to be returned as embedded object
This is an instance of a class that does not exist which
is legal in DMTF specs.
*/
embeddedObjPath = CMNewObjectPath (
_broker,
"test/TestProvider",
"TestCMPI_EmbeddedNoClass",
&rc);
assert(rc.rc == CMPI_RC_OK);
valueEmInst.uint32 = 1;
rc = CMAddKey(embeddedObjPath,"id",&valueEmInst, CMPI_uint32);
assert(rc.rc == CMPI_RC_OK);
emInst1 = CMNewInstance(_broker, embeddedObjPath, &rc);
assert(rc.rc == CMPI_RC_OK);
valueEmInst.uint32 = 1999;
rc = CMSetProperty(emInst1, "id", &valueEmInst, CMPI_uint32);
assert(rc.rc == CMPI_RC_OK);
// set the new instance into a value container
valueEmInst.inst = emInst1;
/* create a new array to hold the instances created */
arr_ptr = CMNewArray(_broker, initArraySize, CMPI_instance, &rc);
/* create object path for instance1 */
cop1 = CMNewObjectPath(
_broker,
"root/SampleProvider",
_ClassName,
&rc);
/* add key (with its value) to object path to recognize instance uniquely */
CMAddKey(cop1, "Identifier", (CMPIValue *)&value1, CMPI_uint8);
/* if created object path is not null then create new instance */
if(!CMIsNullObject(cop1))
{
instance1 = CMNewInstance(_broker,
cop1,
&rc);
/* set the properties for newly created instance */
CMSetProperty(instance1, "Identifier",&value1, CMPI_uint8);
CMSetProperty(instance1, "Message", &value2, CMPI_string);
CMSetProperty(instance1, "emObject", &valueEmInst, CMPI_instance);
value_inst1.inst = instance1;
/* assign the created instance to array created */
rc = CMSetArrayElementAt(
arr_ptr,
numOfInst,
&value_inst1,
CMPI_instance);
/* set the validity of instance to be true.
Validity gets false if instance gets deleted using deleteInstance(). */
valid[numOfInst] = 1;
numOfInst++;
}
/* create instance 2 and add to array */
value1.uint8 = 2;
value2.string = CMNewString(_broker, "\\x0CA8\\x0CBE\\x0CB3"
"\\x0CC6\\x0CA6\\x0CBF\\x0CA8", &rc);
cop2 = CMNewObjectPath(
_broker,
"root/SampleProvider",
_ClassName,
&rc);
CMAddKey(cop2, "Identifier", (CMPIValue *)&value1, CMPI_uint8);
if(!CMIsNullObject(cop2))
{
instance2 = CMNewInstance(_broker,
cop2,
&rc);
CMSetProperty(instance2, "Identifier", &value1, CMPI_uint8);
CMSetProperty(instance2, "Message", &value2, CMPI_string);
value_inst2.inst = instance2;
rc = CMSetArrayElementAt(arr_ptr,
numOfInst,
&value_inst2,
CMPI_instance);
valid[numOfInst] = 1;
numOfInst++;
}
/* create instance 3 and add to array */
value1.uint8 = 3;
value2.string = CMNewString(_broker, "\\x0C9C", &rc);
cop3 = CMNewObjectPath(
_broker,
"root/SampleProvider",
_ClassName,
&rc);
CMAddKey(cop3, "Identifier", (CMPIValue *)&value1, CMPI_uint8);
if(!CMIsNullObject(cop3))
{
instance3 = CMNewInstance(_broker,
cop3,
&rc);
CMSetProperty(instance3, "Identifier", &value1, CMPI_uint8);
CMSetProperty(instance3, "Message", &value2, CMPI_string);
CMSetProperty(instance3, "emObject", &valueEmInst, CMPI_instance);
value_inst2.inst = instance3;
rc = CMSetArrayElementAt(arr_ptr,
numOfInst,
&value_inst2,
CMPI_instance);
valid[numOfInst] = 1;
numOfInst++;
}
/* clone the array which contains instances. */
clone_arr_ptr = arr_ptr->ft->clone(arr_ptr, &rc);
}
static int
_testCMPIObjectPath()
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIObjectPath *objPath = NULL;
CMPIObjectPath *clonedObjPath = NULL;
CMPIObjectPath *otherObjPath = NULL;
CMPIObjectPath *fakeObjPath = NULL;
const char *hostName = "HOSTNAME";
const char *nameSpace = "root/dummy";
const char *className = "classname";
CMPIString *returnedHostname = NULL;
CMPIBoolean equalHostname = 0;
CMPIString *returnedNamespace = NULL;
CMPIBoolean equalNamespace = 0;
CMPIString *returnedClassName;
CMPIBoolean equalClassName = 0;
CMPIString *returnedObjectPath;
CMPIBoolean cloneSuccessful = 0;
CMPIBoolean getKeySuccessful = 0;
CMPIBoolean getKeyCountSuccessful = 0;
CMPIBoolean getKeyAtSuccessful = 0;
const char *objectPath1 = NULL;
const char *objectPath2 = NULL;
CMPIData data;
CMPIValue value;
unsigned int keyCount = 0;
objPath = make_ObjectPath(_broker, _Namespace, _ClassName);
rc = CMSetHostname(objPath, hostName);
returnedHostname = CMGetHostname(objPath, &rc);
if (strcmp(hostName, CMGetCharsPtr(returnedHostname, &rc)) == 0) {
equalHostname = 1;
}
rc = CMSetNameSpace(objPath, nameSpace);
returnedNamespace = CMGetNameSpace(objPath, &rc);
if (strcmp(nameSpace, CMGetCharsPtr(returnedNamespace, &rc)) == 0) {
equalNamespace = 1;
}
rc = CMSetClassName(objPath, className);
returnedClassName = CMGetClassName(objPath, &rc);
if (strcmp(className, CMGetCharsPtr(returnedClassName, &rc)) == 0) {
equalClassName = 1;
}
otherObjPath = make_ObjectPath(_broker, _Namespace, _ClassName);
returnedNamespace = CMGetNameSpace(otherObjPath, &rc);
rc = CMSetNameSpaceFromObjectPath(otherObjPath, objPath);
returnedNamespace = CMGetNameSpace(otherObjPath, &rc);
if (strcmp(nameSpace, CMGetCharsPtr(returnedNamespace, &rc)) == 0) {
equalNamespace = 1;
}
returnedHostname = CMGetHostname(otherObjPath, &rc);
rc = CMSetHostAndNameSpaceFromObjectPath(otherObjPath, objPath);
returnedHostname = CMGetHostname(otherObjPath, &rc);
if (strcmp(hostName, CMGetCharsPtr(returnedHostname, &rc)) == 0) {
equalHostname = 1;
}
returnedObjectPath = CMObjectPathToString(objPath, &rc);
objectPath1 = CMGetCharsPtr(returnedObjectPath, &rc);
clonedObjPath = objPath->ft->clone(objPath, &rc);
returnedObjectPath = CMObjectPathToString(clonedObjPath, &rc);
rc = clonedObjPath->ft->release(clonedObjPath);
objectPath2 = CMGetCharsPtr(returnedObjectPath, &rc);
if (strcmp(objectPath1, objectPath2) == 0) {
cloneSuccessful = 1;
} else {
cloneSuccessful = 0;
}
fakeObjPath = CMNewObjectPath(_broker, "root#cimv2",
"Sample_Instance", &rc);
rc = CMAddKey(fakeObjPath, "ElementName",
(CMPIValue *) "Fake", CMPI_chars);
rc = CMAddKey(otherObjPath, "ElementName1",
(CMPIValue *) "otherObjPath", CMPI_chars);
data = CMGetKey(fakeObjPath, "ElementName", &rc);
if (strcmp(CMGetCharsPtr(data.value.string, &rc), "Fake") == 0) {
getKeySuccessful = 1;
}
keyCount = CMGetKeyCount(fakeObjPath, &rc);
if (keyCount == 1) {
getKeyCountSuccessful = 1;
}
data = CMGetKeyAt(fakeObjPath, 0, NULL, &rc);
if (rc.rc == 0) {
getKeyAtSuccessful = 1;
}
value.uint16 = 67;
rc = CMAddKey(fakeObjPath, "Numeric_key_unsigned",
(CMPIValue *) & value, CMPI_uint16);
data = CMGetKey(fakeObjPath, "Numeric_key_unsigned", &rc);
value.sint16 = -67;
rc = CMAddKey(fakeObjPath, "Numeric_key_signed",
(CMPIValue *) & value, CMPI_sint16);
data = CMGetKey(fakeObjPath, "Numeric_key_signed", &rc);
value.boolean = 1;
rc = CMAddKey(fakeObjPath, "Boolean_key",
(CMPIValue *) & value, CMPI_boolean);
data = CMGetKey(fakeObjPath, "Boolean_key", &rc);
CMGetKeyAt(objPath, 500, NULL, &rc);
if (rc.rc != CMPI_RC_ERR_NO_SUCH_PROPERTY) {
return 1;
}
rc = objPath->ft->release(objPath);
rc = fakeObjPath->ft->release(fakeObjPath);
return 0;
}
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);
}
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;
}
int main()
{
CMCIClient *cc;
CMPIObjectPath *objectpath, *objectpath2;
CMPIEnumeration *enumeration;
CMPIInstance *instance1;
CMPIStatus status;
int i;
char *cim_host, *cim_host_passwd, *cim_host_userid;
void *curbrk;
/* Setup a connection to the CIMOM */
cim_host = getenv("CIM_HOST");
if (cim_host == NULL)
cim_host = "localhost";
cim_host_userid = getenv("CIM_HOST_USERID");
if (cim_host_userid == NULL)
cim_host_userid = "root";
cim_host_passwd = getenv("CIM_HOST_PASSWD");
if (cim_host_passwd == NULL)
cim_host_passwd = "password";
cc = cmciConnect(cim_host, NULL, "5988",
cim_host_userid, cim_host_passwd, NULL);
objectpath = newCMPIObjectPath("root/iicmv1",
"IICM_MAPAdminDomain", NULL);
CMAddKey(objectpath, "CreationClassName",
"IICM_MAPAdminDomain", CMPI_chars);
CMAddKey(objectpath, "Name", "admin1", CMPI_chars);
objectpath2 = newCMPIObjectPath( "root/iicmv1", "CIM_Slot", NULL);
CMAddKey(objectpath2, "CreationClassName", "CIM_Slot", CMPI_chars);
CMAddKey(objectpath2, "Tag", "IBM Asset Tag:0000004", CMPI_chars);
for (i = 0; i < NUM_ITERS; i++) {
curbrk = (void *)sbrk(0);
instance1 = cc->ft->getInstance(cc, objectpath, 0, NULL, &status);
if (status.rc != 0) {
printf( "getInstance() rc=%d, msg=%s\n",
status.rc, (status.msg)? (char *)status.msg->hdl : NULL);
abort();
}
CMRelease(instance1);
if (verbose)
printf("after getInstance heap %p start %p\n", sbrk(0), curbrk);
enumeration = cc->ft->enumInstances(cc, objectpath, 0, NULL, &status);
if (status.rc != 0) {
printf( "enumInstance() rc=%d, msg=%s\n",
status.rc, (status.msg)? (char *)status.msg->hdl : NULL);
abort();
}
CMRelease(enumeration);
if (verbose)
printf("after enumInstances heap %p start %p\n", sbrk(0), curbrk);
enumeration = cc->ft->associators(cc, objectpath,
"CIM_SystemComponent", NULL, NULL, NULL, 0, NULL, &status);
if (status.rc != 0) {
printf( "associators() rc=%d, msg=%s\n",
status.rc, (status.msg)? (char *)status.msg->hdl : NULL);
abort();
}
CMRelease(enumeration);
if (verbose)
printf("after associators heap %p start %p\n", sbrk(0), curbrk);
enumeration = cc->ft->associatorNames( cc,
objectpath2, // The parent object?
"CIM_PackageInSlot", // assocClass
NULL, // resultClass
NULL, // role
NULL, // resultRole
&status); // return code
if (status.rc != 0) {
printf( "associatorNames() rc=%d, msg=%s\n",
status.rc, (status.msg)? (char *)status.msg->hdl : NULL);
abort();
}
CMRelease(enumeration);
if (verbose)
printf("after associatorNames heap %p start %p\n", sbrk(0), curbrk);
enumeration = cc->ft->enumInstanceNames(cc, objectpath2, &status);
if (status.rc != 0) {
printf( "enumInstanceNames() rc=%d, msg=%s\n",
status.rc, (status.msg)? (char *)status.msg->hdl : NULL);
abort();
}
CMRelease(enumeration);
if (verbose)
printf("after enumInstanceNames heap %p start %p\n", sbrk(0), curbrk);
enumeration = cc->ft->references(cc, objectpath,
NULL, NULL, 0, NULL, &status);
if (status.rc != 0) {
printf( "references() rc=%d, msg=%s\n",
status.rc, (status.msg)? (char *)status.msg->hdl : NULL);
abort();
}
CMRelease(enumeration);
if (verbose)
printf("after references heap %p start %p\n", sbrk(0), curbrk);
enumeration = cc->ft->referenceNames(cc, objectpath2, NULL, NULL, &status);
if (status.rc != 0) {
printf( "referenceNames() rc=%d, msg=%s\n",
status.rc, (status.msg)? (char *)status.msg->hdl : NULL);
abort();
}
CMRelease(enumeration);
if (verbose)
printf("after referenceNames heap %p start %p\n", sbrk(0), curbrk);
if (curbrk != (void *)sbrk(0)) {
fprintf(stderr, "+++ heap top changed from %p to %p\n",
curbrk, sbrk(0));
}
if (verbose || (i % 10) == 0)
printf ("+++ iteration %d complete, curbrk %p\n", i, curbrk);
}
if (objectpath) CMRelease(objectpath);
if (objectpath2) CMRelease(objectpath2);
if (status.msg) CMRelease(status.msg);
if (cc) CMRelease(cc);
return 0;
}
CMPIValue *
getKeyValueTypePtr(char *type, char *value, XtokValueReference * ref,
CMPIValue * val, CMPIType *typ, char *scopingNS)
{
if (type) {
if (strcasecmp(type, "string") == 0);
else if (strcasecmp(type, "boolean") == 0) {
*typ = CMPI_boolean;
if (strcasecmp(value, "true") == 0)
val->boolean = 1;
else
val->boolean = 0;
return val;
} else if (strcasecmp(type, "numeric") == 0) {
if (value[0] == '+' || value[0] == '-') {
*typ = CMPI_sint64;
sscanf(value, "%lld", &val->uint64);
} else {
sscanf(value, "%llu", &val->sint64);
*typ = CMPI_uint64;
}
return val;
} else if (strcasecmp(type, "ref") == 0) {
CMPIObjectPath *op;
char *hn = "",
*ns = "",
*cn;
CMPIType type;
CMPIValue v,
*valp;
int i,
m;
XtokInstanceName *in;
switch (ref->type) {
case typeValRef_InstancePath:
in = &ref->instancePath.instanceName;
hn = ref->instancePath.path.host.host;
ns = ref->instancePath.path.nameSpacePath;
break;
case typeValRef_LocalInstancePath:
in = &ref->localInstancePath.instanceName;
ns = ref->localInstancePath.path;
break;
case typeValRef_InstanceName:
in = &ref->instanceName;
ns = scopingNS;
break;
default:
mlogf(M_ERROR, M_SHOW, "%s(%d): unexpected reference type %d %x\n",
__FILE__, __LINE__, (int) ref->type, (int) ref->type);
abort();
}
cn = in->className;
op = TrackedCMPIObjectPath(ns, cn, NULL);
CMSetHostname(op, hn);
for (i = 0, m = in->bindings.next; i < m; i++) {
valp = getKeyValueTypePtr(in->bindings.keyBindings[i].type,
in->bindings.keyBindings[i].value,
&in->bindings.keyBindings[i].ref,
&v, &type, scopingNS);
CMAddKey(op, in->bindings.keyBindings[i].name, valp, type);
}
*typ = CMPI_ref;
val->ref = op;
return val;
}
}
*typ = CMPI_chars;
return (CMPIValue *) value;
}
int
main()
{
CIMCEnv *ce;
char *msg = NULL;
int rc;
CIMCStatus status;
CIMCClient *client;
CIMCObjectPath *op;
CMPIConstClass *clas;
CIMCEnumeration *enumeration;
CIMCString *path;
CMPIString *classname;
CIMCData data;
CMPIData cdata;
char *cim_host,
*cim_host_passwd,
*cim_host_userid,
*cim_host_port;
int i = 0;
int retc = 0;
int count = 0;
int numproperties = 0;
CMPIString *propertyname;
char *cv;
/*
* Setup a connection to the CIMOM
*/
cim_host = getenv("CIM_HOST");
if (cim_host == NULL)
cim_host = "localhost";
cim_host_userid = getenv("CIM_HOST_USERID");
if (cim_host_userid == NULL)
cim_host_userid = "root";
cim_host_passwd = getenv("CIM_HOST_PASSWD");
if (cim_host_passwd == NULL)
cim_host_passwd = "password";
cim_host_port = getenv("CIM_HOST_PORT");
if (cim_host_port == NULL)
cim_host_port = "5988";
printf(" Testing Associators \n");
printf(" using SfcbLocal interface : host = %s userid = %s\n",
cim_host, cim_host_userid);
ce = NewCIMCEnv("SfcbLocal", 0, &rc, &msg);
if (ce == NULL) {
printf
(" local connect failed call to NewCIMCEnv rc = %d , message = [%s] \n",
retc, msg);
return 1;
}
client =
ce->ft->connect(ce, cim_host, "http", cim_host_port, cim_host_userid,
cim_host_passwd, &status);
op = ce->ft->newObjectPath(ce, "root/cimv2", "TEST_Person", &status);
CMAddKey(op, "name", "Mike", CMPI_chars);
enumeration =
client->ft->associators(client, op, "TEST_Lineage", NULL, NULL, NULL,
0, NULL, &status);
/*
* Print the results
*/
printf("associators() rc=%d, msg=%s\n", status.rc,
(status.msg) ? (char *) status.msg->hdl : NULL);
if (!status.rc) {
printf("result(s):\n");
while (enumeration->ft->hasNext(enumeration, NULL)) {
data = enumeration->ft->getNext(enumeration, NULL);
showInstance(data.value.inst);
}
}
if (enumeration)
CMRelease(enumeration);
if (op)
CMRelease(op);
if (status.msg)
CMRelease(status.msg);
return 0;
}
static void initialize()
{
CMPIStatus rc = { CMPI_RC_OK, NULL};
CMPIArray *arr_ptr;
CMPIValue value1, value2, value_inst1, value_inst2;
CMPIInstance *instance1, *instance2, *instance3;
CMPIObjectPath *cop1, *cop2, *cop3;
value1.uint8 = 1;
value2.string = CMNewString(_broker, "Hello World", &rc);
/* create a new array to hold the instances created */
arr_ptr = CMNewArray(_broker, initArraySize, CMPI_instance, &rc);
/* create object path for instance1 */
cop1 = CMNewObjectPath(
_broker,
"root/cimv2",
_ClassName,
&rc);
/* add key (with its value) to object path to recognize instance uniquely */
CMAddKey(cop1, "Identifier", (CMPIValue *)&value1, CMPI_uint8);
/* if created object path is not null then create new instance */
if(!CMIsNullObject(cop1))
{
instance1 = CMNewInstance(_broker,
cop1,
&rc);
/* set the properties for newly created instance */
CMSetProperty(instance1, "Identifier",&value1, CMPI_uint8);
CMSetProperty(instance1, "Message", &value2, CMPI_string);
value_inst1.inst = instance1;
/* assign the created instance to array created */
rc = CMSetArrayElementAt(
arr_ptr,
numOfInst,
&value_inst1,
CMPI_instance);
/* set the validity of instance to be true.
Validity gets false if instance gets deleted using deleteInstance(). */
valid[numOfInst] = 1;
numOfInst++;
}
/* create instance 2 and add to array */
value1.uint8 = 2;
value2.string = CMNewString(_broker, "Yo Planet", &rc);
cop2 = CMNewObjectPath(
_broker,
"root/cimv2",
_ClassName,
&rc);
CMAddKey(cop2, "Identifier", (CMPIValue *)&value1, CMPI_uint8);
if(!CMIsNullObject(cop2))
{
instance2 = CMNewInstance(_broker,
cop2,
&rc);
CMSetProperty(instance2, "Identifier", &value1, CMPI_uint8);
CMSetProperty(instance2, "Message", &value2, CMPI_string);
value_inst2.inst = instance2;
rc = CMSetArrayElementAt(arr_ptr,
numOfInst,
&value_inst2,
CMPI_instance);
valid[numOfInst] = 1;
numOfInst++;
}
/* create instance 3 and add to array */
value1.uint8 = 3;
value2.string = CMNewString(_broker, "Hey Earth", &rc);
cop3 = CMNewObjectPath(
_broker,
"root/cimv2",
_ClassName,
&rc);
CMAddKey(cop3, "Identifier", (CMPIValue *)&value1, CMPI_uint8);
if(!CMIsNullObject(cop3))
{
instance3 = CMNewInstance(_broker,
cop3,
&rc);
CMSetProperty(instance3, "Identifier", &value1, CMPI_uint8);
CMSetProperty(instance3, "Message", &value2, CMPI_string);
value_inst2.inst = instance3;
rc = CMSetArrayElementAt(arr_ptr,
numOfInst,
&value_inst2,
CMPI_instance);
valid[numOfInst] = 1;
numOfInst++;
}
/* clone the array which contains instances. */
clone_arr_ptr = arr_ptr->ft->clone(arr_ptr, &rc);
}