CMPIStatus get_profile(const CMPIBroker *broker,
const CMPIObjectPath *reference,
const char **properties,
const char* pfx,
struct reg_prof *profile,
CMPIInstance **_inst)
{
CMPIStatus s = {CMPI_RC_OK, NULL};
CMPIInstance *instance = NULL;
CMPIArray *array;
instance = get_typed_instance(broker,
pfx,
"RegisteredProfile",
CIM_INTEROP_NS,
false);
if (instance == NULL) {
cu_statusf(broker, &s,
CMPI_RC_ERR_FAILED,
"Can't create RegisteredProfile instance");
goto out;
}
if (properties) {
const char *keys[] = {"InstanceID", NULL};
CMSetPropertyFilter(instance, properties, keys);
}
CMSetProperty(instance, "InstanceID",
(CMPIValue *)profile->reg_id, CMPI_chars);
CMSetProperty(instance, "RegisteredOrganization",
(CMPIValue *)&profile->reg_org, CMPI_uint16);
CMSetProperty(instance, "RegisteredName",
(CMPIValue *)profile->reg_name, CMPI_chars);
CMSetProperty(instance, "RegisteredVersion",
(CMPIValue *)profile->reg_version, CMPI_chars);
array = CMNewArray(broker, 1, CMPI_uint16, &s);
if ((s.rc != CMPI_RC_OK) || (CMIsNullObject(array))) {
cu_statusf(broker, &s,
CMPI_RC_ERR_FAILED,
"Unable to create CMPIArray object");
goto out;
}
CMSetArrayElementAt(array, 0, &profile->ad_types, CMPI_uint16);
CMSetProperty(instance, "AdvertiseTypes",
(CMPIValue *)&array, CMPI_uint16A);
*_inst = instance;
out:
return s;
}
static void
generateIndication2(const char *methodname, const CMPIContext *ctx)
{
CMPIInstance *inst;
CMPIObjectPath *cop;
CMPIDateTime *dat;
CMPIArray *ar;
CMPIStatus rc;
char buffer[32];
if (enabled && activated2) {
cop = CMNewObjectPath(broker, "root/interop2", "Test_Indication", &rc);
inst = CMNewInstance(broker, cop, &rc);
sprintf(buffer, "%d", _nextUID++);
CMSetProperty(inst, "IndicationIdentifier", buffer, CMPI_chars);
dat = CMNewDateTime(broker, &rc);
CMSetProperty(inst, "IndicationTime", &dat, CMPI_dateTime);
CMSetProperty(inst, "MethodName", methodname, CMPI_chars);
ar = CMNewArray(broker, 0, CMPI_string, &rc);
CMSetProperty(inst, "CorrelatedIndications", &ar, CMPI_stringA);
rc = CBDeliverIndication(broker, ctx, "root/interop", inst);
if (rc.rc != CMPI_RC_OK) {
fprintf(stderr, "+++ Could not send the indication!\n");
}
gen2++;
}
fprintf(stderr, "+++ generateIndication2() done %d\n", gen2);
}
static CMPIrc memorypool_set_properties(
provider_resource *resource,
CMPIInstance *inst
)
{
local_host_resource *ctx = resource->ctx;
char buf[MAX_INSTANCEID_LEN];
int prop_val_32;
xen_host_metrics_record *host_metrics_rec = NULL;
if (ctx->host_rec->metrics->is_record)
host_metrics_rec = ctx->host_rec->metrics->u.record;
else
xen_host_metrics_get_record(resource->session->xen, &host_metrics_rec, ctx->host_rec->metrics->u.handle);
_CMPICreateNewDeviceInstanceID(buf, MAX_INSTANCEID_LEN, ctx->host_rec->uuid, "MemoryPool");
CMSetProperty(inst, "InstanceID", (CMPIValue *)buf, CMPI_chars);
CMSetProperty(inst, "PoolID", (CMPIValue *)ctx->host_rec->uuid, CMPI_chars);
int type = DMTF_ResourceType_Memory;
CMSetProperty(inst, "ResourceType", (CMPIValue *)&type, CMPI_uint16);
CMSetProperty(inst, "ResourceSubType", (CMPIValue *) "Xen Memory", CMPI_chars);
CMSetProperty(inst, "AllocationUnits", (CMPIValue *)"Bytes", CMPI_chars);
CMSetProperty(inst, "Capacity",(CMPIValue *)&(host_metrics_rec->memory_total), CMPI_uint64);
CMSetProperty(inst, "Caption", (CMPIValue *)"Xen Virtual Memory Pool", CMPI_chars);
CMSetProperty(inst, "Description", (CMPIValue *)"Xen Virtual Memory Pool", CMPI_chars);
CMSetProperty(inst, "ElementName", (CMPIValue *)ctx->host_rec->name_label, CMPI_chars);
prop_val_32 = DMTF_HealthState_OK;
CMSetProperty(inst, "HealthState", (CMPIValue *)&prop_val_32, CMPI_uint16);
//CMSetProperty(inst, "InstallDate", (CMPIValue *)installDate, CMPI_dateTime);
CMSetProperty(inst, "Name", (CMPIValue *)"Xen Virtual Memory Pool", CMPI_chars);
prop_val_32 = DMTF_OperationalStatus_OK;
CMPIArray *arr = CMNewArray(resource->broker, 1, CMPI_uint16, NULL);
CMSetArrayElementAt(arr, 0, (CMPIValue *)&prop_val_32, CMPI_uint16);
CMSetProperty(inst, "OperationalStatus", (CMPIValue *) &arr, CMPI_uint16A);
//CMSetProperty(inst, "OtherResourceType", (CMPIValue *)other_resource_type, CMPI_String);
prop_val_32 = 1;
CMSetProperty(inst, "Primordial" , (CMPIValue *)&prop_val_32, CMPI_boolean);
//CMSetProperty(inst, "Status", (CMPIValue *)status, CMPI_chars);
// CMSetProperty(inst, "StatusDescriptions", (CMPIValue *)status_descs, CMPI_chars);
int64_t reserved = host_metrics_rec->memory_total - host_metrics_rec->memory_free;
CMSetProperty(inst, "Reserved", (CMPIValue *)&reserved, CMPI_uint64);
// CMSetProperty(inst, "Unreservable", (CMPIValue *)unreservable, CMPI_uint16);
if (!ctx->host_rec->metrics->is_record)
xen_host_metrics_record_free(host_metrics_rec);
return CMPI_RC_OK;
}
static CMPIrc processorpool_set_properties(
const CMPIBroker *broker,
provider_resource *resource,
CMPIInstance *inst)
{
uint64_t prop_val_64;
int prop_val_32;
char buf[MAX_INSTANCEID_LEN];
xen_host_record *host_rec = ((local_host_resource *)resource->ctx)->host_rec;
_CMPICreateNewDeviceInstanceID(buf, MAX_INSTANCEID_LEN, host_rec->uuid, "ProcessorPool");
CMSetProperty(inst, "InstanceID", (CMPIValue *)buf, CMPI_chars);
CMSetProperty(inst, "PoolID", (CMPIValue *)host_rec->uuid, CMPI_chars);
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_INFO, ("setting ProcessorPool properties -InstanceID: %s", buf));
prop_val_32 = DMTF_ResourceType_Processor;
CMSetProperty(inst, "ResourceType", (CMPIValue *)&prop_val_32, CMPI_uint16);
CMSetProperty(inst, "ResourceSubType", (CMPIValue *) "xen:vcpu", CMPI_chars);
CMSetProperty(inst, "AllocationUnits", (CMPIValue *)"count", CMPI_chars);
/* Capacity is the number of items in xen_host_cpu_set. */
prop_val_64 = host_rec->host_cpus->size;
CMSetProperty(inst, "Capacity", (CMPIValue *)&prop_val_64, CMPI_uint64);
CMSetProperty(inst, "Caption", (CMPIValue *)"Xen Virtual Processor Pool", CMPI_chars);
CMSetProperty(inst, "Description", (CMPIValue *)host_rec->name_description, CMPI_chars);
CMSetProperty(inst, "ElementName", (CMPIValue *)host_rec->name_label, CMPI_chars);
prop_val_32 = DMTF_HealthState_OK;
CMSetProperty(inst, "HealthState", (CMPIValue *)&prop_val_32, CMPI_uint16);
//CMSetProperty(inst, "InstallDate", (CMPIValue *)&installDate, CMPI_dateTime);
CMSetProperty(inst, "Name", (CMPIValue *)"Xen Virtual Processor Pool", CMPI_chars);
prop_val_32 = DMTF_OperationalStatus_OK;
CMPIArray *arr = CMNewArray(broker, 1, CMPI_uint16, NULL);
CMSetArrayElementAt(arr, 0, (CMPIValue *)&prop_val_32, CMPI_uint16);
CMSetProperty(inst, "OperationalStatus", (CMPIValue *) &arr, CMPI_uint16A);
//CMSetProperty(inst, "OtherResourceType", (CMPIValue *)other_resource_type, CMPI_String);
prop_val_32 = 1;
CMSetProperty(inst, "Primordial" , (CMPIValue *)&prop_val_32, CMPI_boolean);
//CMSetProperty(inst, "Status", (CMPIValue *)status, CMPI_chars);
// CMSetProperty(inst, "StatusDescriptions", (CMPIValue *)status_descs, CMPI_chars);
/* Does Xen implement reservation of CPUs by VMs ? */
prop_val_64 = 0;
CMSetProperty(inst, "Reserved", (CMPIValue *)&prop_val_64, CMPI_uint64);
// CMSetProperty(inst, "Unreservable", (CMPIValue *)unreservable, CMPI_uint16);
return CMPI_RC_OK;
}
/************************************************************************
* Function that sets the properties of a CIM object with values from the
* provider specific resource.
*
* @param resource - provider specific resource to get values from
* @param inst - CIM object whose properties are being set
* @return CMPIrc return values
*************************************************************************/
static bool _set_allowed_operations(
const CMPIBroker *broker,
xen_host_record *host_rec,
CMPIInstance *inst,
char *property_name
)
{
int cap_count = 1; /* enabled/disabled is always allowed ? */
//int i;
cap_count++; //Default Reboot operation
cap_count++; //Default shutdown operation
//if(host_rec->allowed_operations->size > 0) {
// for(i=0; i<host_rec->allowed_operations->size; i++) {
// if((host_rec->allowed_operations->contents[i] == XEN_HOST_ALLOWED_OPERATIONS_REBOOT) ||
// (host_rec->allowed_operations->contents[i] == XEN_HOST_ALLOWED_OPERATIONS_SHUTDOWN))
// cap_count++;
// }
//}
CMPIArray *statesSupported = CMNewArray(broker, cap_count, CMPI_uint16, NULL);
DMTF_RequestedState additional_state;
cap_count = 0;
if(host_rec->enabled)
additional_state = DMTF_RequestedState_Disabled;
else
additional_state = DMTF_RequestedState_Enabled;
CMSetArrayElementAt(statesSupported, cap_count++, (CMPIValue *)&additional_state, CMPI_uint16);
//for(i=0; i<host_rec->allowed_operations->size; i++) {
// if (host_rec->allowed_operations->contents[i] == XEN_HOST_ALLOWED_OPERATIONS_REBOOT) {
// additional_state = DMTF_RequestedState_Reboot;
// CMSetArrayElementAt(statesSupported, cap_count++, (CMPIValue *)&additional_state, CMPI_uint16);
// }
// else if (host_rec->allowed_operations->contents[i] == XEN_HOST_ALLOWED_OPERATIONS_SHUTDOWN) {
// additional_state = DMTF_RequestedState_Shut_Down;
// CMSetArrayElementAt(statesSupported, cap_count++, (CMPIValue *)&additional_state, CMPI_uint16);
// }
// }
//A temp fix for CA-45165 that should be revereted the moment the XAPI call is fixed.
//It is returning the stated of shutdown and reboot all the time and expecting that in a case where
//it can't, the error message is appropriate returned.
additional_state = DMTF_RequestedState_Reboot;
CMSetArrayElementAt(statesSupported, cap_count++, (CMPIValue *)&additional_state, CMPI_uint16);
additional_state = DMTF_RequestedState_Shut_Down;
CMSetArrayElementAt(statesSupported, cap_count++, (CMPIValue *)&additional_state, CMPI_uint16);
CMSetProperty(inst, property_name, (CMPIValue *)&statesSupported, CMPI_uint16A);
return true;
}
CMPIBoolean KArray_Init(
KArray* self,
const CMPIBroker* cb,
CMPICount max,
CMPIType type)
{
CMPIArray* array;
if (!self || !cb)
return 0;
if (!(array = CMNewArray(cb, max, type, NULL)))
return 0;
self->value = array;
self->exists = 1;
self->null = 0;
self->count = max;
return 1;
}
static CMPIrc host_set_properties(
provider_resource *resource,
CMPIInstance *inst
)
{
local_host_resource *ctx = (local_host_resource *)resource->ctx;
/* Key properties to be filled in */
CMSetProperty(inst, "Name",(CMPIValue *)ctx->host_rec->uuid, CMPI_chars);
CMSetProperty(inst, "CreationClassName",(CMPIValue *)"Xen_HostComputerSystem", CMPI_chars);
xen_host_metrics metrics = NULL;
xen_host_get_metrics(resource->session->xen, &metrics, ctx->host);
xen_host_metrics_record *metrics_rec = NULL;
if (metrics) {
xen_host_metrics_get_record(resource->session->xen, &metrics_rec, metrics);
xen_host_metrics_free(metrics);
}
/* Populate the instance's properties with the backend data */
_set_allowed_operations(resource->broker, ctx->host_rec, inst, "AvailableRequestedStates");
/* Check other-config (as a cache) */
char *CN = NULL;
CN = xen_utils_get_from_string_string_map(ctx->host_rec->other_config, "host_cn");
/* Did not find the CN in the cache, call out to plugin */
if (CN) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_DEBUG,("CN back from other_config = %s for host %s", CN, ctx->host));
CMSetProperty(inst, "CN", (CMPIValue *)CN, CMPI_chars);
} else {
/* Get CN name by calling a plugin on the Host */
//char *CN = NULL;
xen_string_string_map *args = xen_string_string_map_alloc(0);
xen_host_call_plugin(resource->session->xen, &CN, ctx->host, "xscim", "read_host_cn", args);
xen_string_string_map_free(args);
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_DEBUG,("CN name back from plugin = %s for host %s", CN, ctx->host));
/* Update the other_config cache */
xen_host_add_to_other_config(resource->session->xen, ctx->host, "host_cn", CN);
CMSetProperty(inst, "CN", (CMPIValue *)CN, CMPI_chars);
// Only need to free CN here because we have made the plugin call.
// If we've taken the value from the cache it will be free'd when
// ctx->host_rec is free'd.
if (CN)
free(CN);
}
CMSetProperty(inst, "Caption",(CMPIValue *)"XenServer Host", CMPI_chars);
DMTF_Dedicated dedicated = DMTF_Dedicated_Other;
CMPIArray *arr = CMNewArray(resource->broker, 1, CMPI_uint16, NULL);
CMSetArrayElementAt(arr, 0, (CMPIValue *)&dedicated, CMPI_uint16);
CMSetProperty(inst, "Dedicated",(CMPIValue *)&arr, CMPI_uint16A);
CMSetProperty(inst, "Description",(CMPIValue *)ctx->host_rec->name_description, CMPI_chars);
CMSetProperty(inst, "ElementName",(CMPIValue *)ctx->host_rec->name_label, CMPI_chars);
DMTF_EnabledDefault eDefault = DMTF_EnabledDefault_Enabled;
CMSetProperty(inst, "EnabledDefault",(CMPIValue *)&eDefault, CMPI_uint16);
DMTF_EnabledState eState = DMTF_EnabledState_Enabled;
if (!ctx->host_rec->enabled)
eState = DMTF_EnabledState_Enabled_but_Offline;
CMSetProperty(inst, "EnabledState",(CMPIValue *)&eState, CMPI_uint16);
DMTF_HealthState hState = DMTF_HealthState_OK;
CMSetProperty(inst, "HealthState",(CMPIValue *)&hState, CMPI_uint16);
//CMPIDateTime *date_time = xen_utils_time_t_to_CMPIDateTime(resource->broker, <time_value>);
//CMSetProperty(inst, "InstallDate",(CMPIValue *)&date_time, CMPI_dateTime);
CMSetProperty(inst, "NameFormat",(CMPIValue *)DMTF_NameFormat_Other, CMPI_chars);
DMTF_OperationalStatus opStatus = DMTF_OperationalStatus_OK;
if (!ctx->host_rec->enabled)
opStatus = DMTF_OperationalStatus_Stopped;
CMPIArray *opStatusArr = CMNewArray(resource->broker, 1, CMPI_uint16, NULL);
CMSetArrayElementAt(opStatusArr, 0, (CMPIValue *)&opStatus, CMPI_uint16);
CMSetProperty(inst, "OperationalStatus",(CMPIValue *)&opStatusArr, CMPI_uint16A);
//CMPIArray *arr = CMNewArray(resource->broker, 1, CMPI_chars, NULL);
//CMSetArrayElementAt(arr, 0, (CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "OtherDedicatedDescriptions",(CMPIValue *)&arr, CMPI_charsA);
//CMSetProperty(inst, "OtherEnabledState",(CMPIValue *)<value>, CMPI_chars);
arr = xen_utils_convert_string_string_map_to_CMPIArray(resource->broker, ctx->host_rec->other_config);
if(arr)
CMSetProperty(inst, "OtherConfig",(CMPIValue *)&arr, CMPI_stringA);
CMPIArray *otheridinfo = CMNewArray(resource->broker, 4, CMPI_chars, NULL);
char* brand = xen_utils_get_from_string_string_map(ctx->host_rec->software_version, "product_brand");
char* version = xen_utils_get_from_string_string_map(ctx->host_rec->software_version, "product_version");
char* build = xen_utils_get_from_string_string_map(ctx->host_rec->software_version, "build_number");
CMSetArrayElementAt(otheridinfo, 0, (CMPIValue *)ctx->host_rec->address, CMPI_chars);
CMSetArrayElementAt(otheridinfo, 1, (CMPIValue *)brand, CMPI_chars);
CMSetArrayElementAt(otheridinfo, 2, (CMPIValue *)version, CMPI_chars);
CMSetArrayElementAt(otheridinfo, 3, (CMPIValue *)build, CMPI_chars);
CMSetProperty(inst, "OtherIdentifyingInfo",(CMPIValue *)&otheridinfo, CMPI_charsA);
CMPIArray *iddesc = CMNewArray(resource->broker, 4, CMPI_chars, NULL);
CMSetArrayElementAt(iddesc, 0, (CMPIValue *)"IPv4Address", CMPI_chars);
CMSetArrayElementAt(iddesc, 1, (CMPIValue *)"ProductBrand", CMPI_chars);
CMSetArrayElementAt(iddesc, 2, (CMPIValue *)"ProductVersion", CMPI_chars);
CMSetArrayElementAt(iddesc, 3, (CMPIValue *)"BuildNumber", CMPI_chars);
CMSetProperty(inst, "IdentifyingDescriptions",(CMPIValue *)&iddesc, CMPI_charsA);
//CMPIArray *arr = CMNewArray(resource->broker, 1, CMPI_uint16, NULL);
//CMSetArrayElementAt(arr, 0, (CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "PowerManagementCapabilities",(CMPIValue *)&arr, CMPI_uint16A);
char *owner = xen_utils_get_from_string_string_map(ctx->host_rec->other_config, "owner");
char *ownercontact = xen_utils_get_from_string_string_map(ctx->host_rec->other_config, "ownercontact");
if (owner)
CMSetProperty(inst, "PrimaryOwnerName",(CMPIValue *)owner, CMPI_chars);
if (ownercontact)
CMSetProperty(inst, "PrimaryOwnerContact",(CMPIValue *)ownercontact, CMPI_chars);
DMTF_RequestedState rState = DMTF_RequestedState_Enabled;
CMSetProperty(inst, "RequestedState",(CMPIValue *)&rState, CMPI_uint16);
//CMSetProperty(inst, "ResetCapability",(CMPIValue *)&<value>, CMPI_uint16);
char *serverrole = xen_utils_get_from_string_string_map(ctx->host_rec->other_config, "role");
if (serverrole) {
CMPIArray *rolesarr = CMNewArray(resource->broker, 1, CMPI_chars, NULL);
CMSetArrayElementAt(rolesarr, 0, (CMPIValue *)serverrole, CMPI_chars);
CMSetProperty(inst, "Roles",(CMPIValue *)&rolesarr, CMPI_charsA);
}
if (ctx->host_rec->other_config) {
char *val = xen_utils_get_from_string_string_map(ctx->host_rec->other_config, "boot_time");
if (val) {
time_t time = atol(val);
CMPIDateTime *start_time = xen_utils_time_t_to_CMPIDateTime(resource->broker, time);
if (start_time) CMSetProperty(inst, "StartTime",(CMPIValue *)&start_time, CMPI_dateTime);
}
}
CMSetProperty(inst, "Status",(CMPIValue *)DMTF_Status_OK, CMPI_chars);
//CMPIArray *arr = CMNewArray(resource->broker, 1, CMPI_chars, NULL);
//CMSetArrayElementAt(arr, 0, (CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "StatusDescriptions",(CMPIValue *)&arr, CMPI_charsA);
if (metrics_rec && (metrics_rec->last_updated != 0)) {
CMPIDateTime *install_time = xen_utils_time_t_to_CMPIDateTime(resource->broker, metrics_rec->last_updated);
CMSetProperty(inst, "TimeOfLastStateChange",(CMPIValue *)&install_time, CMPI_dateTime);
}
/* properties to indicate hosts's time zone. We compute local time zone on this
host and assume all hosts are in the same zone since xapi doest report the time zone at this time */
time_t now = time(NULL);
struct tm tmnow;
localtime_r(&now, &tmnow);
CMSetProperty(inst, "TimeOffset", (CMPIValue *)&tmnow.tm_gmtoff, CMPI_sint32);
if (metrics_rec)
xen_host_metrics_record_free(metrics_rec);
return CMPI_RC_OK;
}
CMPIInstance *RegisteredProfileCreateInstance(
const char *ns,
const char *name,
CMPIStatus *status)
{
CMPIInstance *ci;
char buf[256];
CMPIValue val;
_SMI_TRACE(1,("RegisteredProfileCreateInstance() called"));
if (strcasecmp(name, ArrayName) == 0 ||
strcasecmp(name, VolumeManagementName) == 0 ||
strcasecmp(name, ServerName) == 0)
{
ci = CMNewInstance(
_BROKER,
CMNewObjectPath(_BROKER, ns, RegisteredProfileName, status),
status);
}
else
{
ci = CMNewInstance(
_BROKER,
CMNewObjectPath(_BROKER, ns, RegisteredSubProfileName, status),
status);
}
if ((status->rc != CMPI_RC_OK) || CMIsNullObject(ci))
{
_SMI_TRACE(1,("RegisteredProfileCreateInstance(): CMNewInstance() failed - %s", CMGetCharPtr(status->msg)));
CMSetStatusWithChars(_BROKER, status, CMPI_RC_ERROR_SYSTEM, "Cannot create new instance");
goto exit;
}
CMSetProperty(ci, InstanceIDName,
cmpiutilMakeInstanceID(name, buf, 256), CMPI_chars);
CMSetProperty(ci, ElementName, name, CMPI_chars);
CMSetProperty(ci, ParamName, name, CMPI_chars);
CMSetProperty(ci, Caption, name, CMPI_chars);
CMSetProperty(ci, RegisteredName, name, CMPI_chars);
val.uint16 = 11;
CMSetProperty(ci, RegisteredOrg, &val, CMPI_uint16);
CMSetProperty(ci, RegisteredVersion, RegisteredVersionValue, CMPI_chars);
CMPIArray *arr = CMNewArray(_BROKER, 1, CMPI_uint16, NULL);
val.uint16 = 2;
CMSetArrayElementAt(arr, 0, &val, CMPI_uint16);
val.array = arr;
CMSetProperty(ci, AdvertiseTypes, &val, CMPI_uint16A);
arr = CMNewArray(_BROKER, 1, CMPI_string, NULL);
val.string = CMNewString(_BROKER, NotAdvertised, NULL);
CMSetArrayElementAt(arr, 0, &val, CMPI_string);
val.array = arr;
CMSetProperty(ci, AdvertiseTypeDesc, &val, CMPI_stringA);
exit:
_SMI_TRACE(1,("RegisteredProfileCreateInstance() done"));
return ci;
}
static CMPIStatus
ClassProviderInvokeMethod(CMPIMethodMI * mi,
const CMPIContext *ctx,
const CMPIResult *rslt,
const CMPIObjectPath * ref,
const char *methodName,
const CMPIArgs * in, CMPIArgs * out)
{
CMPIStatus st = { CMPI_RC_OK, NULL };
CMPIArray *ar;
int rc;
ClassRegister *cReg;
_SFCB_ENTER(TRACE_PROVIDERS, "ClassProviderInvokeMethod");
cReg = getNsReg(ref, &rc);
if (cReg == NULL) {
CMPIStatus st = { CMPI_RC_ERR_INVALID_NAMESPACE, NULL };
_SFCB_RETURN(st);
}
if (strcasecmp(methodName, "getchildren") == 0) {
CMPIData cn = CMGetArg(in, "class", NULL);
_SFCB_TRACE(1, ("--- getchildren %s", (char *) cn.value.string->hdl));
cReg->ft->wLock(cReg);
if (cn.type == CMPI_string && cn.value.string && cn.value.string->hdl) {
char *child;
int l = 0,
i = 0;
UtilList *ul =
getChildren(cReg, (char *) cn.value.string->hdl);
if (ul)
l = ul->ft->size(ul);
ar = CMNewArray(_broker, l, CMPI_string, NULL);
if (ul)
for (child = (char *) ul->ft->getFirst(ul); child; child = (char *)
ul->ft->getNext(ul)) {
CMSetArrayElementAt(ar, i++, child, CMPI_chars);
}
st = CMAddArg(out, "children", &ar, CMPI_stringA);
} else {
}
cReg->ft->wUnLock(cReg);
}
else if (strcasecmp(methodName, "getallchildren") == 0) {
int ignprov = 0;
CMPIStatus st;
CMPIData cn = CMGetArg(in, "class", &st);
cReg->ft->wLock(cReg);
if (st.rc != CMPI_RC_OK) {
cn = CMGetArg(in, "classignoreprov", NULL);
ignprov = 1;
}
_SFCB_TRACE(1,
("--- getallchildren %s", (char *) cn.value.string->hdl));
if (cn.type == CMPI_string && cn.value.string && cn.value.string->hdl) {
int n = 0,
i = 0;
loopOnChildCount(cReg, (char *) cn.value.string->hdl, &n, ignprov);
_SFCB_TRACE(1, ("--- count %d", n));
ar = CMNewArray(_broker, n, CMPI_string, NULL);
if (n) {
_SFCB_TRACE(1, ("--- loop %s", (char *) cn.value.string->hdl));
loopOnChildChars(cReg, (char *) cn.value.string->hdl, ar, &i,
ignprov);
}
st = CMAddArg(out, "children", &ar, CMPI_stringA);
} else {
}
cReg->ft->wUnLock(cReg);
}
else if (strcasecmp(methodName, "getassocs") == 0) {
ar = CMNewArray(_broker, cReg->topAssocs, CMPI_string, NULL);
ClassBase *cb = (ClassBase *) (cReg + 1);
UtilHashTable *ct = cb->ht;
HashTableIterator *i;
char *cn;
ClassRecord *crec;
int n;
cReg->ft->wLock(cReg);
for (n = 0, i = ct->ft->getFirst(ct, (void **) &cn, (void **) &crec);
i; i = ct->ft->getNext(ct, i, (void **) &cn, (void **) &crec)) {
if (crec->flags & CREC_isAssociation && crec->parent == NULL) {
/*
* add top-level association class
*/
CMSetArrayElementAt(ar, n++, cn, CMPI_chars);
}
}
CMAddArg(out, "assocs", &ar, CMPI_stringA);
cReg->ft->wUnLock(cReg);
}
else if (strcasecmp(methodName, "ischild") == 0) {
char *parent = (char *) CMGetClassName(ref, NULL)->hdl;
char *chldn =
(char *) CMGetArg(in, "child", NULL).value.string->hdl;
st.rc = traverseChildren(cReg, parent, chldn);
}
else if (strcasecmp(methodName, "_startup") == 0) {
/* let providerMgr know that we're odne init'ing */
semRelease(sfcbSem,INIT_CLASS_PROV_ID);
st.rc = CMPI_RC_OK;
}
else {
mlogf(M_ERROR, M_SHOW,
"--- ClassProvider: Invalid invokeMethod request %s\n",
methodName);
st.rc = CMPI_RC_ERR_METHOD_NOT_FOUND;
}
_SFCB_RETURN(st);
}
CMPIInstance * _makeInst_TestClassA(
const CMPIBroker * _broker,
const CMPIContext * ctx,
const CMPIObjectPath * cop,
const char ** properties)
{
CMPIArray *array = NULL;
CMPIValue opstatus;
CMPIValue status;
CMPIValue theKey;
CMPIObjectPath* op=NULL;
CMPIInstance* ci=NULL;
opstatus.uint16 = 0; /* Unknown */
status.uint16 = 2; /* Enabled */
theKey.uint32 = 2;
//
// Construct ObjectPath
//
op=_makePath_TestClassA(_broker,ctx,cop);
//
// Create a new instance and fill it's properties
//
ci = CMNewInstance( _broker, op, NULL);
CMRelease(op);
CMSetPropertyFilter(ci,properties,NULL);
//
// Properties of CIM_ManagedElement
//
CMSetProperty(ci,"Caption","Test class A",CMPI_chars);
CMSetProperty(
ci,
"Description",
"Test class used for all kinds of testing",
CMPI_chars);
CMSetProperty(ci,"ElementName","Instance1",CMPI_chars);
//
// Properties of CIM_ManagedSystemElement
//
array = CMNewArray(_broker,1,CMPI_uint16,NULL);
CMSetArrayElementAt(array,0,&opstatus,CMPI_uint16);
CMSetProperty(ci,"OperationalStatus",(CMPIValue*)&(array),CMPI_uint16A);
//
// Properties of CIM_EnabledLogicalElement
//
CMSetProperty(ci,"EnabledState",&status,CMPI_uint16);
CMSetProperty(ci,"OtherEnabledState","NULL",CMPI_chars);
CMSetProperty(ci,"RequestedState",&status,CMPI_uint16);
CMSetProperty(ci,"EnabledDefault",&status,CMPI_uint16);
//
// Properties of CIM_TestClass
//
CMSetProperty(ci,"theKey",&theKey,CMPI_uint32 );
CMSetProperty(ci,"theData",&theKey,CMPI_uint32 );
CMSetProperty(ci,"theString","Test Instance Number One",CMPI_chars);
return ci;
}
static int
_testCMPIArray()
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIArray *arr_ptr = NULL;
CMPIArray *new_arr_ptr = NULL;
CMPIData data[3];
CMPIData clonedData[3];
CMPIValue value;
CMPIType initArrayType = CMPI_uint32;
CMPIType initErrArrayType = CMPI_REAL;
CMPIType returnedArrayType;
CMPICount initArraySize = 3;
CMPICount returnedArraySize;
CMPIUint32 i;
CMPIBoolean cloneSuccessful = 0;
CMPIBoolean getDataSuccessful;
void *aptr;
arr_ptr = CMNewArray(_broker, initArraySize, initArrayType, &rc);
if (arr_ptr == NULL) {
return 1;
}
returnedArraySize = CMGetArrayCount(arr_ptr, &rc);
returnedArrayType = CMGetArrayType(arr_ptr, &rc);
value.uint32 = 10;
rc = CMSetArrayElementAt(arr_ptr, 0, &value, initArrayType);
value.uint32 = 20;
rc = CMSetArrayElementAt(arr_ptr, 1, &value, initArrayType);
value.uint32 = 30;
rc = CMSetArrayElementAt(arr_ptr, 2, &value, initArrayType);
i = 0;
while (i < 3) {
data[i] = CMGetArrayElementAt(arr_ptr, i, &rc);
i++;
}
i = 0;
getDataSuccessful = 1;
while (i < 3) {
if (data[i].value.uint32 != (i + 1) * 10) {
getDataSuccessful = 0;
break;
}
i++;
}
new_arr_ptr = arr_ptr->ft->clone(arr_ptr, &rc);
i = 0;
while (i < 3) {
clonedData[i] = CMGetArrayElementAt(new_arr_ptr, i, &rc);
i++;
}
cloneSuccessful = 1;
for (i = 0; i < initArraySize; i++) {
if (data[i].value.uint32 != clonedData[i].value.uint32) {
cloneSuccessful = 0;
break;
}
}
rc = new_arr_ptr->ft->release(new_arr_ptr);
aptr = arr_ptr->hdl;
arr_ptr->hdl = NULL;
returnedArraySize = CMGetArrayCount(arr_ptr, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
returnedArrayType = CMGetArrayType(arr_ptr, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
rc = CMSetArrayElementAt(arr_ptr, 2, &value, initArrayType);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
CMGetArrayElementAt(arr_ptr, 5, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
arr_ptr->ft->clone(arr_ptr, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
rc = arr_ptr->ft->release(arr_ptr);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
arr_ptr->hdl = aptr;
CMGetArrayElementAt(arr_ptr, 5, &rc);
if (rc.rc != CMPI_RC_ERR_NO_SUCH_PROPERTY) {
return 1;
}
rc = CMSetArrayElementAt(arr_ptr, 2, &value, initErrArrayType);
if (rc.rc != CMPI_RC_ERR_TYPE_MISMATCH) {
return 1;
}
rc = arr_ptr->ft->release(arr_ptr);
return 0;
}
static int
_testArrayTypes()
{
struct array_types {
CMPIType element_type;
CMPIType typeA;
char *typeName;
char *typeAName;
char *args_name;
} types_arr[] = {
{
CMPI_uint32,
CMPI_uint32A,
"CMPI_uint32", "CMPI_uint32A", "CMPI_uint32_array"}, {
CMPI_uint16,
CMPI_uint16A,
"CMPI_uint16", "CMPI_uint16A", "CMPI_uint16_array"}, {
CMPI_uint8,
CMPI_uint8A, "CMPI_uint8", "CMPI_uint8A", "CMPI_uint8_array"}, {
CMPI_uint64,
CMPI_uint64A,
"CMPI_uint64", "CMPI_uint64A", "CMPI_uint64_array"}, {
CMPI_sint32,
CMPI_sint32A,
"CMPI_sint32", "CMPI_sint32A", "CMPI_sint32_array"}, {
CMPI_sint16,
CMPI_sint16A,
"CMPI_sint16", "CMPI_sint16A", "CMPI_sint16_array"}, {
CMPI_sint8,
CMPI_sint8A, "CMPI_sint8", "CMPI_sint8A", "CMPI_sint8_array"}, {
CMPI_sint64,
CMPI_sint64A,
"CMPI_sint64", "CMPI_sint64A", "CMPI_sint64_array"}, {
CMPI_real32,
CMPI_real32A,
"CMPI_real32", "CMPI_real32A", "CMPI_real32_array"}, {
CMPI_real64,
CMPI_real64A,
"CMPI_real64", "CMPI_real64A", "CMPI_real64_array"}, {
CMPI_char16,
CMPI_char16A,
"CMPI_char16", "CMPI_char16A", "CMPI_char16_array"}, {
CMPI_boolean,
CMPI_booleanA,
"CMPI_boolean", "CMPI_booleanA", "CMPI_boolean_array"}, {
CMPI_string,
CMPI_stringA,
"CMPI_string", "CMPI_stringA", "CMPI_string_array"}, {
CMPI_dateTime,
CMPI_dateTimeA,
"CMPI_dateTime", "CMPI_dateTimeA", "CMPI_dateTime_array"}, {
CMPI_ref, CMPI_refA, "CMPI_ref", "CMPI_refA", "CMPI_ref_array"}, {
CMPI_instance,
CMPI_instanceA,
"CMPI_instance", "CMPI_instanceA", "CMPI_instance_array"}, {
CMPI_null, CMPI_ARRAY, "Invalid", "InvalidArray", "Invalid_array"}};
int i,
flag,
size;
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIStatus rc1 = { CMPI_RC_OK, NULL };
CMPIArray *arr = NULL;
CMPIString *retNamespace = NULL;
CMPIString *retClassname = NULL;
CMPIValue value,
value1;
CMPIData data;
CMPIData arr_data;
CMPIData dataInst;
CMPIData retDataInst;
CMPIArgs *args_ptr = NULL;
CMPIObjectPath *objPath = make_ObjectPath(_broker,
_Namespace,
_ClassName);
CMPIUint64 datetime1,
datetime2;
const char *str1;
const char *str2;
size = 17;
for (i = 0; i < size; i++) {
args_ptr = CMNewArgs(_broker, &rc);
switch (types_arr[i].element_type) {
case CMPI_uint32:
value.uint32 = 56;
break;
case CMPI_uint16:
value.uint16 = 32;
break;
case CMPI_uint8:
value.uint8 = 56;
break;
case CMPI_uint64:
value.uint64 = 32;
break;
case CMPI_sint32:
value.sint32 = -56;
break;
case CMPI_sint16:
value.sint16 = -32;
break;
case CMPI_sint8:
value.sint8 = -56;
break;
case CMPI_sint64:
value.sint64 = -32;
break;
case CMPI_real32:
value.real32 = (CMPIReal32) -32.78;
break;
case CMPI_real64:
value.real64 = -899.32;
break;
case CMPI_char16:
value.char16 = 'k';
break;
case CMPI_string:
value.string = CMNewString(_broker, "string", &rc);
break;
case CMPI_boolean:
value.boolean = 1;
break;
case CMPI_dateTime:
value.dateTime = CMNewDateTime(_broker, &rc);
break;
case CMPI_ref:
value.ref = CMNewObjectPath(_broker,
"root/cimv2", "Sample_Instance", &rc);
break;
case CMPI_null:
value.args = NULL;
break;
case CMPI_instance:
value.inst = make_Instance(objPath);
value1.uint32 = 20;
rc = CMSetProperty(value.inst, "Property1", &value1, CMPI_uint32);
break;
}
arr = NULL;
rc = CMAddArg(args_ptr,
"EmptyArray", (CMPIValue *) & arr, types_arr[i].typeA);
arr = CMNewArray(_broker, 1, types_arr[i].element_type, &rc);
rc = CMSetArrayElementAt(arr, 0, &value, types_arr[i].element_type);
rc = CMAddArg(args_ptr,
types_arr[i].args_name,
(CMPIValue *) & arr, types_arr[i].typeA);
flag = 1;
if ((types_arr[i].element_type) != CMPI_null) {
data = CMGetArg(args_ptr, types_arr[i].args_name, &rc);
arr_data = CMGetArrayElementAt(data.value.array, 0, &rc);
switch (types_arr[i].element_type) {
case CMPI_uint32:
if (arr_data.value.uint32 != value.uint32) {
flag = 0;
}
break;
case CMPI_uint16:
if (arr_data.value.uint16 != value.uint16) {
flag = 0;
}
break;
case CMPI_uint8:
if (arr_data.value.uint8 != value.uint8) {
flag = 0;
}
break;
case CMPI_uint64:
if (arr_data.value.uint64 != value.uint64) {
flag = 0;
}
break;
case CMPI_sint32:
if (arr_data.value.sint32 != value.sint32) {
flag = 0;
}
break;
case CMPI_sint16:
if (arr_data.value.sint16 != value.sint16) {
flag = 0;
}
break;
case CMPI_sint8:
if (arr_data.value.sint8 != value.sint8) {
flag = 0;
}
break;
case CMPI_sint64:
if (arr_data.value.sint64 != value.sint64) {
flag = 0;
}
break;
case CMPI_real32:
if (arr_data.value.real32 != value.real32) {
flag = 0;
}
break;
case CMPI_real64:
if (arr_data.value.real64 != value.real64) {
flag = 0;
}
break;
case CMPI_char16:
if (arr_data.value.char16 != value.char16) {
flag = 0;
}
break;
case CMPI_string:
str1 = CMGetCharsPtr(arr_data.value.string, &rc);
str2 = CMGetCharsPtr(value.string, &rc1);
if ((rc.rc != CMPI_RC_OK) ||
(rc1.rc != CMPI_RC_OK) || strcmp(str1, str2)) {
flag = 0;
}
break;
case CMPI_boolean:
if (arr_data.value.boolean != value.boolean) {
flag = 0;
}
break;
case CMPI_dateTime:
datetime1 = CMGetBinaryFormat(arr_data.value.dateTime, &rc);
datetime2 = CMGetBinaryFormat(value.dateTime, &rc1);
if ((rc.rc != CMPI_RC_OK) ||
(rc1.rc != CMPI_RC_OK) || (datetime1 != datetime2)) {
flag = 0;
}
rc = CMRelease(value.dateTime);
break;
case CMPI_ref:
retNamespace = CMGetNameSpace(arr_data.value.ref, &rc);
retClassname = CMGetClassName(arr_data.value.ref, &rc1);
if ((rc.rc == CMPI_RC_OK) && (rc1.rc == CMPI_RC_OK)) {
str1 = CMGetCharsPtr(retNamespace, &rc);
str2 = CMGetCharsPtr(retClassname, &rc1);
if ((rc.rc == CMPI_RC_OK) && (rc1.rc == CMPI_RC_OK)) {
if ((strcmp(str1, "root/cimv2")) ||
(strcmp(str2, "TestCMPI_Instance"))) {
flag = 0;
}
} else {
flag = 0;
}
} else {
flag = 0;
}
rc = CMRelease(value.ref);
break;
case CMPI_instance:
retDataInst = CMGetProperty(arr_data.value.inst, "Property1", &rc);
dataInst = CMGetProperty(value.inst, "Property1", &rc);
if (retDataInst.value.uint32 != dataInst.value.uint32) {
flag = 0;
}
rc = CMRelease(value.inst);
break;
}
if (data.type == types_arr[i].typeA && flag) {
}
}
rc = CMRelease(arr);
rc = CMRelease(args_ptr);
}
return flag;
}
/**
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 CMPIStatus ClassProviderInvokeMethod(CMPIMethodMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * ref,
const char *methodName,
const CMPIArgs * in, CMPIArgs * out)
{
CMPIStatus st = { CMPI_RC_OK, NULL };
CMPIArray *ar;
int rc;
ClassRegister *cReg;
_SFCB_ENTER(TRACE_PROVIDERS, "ClassProviderInvokeMethod");
cReg=getNsReg(ref, &rc);
if (cReg==NULL) {
CMPIStatus st = { CMPI_RC_ERR_INVALID_NAMESPACE, NULL };
_SFCB_RETURN(st);
}
if (strcasecmp(methodName, "getchildren") == 0) {
CMPIData cn = CMGetArg(in, "class", NULL);
_SFCB_TRACE(1,("--- getchildren %s",(char*)cn.value.string->hdl));
cReg->ft->wLock(cReg);
if (cn.type == CMPI_string && cn.value.string && cn.value.string->hdl) {
char *child;
int l=0, i=0;
UtilList *ul = getChildren(cReg, (char *) cn.value.string->hdl);
if (ul) l = ul->ft->size(ul);
ar = CMNewArray(_broker, l, CMPI_string, NULL);
if (ul) for (child = (char *) ul->ft->getFirst(ul); child; child = (char *)
ul->ft->getNext(ul)) {
CMSetArrayElementAt(ar, i++, child, CMPI_chars);
}
st = CMAddArg(out, "children", &ar, CMPI_stringA);
}
else {
}
cReg->ft->wUnLock(cReg);
}
else if (strcasecmp(methodName, "getallchildren") == 0) {
int ignprov=0;
CMPIStatus st;
CMPIData cn = CMGetArg(in, "class", &st);
cReg->ft->wLock(cReg);
if (st.rc!=CMPI_RC_OK) {
cn = CMGetArg(in, "classignoreprov", NULL);
ignprov=1;
}
_SFCB_TRACE(1,("--- getallchildren %s",(char*)cn.value.string->hdl));
if (cn.type == CMPI_string && cn.value.string && cn.value.string->hdl) {
int n=0,i=0;
loopOnChildCount(cReg,(char *)cn.value.string->hdl,&n,ignprov);
_SFCB_TRACE(1,("--- count %d",n));
ar = CMNewArray(_broker, n, CMPI_string, NULL);
if (n) {
_SFCB_TRACE(1,("--- loop %s",(char*)cn.value.string->hdl));
loopOnChildChars(cReg, (char *)cn.value.string->hdl,ar,&i,ignprov);
}
st = CMAddArg(out, "children", &ar, CMPI_stringA);
}
else {
}
cReg->ft->wUnLock(cReg);
}
else if (strcasecmp(methodName, "getassocs") == 0) {
ar = CMNewArray(_broker, cReg->topAssocs, CMPI_string, NULL);
ClassBase *cb = (ClassBase *) (cReg + 1);
UtilHashTable *ct = cb->ht;
HashTableIterator *i;
char *cn;
ClassRecord *crec;
int n;
cReg->ft->wLock(cReg);
for (n = 0, i = ct->ft->getFirst(ct, (void **) &cn, (void **) &crec); i;
i = ct->ft->getNext(ct, i, (void **) &cn, (void **) &crec)) {
if(crec->flags & CREC_isAssociation && crec->parent == NULL) {
/* add top-level association class */
CMSetArrayElementAt(ar, n++, cn, CMPI_chars);
}
}
CMAddArg(out, "assocs", &ar, CMPI_stringA);
cReg->ft->wUnLock(cReg);
}
else if (strcasecmp(methodName, "ischild") == 0) {
char *parent=(char*)CMGetClassName(ref,NULL)->hdl;
char *chldn=(char*)CMGetArg(in, "child", NULL).value.string->hdl;
st.rc = traverseChildren(cReg, parent, chldn);
}
else if (strcasecmp(methodName, "_startup") == 0) {
/* check to see if cacheLimit was specified in providerRegister */
CMPIStatus parm_st = { CMPI_RC_OK, NULL };
CMPIData parmdata = CMGetContextEntry(ctx, "sfcbProviderParameters", &parm_st);
if (parm_st.rc == CMPI_RC_OK ) {
const char* parms = CMGetCharPtr(parmdata.value.string);
/* cacheLimit is currently the only param, so just take whatever is after the '=' */
const char* val = strchr(parms,'=');
/* conversion to uint may cause wrapping; won't catch negatives */
cacheLimit = ((val != NULL) && (cacheLimit = atoi(val+sizeof(char)))>0) ? cacheLimit : 10;
}
st.rc=CMPI_RC_OK;
}
else {
mlogf(M_ERROR,M_SHOW,"--- ClassProvider: Invalid invokeMethod request %s\n", methodName);
st.rc = CMPI_RC_ERR_METHOD_NOT_FOUND;
}
_SFCB_RETURN(st);
}
CMPIInstance * _makeInst_TestClass(
const CMPIBroker * _broker,
const CMPIContext * ctx,
const CMPIObjectPath * ref,
const char ** properties,
CMPIStatus * rc,
unsigned int theKey)
{
CMPIValue opstatus;
CMPIValue status;
CMPIObjectPath * op = NULL;
CMPIInstance * ci = NULL;
char * theName = NULL;
CMPIArray *array = NULL;
char **keys = NULL;
int keyCount = 0;
opstatus.uint16 = 0; /* Unknown */
status.uint16 = 2; /* Enabled */
//
// Initialize Name
//
theName = calloc(1,20);
sprintf(theName, "%u", theKey);
//
// Construct ObjectPath
//
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;
}
//
// Create a new instance and fill it's properties
//
ci = CMNewInstance( _broker, op, rc);
if (CMIsNullObject(ci))
{
CMSetStatusWithChars(
_broker,
rc,
CMPI_RC_ERR_FAILED,
"Create CMPIInstance failed." );
goto exit;
}
//
// Set property filter
//
keys = calloc(2,sizeof(char*));
keys[0] = strdup("theKey");
CMSetPropertyFilter(ci,properties,(const char**)keys);
for (;keys[keyCount]!=NULL;keyCount++)
{
free((char*)keys[keyCount]);
}
free(keys);
//
// Properties of CIM_ManagedElement
//
CMSetProperty(ci,"Caption","Performance Test class",CMPI_chars);
CMSetProperty(
ci,
"Description",
"Test class used for all kinds of testing",
CMPI_chars);
CMSetProperty(ci,"ElementName",theName,CMPI_chars);
//
// Properties of CIM_ManagedSystemElement
//
// TBD: InstallDate
array = CMNewArray(_broker,1,CMPI_uint16,rc);
CMSetArrayElementAt(array,0,&opstatus,CMPI_uint16);
CMSetProperty(ci,"OperationalStatus",(CMPIValue*)&(array),CMPI_uint16A);
//
// Properties of CIM_EnabledLogicalElement
//
CMSetProperty( ci, "EnabledState", &status, CMPI_uint16);
CMSetProperty( ci, "RequestedState", &status, CMPI_uint16);
CMSetProperty( ci, "EnabledDefault", &status, CMPI_uint16);
//
// Properties of CIM_TestClass
//
CMSetProperty(ci,"theKey",&theKey , CMPI_uint32 );
CMSetProperty(ci,"theData",&theKey , CMPI_uint32 );
CMSetProperty(ci,"theString0","Test Data Number Zero",CMPI_chars);
CMSetProperty(ci,"theString1","Test Data Number One",CMPI_chars);
CMSetProperty(ci,"theString2","Test Data Number Two",CMPI_chars);
CMSetProperty(ci,"theString3","Test Data Number Three",CMPI_chars);
CMSetProperty(ci,"theString4","Test Data Number Four",CMPI_chars);
CMSetProperty(ci,"theString5","Test Data Number Five",CMPI_chars);
CMSetProperty(ci,"theString6","Test Data Number Six",CMPI_chars);
CMSetProperty(ci,"theString7","Test Data Number Seven",CMPI_chars);
CMSetProperty(ci,"theString8","Test Data Number Eight",CMPI_chars);
CMSetProperty(ci,"theString9","Test Data Number Nine",CMPI_chars);
exit:
free(theName);
return ci;
}
static CMPIData make_cmpi_data( type_type lextype, int arrayspec,
value_chain * vals )
{
CMPIData data;
CMPIData arr_data;
int i = 0;
data.type = make_cmpi_type(lextype,arrayspec);
data.value.uint64 = 0L; /* set to binary zeros */
if ( vals == NULL ) {
data.state = CMPI_nullValue;
} else if (vals -> val_value == NULL) {
fprintf (stderr,"*** fatal error in backend: NULL value recieved.\n");
abort(); /* paranoia */
}else {
data.state = CMPI_goodValue;
}
if ( data.state == CMPI_goodValue ) {
if (data.type & CMPI_ARRAY) {
/* process array entries */
data.value.array =
CMNewArray(Broker,0,data.type&~CMPI_ARRAY,NULL);
while (vals && vals -> val_value) {
arr_data = make_cmpi_data(lextype,-1,vals);
sfcb_simpleArrayAdd(data.value.array, &arr_data.value, data.type&~CMPI_ARRAY);
i++;
vals = vals -> val_next;
}
} else {
switch (data.type & ~CMPI_ARRAY) {
case CMPI_uint8:
sscanf(vals -> val_value, "%hhu", &data.value.uint8 );
break;
case CMPI_sint8:
sscanf(vals -> val_value, "%hhd", &data.value.sint8 );
break;
case CMPI_uint16:
sscanf(vals -> val_value, "%hu", &data.value.uint16 );
break;
case CMPI_sint16:
sscanf(vals -> val_value, "%hd", &data.value.sint16 );
break;
case CMPI_uint32:
sscanf(vals -> val_value, "%u", &data.value.uint32 );
break;
case CMPI_sint32:
sscanf(vals -> val_value, "%d", &data.value.sint32 );
break;
case CMPI_uint64:
sscanf(vals -> val_value, "%llu", &data.value.uint64);
break;
case CMPI_sint64:
sscanf(vals -> val_value, "%lld", &data.value.uint64 );
break;
case CMPI_real32:
sscanf(vals -> val_value, "%f", &data.value.real32 );
break;
case CMPI_real64:
sscanf(vals -> val_value, "%lf", &data.value.real64 );
break;
case CMPI_char16:
/* this one is suspect to produce garbage */
sscanf(vals -> val_value, "%c", &data.value.uint8 );
break;
case CMPI_string:
data.value.string = CMNewString(Broker,vals -> val_value,NULL);
break;
case CMPI_boolean:
if (strcasecmp("true",vals -> val_value) == 0) {
data.value.boolean = 1;
} else {
data.value.boolean = 0;
}
break;
case CMPI_dateTime:
data.value.dateTime =
CMNewDateTimeFromChars(Broker,vals -> val_value,NULL);
if (data.value.dateTime == NULL) {
fprintf(stderr,"failed to build datetime from %s", vals -> val_value);
data.state = CMPI_nullValue;
}
break;
default: {
char *msg=NULL;
data.value.ref = getObjectPath(vals -> val_value, &msg);
if(msg) {
fprintf(stderr, "Problem with Objectpath %s: %s\n", vals -> val_value, msg);
exit(0);
}
}
}
}
}
return data;
}
CMPIStatus
TestCMPIErrorProviderInvokeMethod (CMPIMethodMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * ref,
const char *methodName,
const CMPIArgs * in, CMPIArgs * out)
{
CMPIString *class_name = NULL;
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIError *cmpiError;
CMPIError *cmpiErrorClone;
CMPICount i, arrSize;
CMPIObjectPath *objPath = NULL;
CMPIUint32 brokerCapabilities;
/* CMPIError data */
const char* inOwningEntity = "ACME";
CMPIString* outOwningEntity;
const char* inMsgID = "ACME0023";
CMPIString* outMsgID;
const char* inMsg = "ACME0023 Need to restock Road Runner bait and traps.";
CMPIString* outMsg;
const CMPIErrorSeverity inSev = ErrorSevMedium;
CMPIErrorSeverity outSev;
const CMPIErrorProbableCause inPc = Equipment_Malfunction;
CMPIErrorProbableCause outPc;
const CMPIrc inCIMStatusCode = CMPI_RC_ERR_FAILED;
CMPIrc outCIMStatusCode;
const char * inCIMStatusCodeDesc = "another failed attempt at road "
"runner elimination";
CMPIString* outCIMStatusCodeDesc;
const CMPIErrorType inErrType = OtherErrorType;
CMPIErrorType outErrType;
const char* inOtherErrType = "Pervasive Coyote Incompetance";
CMPIString* outOtherErrType;
const char* inPcd = "Incorrect use of equipment";
CMPIString* outPcd;
CMPIArray *inRecActions;
CMPIArray *outRecActions;
CMPIArray *inMsgArgs;
CMPIArray *outMsgArgs;
CMPIValue raOne;
CMPIValue raTwo;
const char* inErrSource = "Acme bomb";
CMPIString* outErrSource;
const CMPIErrorSrcFormat inErrSourceFormat = CMPIErrSrcOther;
CMPIErrorSrcFormat outErrSourceFormat;
const char* inOtherErrSourceFormat = "no idea";
CMPIString* outOtherErrSourceFormat;
CMPIData retData;
PROV_LOG_OPEN (_ClassName, _ProviderLocation);
PROV_LOG ("Calling CBGetBrokerCapabilities");
brokerCapabilities = CBGetBrokerCapabilities(_broker);
if (brokerCapabilities & CMPI_MB_Supports_Extended_Error)
{
PROV_LOG("CMPI_MB_Supports_Extended_Error Support : True");
}
else
{
PROV_LOG("CMPI_MB_Supports_Extended_Error Support : False");
CMReturnWithString(CMPI_RC_ERR_NOT_SUPPORTED,
CMNewString(_broker,
"Extended error support not avilable", NULL));
}
PROV_LOG ("--- %s CMPI InvokeMethod() called", _ClassName);
class_name = CMGetClassName (ref, &rc);
PROV_LOG ("InvokeMethod: checking for correct classname [%s]",
CMGetCharsPtr (class_name,NULL));
PROV_LOG ("Calling CMNewCMPIError");
cmpiError = CMNewCMPIError(_broker, inOwningEntity, inMsgID, inMsg,
inSev, inPc, inCIMStatusCode, &rc);
PROV_LOG ("++++ (%s) CMNewCMPIError", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetErrorType");
rc = CMSetErrorType(cmpiError, inErrType);
PROV_LOG ("++++ (%s) CMSetErrorType", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetOtherErrorType");
rc = CMSetOtherErrorType(cmpiError, inOtherErrType);
PROV_LOG ("++++ (%s) CMSetOtherErrorType", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetProbableCauseDescription");
rc = CMSetProbableCauseDescription(cmpiError, inPcd);
PROV_LOG ("++++ (%s) CMSetProbableCauseDescription", strCMPIStatus (rc));
inRecActions = CMNewArray(_broker, 2, CMPI_string, &rc);
PROV_LOG ("++++ (%s) CMNewArray", strCMPIStatus (rc));
raOne.string = CMNewString(_broker, "Fire coyote.", &rc);
PROV_LOG ("++++ (%s) CMNewString", strCMPIStatus (rc));
rc = CMSetArrayElementAt(inRecActions, 0, &raOne, CMPI_string);
PROV_LOG ("++++ (%s) CMSetArrayElementAt [0]", strCMPIStatus (rc));
raTwo.string = CMNewString(_broker, "Give peace a chance.", &rc);
PROV_LOG ("++++ (%s) CMNewString", strCMPIStatus (rc));
rc = CMSetArrayElementAt(inRecActions, 1, &raTwo, CMPI_string);
PROV_LOG ("++++ (%s) CMSetArrayElementAt [1]", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetRecommendedActions");
rc = CMSetRecommendedActions(cmpiError, inRecActions);
PROV_LOG ("++++ (%s) CMSetRecommendedActions", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetErrorSource");
rc = CMSetErrorSource(cmpiError, inErrSource);
PROV_LOG ("++++ (%s) CMSetErrorSource", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetErrorSourceFormat");
rc = CMSetErrorSourceFormat(cmpiError, inErrSourceFormat);
PROV_LOG ("++++ (%s) CMSetErrorSourceFormat", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetOtherErrorSourceFormat");
rc = CMSetOtherErrorSourceFormat(cmpiError, inOtherErrSourceFormat);
PROV_LOG ("++++ (%s) CMSetOtherErrorSourceFormat", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetCIMStatusCodeDescription");
rc = CMSetCIMStatusCodeDescription(cmpiError, inCIMStatusCodeDesc);
PROV_LOG ("++++ (%s) CMSetCIMStatusCodeDescription", strCMPIStatus (rc));
inMsgArgs = CMNewArray(_broker, 1, CMPI_string, &rc);
PROV_LOG ("++++ (%s) CMNewArray", strCMPIStatus (rc));
raOne.string = CMNewString(_broker, "no real inserts", &rc);
PROV_LOG ("++++ (%s) CMNewString", strCMPIStatus (rc));
rc = CMSetArrayElementAt(inMsgArgs, 0, &raOne, CMPI_string);
PROV_LOG ("++++ (%s) CMSetArrayElementAt [0]", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetMessageArguments");
rc = CMSetMessageArguments(cmpiError, inMsgArgs);
PROV_LOG ("++++ (%s) CMSetMessageArguments", strCMPIStatus (rc));
PROV_LOG ("First clone the CMPIError.");
cmpiErrorClone = CMClone(cmpiError, &rc);
PROV_LOG ("++++ (%s) CMClone", strCMPIStatus (rc));
PROV_LOG ("Ok, reading back fields to verify");
PROV_LOG ("Calling CMGetErrorType");
outErrType = CMGetErrorType(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetErrorType (%d)", strCMPIStatus (rc), outErrType);
PROV_LOG ("Calling CMGetOtherErrorType");
outOtherErrType = CMGetOtherErrorType(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetOtherErrorType (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outOtherErrType,NULL));
PROV_LOG ("Calling CMGetOwningEntity");
outOwningEntity = CMGetOwningEntity(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetOwningEntity (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outOwningEntity,NULL));
PROV_LOG ("Calling CMGetMessageID");
outMsgID = CMGetMessageID(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetMessageID (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outMsgID,NULL));
PROV_LOG ("Calling CMGetErrorMessage");
outMsg = CMGetErrorMessage(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetErrorMessage (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outMsg,NULL));
PROV_LOG ("Calling CMGetPerceivedSeverity");
outSev = CMGetPerceivedSeverity(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetPerceivedSeverity (%d)", strCMPIStatus (rc),
outSev);
PROV_LOG ("Calling CMGetProbableCause");
outPc = CMGetProbableCause(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetProbableCause (%d)", strCMPIStatus (rc),
outPc);
PROV_LOG ("Calling CMGetProbableCauseDescription");
outPcd = CMGetProbableCauseDescription(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetProbableCauseDescription (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(outPcd,NULL));
PROV_LOG ("Calling CMGetRecommendedActions");
outRecActions = CMGetRecommendedActions(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetRecommendedActions", strCMPIStatus (rc));
arrSize = CMGetArrayCount(outRecActions, &rc);
PROV_LOG ("++++ (%s) CMGetArrayCount (%d)", strCMPIStatus (rc), arrSize);
for (i = 0 ; i < arrSize ; i++)
{
CMPIData dta = CMGetArrayElementAt(outRecActions, i, &rc);
PROV_LOG ("++++ (%s) CMGetArrayElementAt (%d:%s)", strCMPIStatus (rc),
i, CMGetCharsPtr(dta.value.string,NULL));
}
PROV_LOG ("Calling CMGetErrorSource");
outErrSource = CMGetErrorSource(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetErrorSource (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outErrSource,NULL));
PROV_LOG ("Calling CMGetErrorSourceFormat");
outErrSourceFormat = CMGetErrorSourceFormat(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetErrorSourceFormat (%d)", strCMPIStatus (rc),
outErrSourceFormat);
PROV_LOG ("Calling CMGetOtherErrorSourceFormat");
outOtherErrSourceFormat = CMGetOtherErrorSourceFormat(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetOtherErrorSourceFormat (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outOtherErrSourceFormat,NULL));
PROV_LOG ("Calling CMGetCIMStatusCode");
outCIMStatusCode = CMGetCIMStatusCode(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetCIMStatusCode (%d)", strCMPIStatus (rc),
outCIMStatusCode);
PROV_LOG ("Calling CMGetCIMStatusCodeDescription");
outCIMStatusCodeDesc = CMGetCIMStatusCodeDescription(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetCIMStatusCodeDescription (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outCIMStatusCodeDesc,NULL));
PROV_LOG ("Calling CMGetMessageArguments");
outMsgArgs = CMGetMessageArguments(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetMessageArguments", strCMPIStatus (rc));
arrSize = CMGetArrayCount(outMsgArgs, &rc);
PROV_LOG ("++++ (%s) CMGetArrayCount (%d)", strCMPIStatus (rc), arrSize);
for (i = 0 ; i < arrSize ; i++)
{
CMPIData dta = CMGetArrayElementAt(outMsgArgs, i, &rc);
PROV_LOG ("++++ (%s) CMGetArrayElementAt (%d:%s)", strCMPIStatus (rc),
i, CMGetCharsPtr(dta.value.string,NULL));
}
PROV_LOG ("Calling CMPIResultFT.returnData");
rc = (rslt)->ft->returnError (rslt, cmpiErrorClone);
PROV_LOG ("++++ (%s) returnData", strCMPIStatus (rc));
PROV_LOG ("Releasing cloned CMPIError");
rc = CMRelease(cmpiErrorClone);
PROV_LOG ("++++ (%s) CMClone", strCMPIStatus (rc));
//Test Error Paths
PROV_LOG ("Testing for Error Paths in CMPI_Error.cpp");
PROV_LOG ("Calling CMNewCMPIError");
cmpiError = CMNewCMPIError(_broker,
inOwningEntity,
inMsgID,
inMsg,
inSev,
inPc,
inCIMStatusCode,
&rc);
PROV_LOG ("++++ (%s) CMNewCMPIError", strCMPIStatus (rc));
PROV_LOG ("Calling CMGetErrorType without setting the ErrorType");
outErrType = CMGetErrorType(cmpiError, &rc);
if (!outErrType)
{
PROV_LOG ("++++ (%s) CMGetErrorType (%d)", strCMPIStatus (rc),
outErrType);
}
PROV_LOG ("Calling CMGetOtherErrorType without setting the OtherErrorType");
outOtherErrType = CMGetOtherErrorType(cmpiError, &rc);
if (outOtherErrType == NULL)
{
PROV_LOG ("++++ (%s) CMGetOtherErrorType", strCMPIStatus (rc));
}
PROV_LOG ("Testing CMSetMessageArguments");
CMRelease(inMsgArgs);
inMsgArgs = CMNewArray(_broker, 1, CMPI_uint32, &rc);
PROV_LOG ("++++ (%s) CMNewArray inMsgArgs of CMPI_uint32 type",
strCMPIStatus (rc));
raOne.uint32 = 32;
rc = CMSetArrayElementAt(inMsgArgs, 0, &raOne, CMPI_uint32);
PROV_LOG ("++++ (%s) CMSetArrayElementAt [0]", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetMessageArguments with input array of uint32");
rc = CMSetMessageArguments(cmpiError, inMsgArgs);
PROV_LOG ("++++ (%s) CMSetMessageArguments", strCMPIStatus (rc));
inMsgArgs->hdl = NULL;
PROV_LOG ("Calling CMSetMessageArguments with input array with NULL handle");
rc = CMSetMessageArguments(cmpiError, inMsgArgs);
PROV_LOG ("++++ (%s) CMSetMessageArguments", strCMPIStatus (rc));
PROV_LOG ("Testing CMSetRecommendedActions");
CMRelease(inRecActions);
inRecActions = CMNewArray(_broker, 1, CMPI_uint32, &rc);
PROV_LOG ("++++ (%s) CMNewArray inRecActions of CMPI_uint32",
strCMPIStatus (rc));
raOne.uint32 = 32;
rc = CMSetArrayElementAt(inRecActions, 0, &raOne, CMPI_uint32);
PROV_LOG ("++++ (%s) CMSetArrayElementAt [0]", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetRecommendedActions with input array of CMPI_uint32");
rc = CMSetRecommendedActions(cmpiError, inRecActions);
PROV_LOG ("++++ (%s) CMSetRecommendedActions", strCMPIStatus (rc));
inRecActions->hdl = NULL;
PROV_LOG ("Calling CMSetRecommendedActions with input array"
" with NULL handle");
rc = CMSetRecommendedActions(cmpiError, inRecActions);
PROV_LOG ("++++ (%s) CMSetRecommendedActions", strCMPIStatus (rc));
/* Cases when CMPIError object handle is NULL*/
cmpiError->hdl = NULL;
PROV_LOG ("Clone the CMPIError with NULL handle.");
cmpiErrorClone = CMClone(cmpiError, &rc);
if (cmpiErrorClone == NULL)
{
PROV_LOG ("++++ (%s) CMClone", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetErrorType with NULL handle");
outErrType = CMGetErrorType(cmpiError, &rc);
if (!outErrType)
{
PROV_LOG ("++++ (%s) CMGetErrorType (%d)", strCMPIStatus (rc),
outErrType);
}
PROV_LOG ("Calling CMGetOtherErrorType with NULL handle");
outOtherErrType = CMGetOtherErrorType(cmpiError, &rc);
if (outOtherErrType == NULL)
{
PROV_LOG ("++++ (%s) CMGetOtherErrorType ", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetOwningEntity with NULL handle");
outOwningEntity = CMGetOwningEntity(cmpiError, &rc);
if (outOwningEntity == NULL)
{
PROV_LOG ("++++ (%s) CMGetOwningEntity ", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetMessageID with NULL handle");
outMsgID = CMGetMessageID(cmpiError, &rc);
if (!outMsgID)
{
PROV_LOG ("++++ (%s) CMGetMessageID", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetErrorMessage with NULL handle");
outMsg = CMGetErrorMessage(cmpiError, &rc);
if (!outMsg)
{
PROV_LOG ("++++ (%s) CMGetErrorMessage", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetPerceivedSeverity with NULL handle");
outSev = CMGetPerceivedSeverity(cmpiError, &rc);
if (!outSev)
{
PROV_LOG ("++++ (%s) CMGetPerceivedSeverity (%d)", strCMPIStatus (rc),
outSev);
}
PROV_LOG ("Calling CMGetProbableCause with NULL handle");
outPc = CMGetProbableCause(cmpiError, &rc);
if (!outPc)
{
PROV_LOG ("++++ (%s) CMGetProbableCause (%d)", strCMPIStatus (rc),
outPc);
}
PROV_LOG ("Calling CMGetProbableCauseDescription with NULL handle");
outPcd = CMGetProbableCauseDescription(cmpiError, &rc);
if (!outPcd)
{
PROV_LOG ("++++ (%s) CMGetProbableCauseDescription ",
strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetRecommendedActions with NULL handle");
outRecActions = CMGetRecommendedActions(cmpiError, &rc);
if (!outRecActions)
{
PROV_LOG ("++++ (%s) CMGetRecommendedActions", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetErrorSource with NULL handle");
outErrSource = CMGetErrorSource(cmpiError, &rc);
if (!outErrSource)
{
PROV_LOG ("++++ (%s) CMGetErrorSource", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetErrorSourceFormat with NULL handle");
outErrSourceFormat = CMGetErrorSourceFormat(cmpiError, &rc);
if (!outErrSourceFormat)
{
PROV_LOG ("++++ (%s) CMGetErrorSourceFormat (%d)", strCMPIStatus (rc),
outErrSourceFormat);
}
PROV_LOG ("Calling CMGetOtherErrorSourceFormat with NULL handle");
outOtherErrSourceFormat = CMGetOtherErrorSourceFormat(cmpiError, &rc);
if (!outOtherErrSourceFormat)
{
PROV_LOG ("++++ (%s) CMGetOtherErrorSourceFormat", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetCIMStatusCode with NULL handle");
outCIMStatusCode = CMGetCIMStatusCode(cmpiError, &rc);
if (!outCIMStatusCode)
{
PROV_LOG ("++++ (%s) CMGetCIMStatusCode (%d)", strCMPIStatus (rc),
outCIMStatusCode);
}
PROV_LOG ("Calling CMGetCIMStatusCodeDescription with NULL handle");
outCIMStatusCodeDesc = CMGetCIMStatusCodeDescription(cmpiError, &rc);
if (!outCIMStatusCodeDesc)
{
PROV_LOG ("++++ (%s) CMGetCIMStatusCodeDescription", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetMessageArguments with NULL handle");
outMsgArgs = CMGetMessageArguments(cmpiError, &rc);
if (!outMsgArgs)
{
PROV_LOG ("++++ (%s) CMGetMessageArguments", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMSetErrorType with NULL handle");
rc = CMSetErrorType(cmpiError, inErrType);
PROV_LOG ("++++ (%s) CMSetErrorType", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetOtherErrorType with NULL handle");
rc = CMSetOtherErrorType(cmpiError, inOtherErrType);
PROV_LOG ("++++ (%s) CMSetOtherErrorType", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetProbableCauseDescription with NULL handle");
rc = CMSetProbableCauseDescription(cmpiError, inPcd);
PROV_LOG ("++++ (%s) CMSetProbableCauseDescription", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetRecommendedActions with NULL handle");
rc = CMSetRecommendedActions(cmpiError, inRecActions);
PROV_LOG ("++++ (%s) CMSetRecommendedActions", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetErrorSource with NULL handle");
rc = CMSetErrorSource(cmpiError, inErrSource);
PROV_LOG ("++++ (%s) CMSetErrorSource", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetErrorSourceFormat with NULL handle");
rc = CMSetErrorSourceFormat(cmpiError, inErrSourceFormat);
PROV_LOG ("++++ (%s) CMSetErrorSourceFormat", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetOtherErrorSourceFormat with NULL handle");
rc = CMSetOtherErrorSourceFormat(cmpiError, inOtherErrSourceFormat);
PROV_LOG ("++++ (%s) CMSetOtherErrorSourceFormat", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetCIMStatusCodeDescription with NULL handle");
rc = CMSetCIMStatusCodeDescription(cmpiError, inCIMStatusCodeDesc);
PROV_LOG ("++++ (%s) CMSetCIMStatusCodeDescription", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetMessageArguments with NULL handle");
rc = CMSetMessageArguments(cmpiError, inMsgArgs);
PROV_LOG ("++++ (%s) CMSetMessageArguments", strCMPIStatus (rc));
PROV_LOG_CLOSE();
// Test case to increase coverage in CMPI_Broker.cpp
objPath = CMNewObjectPath (_broker,
"test/TestProvider",
"TestCMPI_Method",
&rc);
retData = CBInvokeMethod(_broker,
ctx,
objPath,
"testReturn",
in,
out,
&rc);
PROV_LOG_OPEN (_ClassName, _ProviderLocation);
if(retData.value.uint32 == 2 && rc.rc == CMPI_RC_OK)
{
PROV_LOG ("++++ (%s) CMInvokeMethod", strCMPIStatus (rc));
}
PROV_LOG ("--- %s CMPI InvokeMethod() exited with CMPI_RC_ERR_FAILED",
_ClassName);
PROV_LOG_CLOSE();
CMReturnWithString(inCIMStatusCode,
CMNewString(_broker, "TestError invokeMethod() expected failure", NULL));
}
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);
}
/****************************************************************************
* disk_rasd_from_vbd
*
* This function builds a new Xen_Disk CIM instance based on the information
* in the VBD record
*
* Returns 1 on Success and 0 on failure.
*****************************************************************************/
int disk_rasd_from_vbd(
const CMPIBroker* broker,
xen_utils_session *session,
CMPIInstance *inst,
xen_vm_record *vm_rec,
xen_vbd_record *vbd_rec,
xen_vdi_record *vdi_rec
)
{
char buf[MAX_INSTANCEID_LEN];
xen_sr_record *sr_rec = NULL;
unsigned long long physical_utilization = 1, limit = 1, virtual_quantity = 1;
DMTF_ResourceType rasd_type = DMTF_ResourceType_Storage_Extent;
uint64_t block_size = 1;
bool autoalloc = false;
DMTF_MappingBehavior behaviour = DMTF_MappingBehavior_Dedicated;
char *alloc_unit = "byte";
Access access = Access_Unknown;
RESET_XEN_ERROR(session->xen);
if (vm_rec == NULL) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("--- Orphaned VBD"));
return 0;
}
_CMPICreateNewDeviceInstanceID(buf, MAX_INSTANCEID_LEN, vm_rec->uuid, vbd_rec->uuid);
if (vdi_rec) {
if (vdi_rec->sharable)
behaviour = DMTF_MappingBehavior_Hard_Affinity;
physical_utilization = vdi_rec->physical_utilisation;
limit = vdi_rec->virtual_size;
virtual_quantity = vdi_rec->virtual_size;
if (vdi_rec->sr->is_record)
sr_rec = vdi_rec->sr->u.handle;
else
xen_sr_get_record(session->xen, &sr_rec, vdi_rec->sr->u.handle);
}
if (vbd_rec->mode == XEN_VBD_MODE_RW)
access = Access_Read_Write_Supported;
else
access = Access_Readable;
DMTF_ConsumerVisibility virtualized = DMTF_ConsumerVisibility_Virtualized;
if (vbd_rec->type == XEN_VBD_TYPE_CD) {
rasd_type = DMTF_ResourceType_DVD_drive;
alloc_unit = "count";
virtual_quantity = 1;
}
/* Set the CMPIInstance properties from the resource data. */
/* Key Proerpty first */
CMSetProperty(inst, "InstanceID",(CMPIValue *)buf, CMPI_chars);
/* Rest of the keys follow */
CMSetProperty(inst, "Caption",(CMPIValue *)"Extended Settings for a Xen Virtual Disk", CMPI_chars);
CMSetProperty(inst, "ResourceType",(CMPIValue *)&rasd_type, CMPI_uint16);
CMSetProperty(inst, "ResourceSubType",(CMPIValue *)"DMTF:xen:vbd", CMPI_chars); /* required by DMTF */
CMSetProperty(inst, "Access",(CMPIValue *)&access, CMPI_uint16);
CMSetProperty(inst, "AddressOnParent",(CMPIValue *)vbd_rec->userdevice, CMPI_chars);
CMSetProperty(inst, "AllocationUnits",(CMPIValue *)alloc_unit, CMPI_chars);
CMSetProperty(inst, "AutomaticAllocation",(CMPIValue *)&autoalloc, CMPI_boolean);
CMSetProperty(inst, "AutomaticDeallocation", (CMPIValue *)&autoalloc, CMPI_boolean);
CMSetProperty(inst, "ConsumerVisibility", (CMPIValue *)&virtualized, CMPI_uint16);
CMSetProperty(inst, "VirtualQuantity",(CMPIValue *)&virtual_quantity, CMPI_uint64);
CMSetProperty(inst, "VirtualQuantityUnits",(CMPIValue *)alloc_unit, CMPI_chars);
CMSetProperty(inst, "Reservation",(CMPIValue *)&limit, CMPI_uint64);
CMSetProperty(inst, "Limit",(CMPIValue *)&limit, CMPI_uint64);
CMSetProperty(inst, "VirtualResourceBlockSize",(CMPIValue *)&block_size, CMPI_uint64);
CMSetProperty(inst, "HostResourceBlockSize",(CMPIValue *)&block_size, CMPI_uint64);
/* Setup the Configuration properties */
if (vdi_rec) {
CMSetProperty(inst, "ElementName",(CMPIValue *)vdi_rec->name_label, CMPI_chars);
CMSetProperty(inst, "Description",(CMPIValue *)vdi_rec->name_description, CMPI_chars);
/* HostResource requires string in WBEM URI Format */
CMPIObjectPath *disk_ref = disk_image_create_ref(broker, DEFAULT_NS, session, sr_rec->uuid, vdi_rec->uuid);
if (disk_ref) {
/* conver objectpath to string form */
char *disks_uri = xen_utils_CMPIObjectPath_to_WBEM_URI(broker, disk_ref);
if (disks_uri) {
CMPIArray *arr = CMNewArray(broker, 1, CMPI_chars, NULL);
CMSetArrayElementAt(arr, 0, (CMPIValue *) disks_uri, CMPI_chars);
CMSetProperty(inst, "HostResource", &arr, CMPI_charsA);
}
}
CMSetProperty(inst, "HostExtentName",(CMPIValue *)vdi_rec->uuid, CMPI_chars);
NameFormat name_format = NameFormat_Other;
CMSetProperty(inst, "HostExtentNameFormat",(CMPIValue *)&name_format, CMPI_uint16);
CMSetProperty(inst, "OtherHostExtentNameFormat",(CMPIValue *)"Xen VDI UUID", CMPI_chars);
NameNamespace name_namespace = NameNamespace_Other;
CMSetProperty(inst, "HostExtentNameNamespace",(CMPIValue *)&name_namespace, CMPI_uint16);
CMSetProperty(inst, "OtherHostExtentNameNamespace",(CMPIValue *)"Xen UUID", CMPI_chars);
}
CMSetProperty(inst, "MappingBehavior",(CMPIValue *)&behaviour, CMPI_uint16);
if (sr_rec)
CMSetProperty(inst, "PoolID", sr_rec->uuid, CMPI_chars);
// Derived class properties
CMSetProperty(inst, "Bootable",(CMPIValue *)&vbd_rec->bootable, CMPI_boolean);
// Others not used
//CMSetProperty(inst, "Address",(CMPIValue *)<value>, CMPI_chars);
//CMPIArray *arr = CMNewArray(broker, 1, CMPI_chars, NULL);
//CMSetArrayElementAt(arr, 0, (CMPIValue *) buf, CMPI_chars);
//CMSetProperty(inst, "Connection", &arr, CMPI_charsA);
//CMSetProperty(inst, "ChangeableType",(CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "ConfigurationName",(CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "Generation",(CMPIValue *)&<value>, CMPI_uint64);
//CMSetProperty(inst, "OtherResourceType", (CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "HostExtentStartingAddress",(CMPIValue *)&<value>, CMPI_uint64);
//CMSetProperty(inst, "MaxConsumableResource",(CMPIValue *)<value>, CMPI_uint64);
//CMSetProperty(inst, "CurrentlyConsumedResource",(CMPIValue *)<value>, CMPI_uint64);
//CMSetProperty(inst, "ConsumedResourceUnit",(CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "Parent",(CMPIValue *)<value>, CMPI_chars); /* This is going to be useful for diff disks WBEM URI */
//CMSetProperty(inst, "Weight",(CMPIValue *)&<value>, CMPI_uint32);
/* Free time */
if (sr_rec && vdi_rec && !vdi_rec->sr->is_record)
xen_sr_record_free(sr_rec);
return CMPI_RC_OK;
}
// To increase the coverage in CMPIBrokerEnc.cpp
static int _testBrokerEnc (const CMPIContext * ctx,
const CMPIResult * rslt)
{
int flag = 1 ;
int count;
char* msgId;
char* illegal;
char path[100];
void* hdl;
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIString *type;
CMPIString *cmpiStr;
CMPIBoolean bol=0;
CMPIBoolean bool=0;
CMPIArray* cmpiArray = NULL ;
CMPIInstance* instance = NULL;
CMPIInstance* instance1 = NULL;
CMPIInstance* instanceErr = NULL;
CMPIObjectPath* objPath = NULL;
CMPIObjectPath* objPath1 = NULL;
CMPICount cmpiCnt = 5;
CMPIType cmpiType = CMPI_uint64;
CMPIDateTime* cmpiDateTime = NULL ;
CMPIMsgFileHandle msgFileHandle;
CMPIEnumeration* cmpiEnum;
CMPISelectExp* selExp;
CMPIValue val;
CMPIError* err;
CMPIStatus* rc1 = NULL;
CMPIArgs* args = NULL;
void* handle;
CMPIInstanceFT* funcTable;
PROV_LOG ("++++ _testBrokerEnc ");
PROV_LOG ("++++ ObjectPath testing");
objPath1 = CMNewObjectPath (_broker, NULL, _ClassName, &rc);
PROV_LOG ("++++ New object path with NULL namespace creation : (%s)",
strCMPIStatus (rc));
CMRelease(objPath1);
objPath1 = CMNewObjectPath (_broker, _Namespace, "abc", &rc);
PROV_LOG ("++++ New object path with wrong classname : (%s)",
strCMPIStatus (rc));
instance = CMNewInstance(_broker, NULL, &rc);
PROV_LOG ("++++ New Instance with NULL object path : (%s)",
strCMPIStatus (rc));
handle = objPath1->hdl;
objPath1->hdl=NULL;
instance = CMNewInstance(_broker, objPath1, &rc);
PROV_LOG ("++++ New Instance with object path handle set to NULL: (%s)",
strCMPIStatus (rc));
objPath1->hdl = handle;
objPath = make_ObjectPath(_broker, _Namespace, _ClassName);
instance = CMNewInstance(_broker, objPath, &rc);
PROV_LOG ("++++ New Instance creation status: (%s)",
strCMPIStatus (rc));
instance1 = CMClone(instance, &rc);
instanceErr = CMClone(instance, &rc);
cmpiStr = CMNewString(_broker, NULL, &rc);
PROV_LOG ("++++ Status of mbNewString with NULL parameter:(%s)",
strCMPIStatus (rc));
err = CMNewCMPIError(_broker, "abc", "abc", "abc", 4, 5, 6, rc1);
if (err)
{
PROV_LOG ("++++ CMNewCMPIError called with null rc");
}
cmpiDateTime = CMNewDateTimeFromChars(_broker, "datetime", &rc);
PROV_LOG ("++++ Status of CMNewDateTimeFromChars with junk parameter:(%s)",
strCMPIStatus (rc));
if (!CMClassPathIsA(_broker, NULL, NULL, &rc))
{
PROV_LOG ("++++ Error Status of CMClassPathIsA:(%s)",
strCMPIStatus (rc));
}
if (!CMClassPathIsA(_broker, objPath, NULL, &rc))
{
PROV_LOG ("++++ Error Status of CMClassPathIsA:(%s)",
strCMPIStatus (rc));
}
illegal = "$";
if (!CMClassPathIsA(_broker, objPath, illegal, &rc))
{
PROV_LOG ("++++ Error Status of CMClassPathIsA:(%s)",
strCMPIStatus (rc));
}
rc = CMLogMessage(_broker,
2,
"TestProvider",
"Testing Severity 2 in TestCMPIBrokerEnc",
NULL);
PROV_LOG ("++++ Status of CMLogMessage with Severity 2:(%s)",
strCMPIStatus (rc));
rc = CMLogMessage(_broker,
3,
"TestProvider",
"Testing Severity 3 in TestCMPIBrokerEnc",
NULL);
PROV_LOG ("++++ Status of CMLogMessage with Severity 3:(%s)",
strCMPIStatus (rc));
rc = CMLogMessage(_broker,
4,
"TestProvider",
"Testing Severity 4 in TestCMPIBrokerEnc",
NULL);
PROV_LOG ("++++ Status of CMLogMessage with Severity 4:(%s)",
strCMPIStatus (rc));
rc = CMTraceMessage(_broker,
2,
"CMPIProvider",
"Tracing for level 2",
NULL);
PROV_LOG ("++++ Status of CMTraceMessage with level 2:(%s)",
strCMPIStatus (rc));
rc = CMTraceMessage(_broker,
3,
"CMPIProvider",
"Tracing for level 3",
NULL);
PROV_LOG ("++++ Status of CMTraceMessage with level 3:(%s)",
strCMPIStatus (rc));
rc = CMTraceMessage(_broker,
4,
"CMPIProvider",
"Tracing for level 4",
NULL);
PROV_LOG ("++++ Status of CMTraceMessage with level 4:(%s)",
strCMPIStatus (rc));
cmpiStr = CMNewString(_broker, "Tracing for level 5", &rc);
rc = CMTraceMessage(_broker,
5,
"CMPIProvider",
NULL,
cmpiStr);
PROV_LOG ("++++ Status of CMTraceMessage with level 5:(%s)",
strCMPIStatus (rc));
CMRelease(cmpiStr);
PROV_LOG ("++++ Calling mbEncToString function ");
type = CDToString (_broker, _broker, &rc);
PROV_LOG ("++++ Error status of mbEncToString with wrong object path:"
" (%s)",
strCMPIStatus (rc));
type = CDToString (_broker, NULL, &rc);
PROV_LOG ("++++ Error status of mbEncToString with NULL parameter:"
" (%s)",
strCMPIStatus (rc));
type = CDToString (_broker, type, &rc);
PROV_LOG ("++++ Passing CMPIString to mbEncToString successes : (%s)",
strCMPIStatus (rc));
type = CDToString (_broker, objPath, &rc);
PROV_LOG ("++++ Passing CMPIObjectPath to mbEncToString successes : (%s)",
strCMPIStatus (rc));
handle = objPath1->hdl;
objPath1->hdl = NULL;
type = CDToString (_broker, objPath1, &rc);
if ( rc.rc == CMPI_RC_ERR_INVALID_PARAMETER)
{
PROV_LOG ("++++ Error status of mbEncToString with object path with "
"NULL handle: (%s)",
strCMPIStatus (rc));
}
objPath1->hdl = handle;
val.boolean = 1;
rc = CMSetProperty (instance, "Boolean", &val, CMPI_boolean);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_boolean : (%s)",
strCMPIStatus (rc));
val.uint8 = 8;
rc = CMSetProperty (instance, "Uint8", &val, CMPI_uint8);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_uint8 : (%s)",
strCMPIStatus (rc));
val.uint16 = 16;
rc = CMSetProperty (instance, "Uint16", &val, CMPI_uint16);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_uint16 : (%s)",
strCMPIStatus (rc));
val.uint32 = 32;
rc = CMSetProperty (instance, "Uint32", &val, CMPI_uint32);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_uint32 : (%s)",
strCMPIStatus (rc));
val.uint64 = 64;
rc = CMSetProperty (instance, "Uint64", &val, CMPI_uint64);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_uint64 : (%s)",
strCMPIStatus (rc));
val.sint8 = -8;
rc = CMSetProperty (instance, "Sint8", &val, CMPI_sint8);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_sint8 : (%s)",
strCMPIStatus (rc));
val.sint16 = -16;
rc = CMSetProperty (instance, "Sint16", &val, CMPI_sint16);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_sint16 : (%s)",
strCMPIStatus (rc));
val.sint32 = -32;
rc = CMSetProperty (instance, "Sint32", &val, CMPI_sint32);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_sint32 : (%s)",
strCMPIStatus (rc));
val.sint64 = -64;
rc = CMSetProperty (instance, "Sint64", &val, CMPI_sint64);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_sint64 : (%s)",
strCMPIStatus (rc));
val.real32 = 32.32;
rc = CMSetProperty (instance, "Real32", &val, CMPI_real32);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_real32 : (%s)",
strCMPIStatus (rc));
val.real64 = 64.64;
rc = CMSetProperty (instance, "Real64", &val, CMPI_real64);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_real64 : (%s)",
strCMPIStatus (rc));
val.char16 = 'c';
rc = CMSetProperty (instance, "Char16", &val, CMPI_char16);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_char16 : (%s)",
strCMPIStatus (rc));
cmpiDateTime = CMNewDateTime (_broker, &rc);
val.dateTime = cmpiDateTime;
rc = CMSetProperty (instance, "DateTime", &val, CMPI_dateTime);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_dateTime : (%s)",
strCMPIStatus (rc));
val.ref = objPath;
rc = CMSetProperty (instance, "Ref", &val, CMPI_ref);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_ref : (%s)",
strCMPIStatus (rc));
val.inst = instance1;
rc = CMSetProperty (instance, "Instance", &val, CMPI_instance);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_instance : (%s)",
strCMPIStatus (rc));
type = CDToString (_broker, instance, &rc);
PROV_LOG ("++++ Passing CMPIInstance to mbEncToString successes : (%s)",
strCMPIStatus (rc));
args = CMNewArgs(_broker, &rc);
PROV_LOG ("++++ Status of CMNewArgs : (%s)", strCMPIStatus (rc));
type = CDToString (_broker, args, &rc);
PROV_LOG ("++++ Passing CMPIArgs to mbEncToString successes : (%s)",
strCMPIStatus (rc));
PROV_LOG ("++++ Calling mbEncGetType function ");
rc1 = NULL;
type = CDGetType (_broker, NULL, rc1);
if (!type)
{
PROV_LOG ("++++ Error calling mbEncGetType with NULL rc");
}
rc1 = NULL;
funcTable = instanceErr->ft;
instanceErr->ft = NULL;
type = CDGetType (_broker, instanceErr, rc1);
if (!type)
{
PROV_LOG ("++++ Error calling mbEncGetType with wrong parameter and"
" NULL rc");
}
type = CDGetType (_broker, instanceErr, &rc);
PROV_LOG ("++++ Error status of mbEncGetType with wrong input : (%s)",
strCMPIStatus (rc));
instanceErr->ft = funcTable;
type = CDGetType (_broker, NULL, &rc);
PROV_LOG ("++++ Error status of mbEncGetType with NULL input : (%s)",
strCMPIStatus (rc));
type = CDGetType (_broker, instance, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIInstance"
" : (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CDGetType (_broker, objPath, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIObjectPath:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
cmpiStr = CMNewString(_broker, "Test1", & rc);
type = CDGetType (_broker, cmpiStr, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIString:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CDGetType (_broker, _broker, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIBroker:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
cmpiArray = CMNewArray(_broker, cmpiCnt,cmpiType, &rc);
type = CDGetType (_broker, cmpiArray, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIArray:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CDGetType (_broker, cmpiDateTime, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIDateTime:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CDGetType (_broker, ctx, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIContext:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CDGetType (_broker, rslt, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIResult:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
rc1 = NULL;
selExp = CMNewSelectExp(_broker,
"SELECT c,b FROM TestCMPI_Indication WHERE c='c' OR b=1",
"WQL",
NULL,
rc1);
PROV_LOG ("++++ CMNewSelectExp with rc set to NULL Called");
selExp = CMNewSelectExp(_broker,
"SELECT c,b FROM TestCMPI_Indication",
"WQL",
NULL,
&rc);
PROV_LOG ("++++ Status of CMNewSelectExp: (%s) ",
strCMPIStatus (rc));
type = CDGetType (_broker, selExp, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPISelectExp:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
handle = objPath1->hdl;
objPath1->hdl = NULL;
rc = CMRelease(objPath1);
PROV_LOG ("++++ Status of CMRelease(objPath1): (%s)",
strCMPIStatus (rc));
objPath1->hdl = handle;
rc = CMRelease(objPath1);
PROV_LOG ("++++ Status of CMRelease(objPath1): (%s)",
strCMPIStatus (rc));
objPath1 = CMNewObjectPath(_broker,
"test/TestProvider",
"TestCMPI_Instance",
&rc);
PROV_LOG ("++++ Status of CMNewObjectPath for TestCMPI_Instance : (%s)",
strCMPIStatus (rc));
PROV_LOG_CLOSE();
cmpiEnum = CBEnumInstances(_broker, ctx, objPath1, NULL, &rc);
PROV_LOG_OPEN (_ClassName, _ProviderLocation);
PROV_LOG ("++++ Status of CBEnumInstances : (%s)",
strCMPIStatus (rc));
type = CDGetType (_broker, cmpiEnum, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIEnumeration:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CDGetType (_broker, args, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIArgs:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
PROV_LOG ("++++ Calling mbEncIsOfType function ");
bol = CDIsOfType (_broker, NULL, "No object", rc1);
if(!bol)
{
PROV_LOG ("++++Calling mbEncIsOfType with NULL rc and wrong"
" parameters");
}
bol = CDIsOfType (_broker, instance, "CMPIInstance", rc1);
if(!bol)
{
PROV_LOG ("++++ Calling mbEncIsOfType with NULL rc");
}
bol = CDIsOfType (_broker, NULL, "No object", &rc);
PROV_LOG ("++++ Error Status of mbEncIsOfType : (%s)", strCMPIStatus (rc));
bol = CDIsOfType (_broker, instance, "CMPIInstance", &rc);
if ( bol )
{
PROV_LOG ("++++ CDIsOfType for CMPIInstance status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, instance, "CMPI", &rc);
if ( !bol )
{
PROV_LOG ("++++ CDIsOfType for CMPIInstance status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, objPath, "CMPIObjectPath", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIObjectPath status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, objPath, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIObjectPath status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, cmpiDateTime, "CMPIDateTime", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIDateTime status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, cmpiDateTime, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIDateTime status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, cmpiStr, "CMPIString", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIString status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, cmpiStr, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIString status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, _broker, "CMPIBroker", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIBroker status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, _broker, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIBroker status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, cmpiArray, "CMPIArray", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIArray status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, cmpiArray, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIArray status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, rslt, "CMPIResult", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIResult status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, rslt, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIResult status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, ctx, "CMPIContext", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIContext status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, ctx, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIContext status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, cmpiEnum, "CMPIEnumeration", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIEnumeration status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, cmpiEnum, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIEnumeration status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
/* Testcase to increase coverage in CMPI_Enumeration.cpp*/
rc = CMRelease(cmpiEnum);
PROV_LOG ("++++ Status of CMRelease on cmpiEnum :(%s)",
strCMPIStatus (rc));
/**********************************************************/
bol = CDIsOfType (_broker, selExp, "CMPISelectExp", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPISelectExp status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, selExp, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPISelectExp status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, args, "CMPIArgs", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIArgs status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, args, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CdIsOfType for CMPIArgs status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
type = CMGetMessage (_broker,
"msgid",
"Test 0 arguments",
&rc,
0);
PROV_LOG ("++++ Status of GetMessage with 0 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0",
&rc,
CMFmtArgs1(CMFmtChars("one argument")));
PROV_LOG ("++++ Status of GetMessage with 1 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0 $1",
&rc,
CMFmtArgs2(CMFmtChars("Sint32 ::"),
CMFmtSint(-1)));
PROV_LOG ("++++ Status of GetMessage with 2 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0 $1, $2",
&rc,
CMFmtArgs3(CMFmtChars("Sint32, Uint32 ::"),
CMFmtSint(-1),
CMFmtUint(1)));
PROV_LOG ("++++ Status of GetMessage with 3 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0 $1, $2, $3",
&rc,
CMFmtArgs4(CMFmtChars("Sint32, Uint32, Sint64 ::"),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64)));
PROV_LOG ("++++ Status of GetMessage with 4 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0 $1, $2, $3, $4",
&rc,
CMFmtArgs5(CMFmtChars("Sint32, Uint32, Sint64, Uint64 ::"),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64)));
PROV_LOG ("++++ Status of GetMessage with 5 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0 $1, $2, $3, $4, $5",
&rc,
CMFmtArgs6(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64 ::"),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64),
CMFmtReal(64.64)));
PROV_LOG ("++++ Status of GetMessage with 6 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0 $1, $2, $3, $4, $5, $6",
&rc,
CMFmtArgs7(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64,"
" Boolean:: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64),
CMFmtReal(64.64),
CMFmtBoolean(1)));
PROV_LOG ("++++ Status of GetMessage with 7 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0 $1, $2, $3, $4, $5, $6, $7",
&rc,
CMFmtArgs8(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64,"
" Boolean, chars:: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64),
CMFmtReal(64.64),
CMFmtBoolean(1),
CMFmtChars("chars")));
PROV_LOG ("++++ Status of GetMessage with 8 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0 $1, $2, $3, $4, $5, $6, $7, $8",
&rc,
CMFmtArgs9(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64,"
" Boolean, chars, String :: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64),
CMFmtReal(64.64),
CMFmtBoolean(1),
CMFmtChars("chars"),
CMFmtString(cmpiStr)));
PROV_LOG ("++++ Status of GetMessage with 9 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
strcpy(path,"path");
rc = CMOpenMessageFile(_broker, path, &msgFileHandle);
PROV_LOG ("++++ Status of CMOpenMessageFile (%s) ",
strCMPIStatus (rc));
type = CMGetMessage2(_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test zero arguments",
&rc,
0);
PROV_LOG ("++++ Status of GetMessage2 with 0 argument (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2(_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0",
&rc,
CMFmtArgs1(CMFmtChars("Single argument")));
PROV_LOG ("++++ Status of GetMessage2 with 1 argument (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2(_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0 $1",
&rc,
CMFmtArgs2(CMFmtChars("Sint32 ::"),CMFmtSint(1)));
PROV_LOG ("++++ Status of GetMessage2 with 2 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2 (_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0 $1, $2",
&rc,
CMFmtArgs3(CMFmtChars("Sint32, Uint32 :: "),
CMFmtSint(-1),
CMFmtUint(1)));
PROV_LOG ("++++ Status of GetMessage2 with 3 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2 (_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0 $1, $2, $3",
&rc,
CMFmtArgs4(CMFmtChars("Sint32, Uint32, Sint64 :: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64)));
PROV_LOG ("++++ Status of GetMessage2 with 4 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2 (_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0 $1, $2, $3, $4",
&rc,
CMFmtArgs5(CMFmtChars("Sint32, Uint32, Sint64, Uint64 :: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64)));
PROV_LOG ("++++ Status of GetMessage2 with 5 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2 (_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0 $1, $2, $3, $4, $5",
&rc,
CMFmtArgs6(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64 :: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64),
CMFmtReal(64.64)));
PROV_LOG ("++++ Status of GetMessage2 with 6 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2 (_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0 $1, $2, $3, $4, $5, $6",
&rc,
CMFmtArgs7(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64,"
" Boolean :: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64),
CMFmtReal(64.64),
CMFmtBoolean(1)));
PROV_LOG ("++++ Status of GetMessage2 with 7 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2 (_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0 $1, $2, $3, $4, $5, $6, $7",
&rc,
CMFmtArgs8(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64,"
" Boolean, chars :: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64),
CMFmtReal(64.64),
CMFmtBoolean(1),
CMFmtChars("chars")));
PROV_LOG ("++++ Status of GetMessage2 with 8 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2 (_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0 $1, $2, $3, $4, $5, $6, $7, $8",
&rc,
CMFmtArgs9(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64,"
" Boolean, chars, String :: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64),
CMFmtReal(64.64),
CMFmtBoolean(1),
CMFmtChars("chars"),
CMFmtString(cmpiStr)));
PROV_LOG ("++++ Status of GetMessage2 with 9 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
rc = CMCloseMessageFile(_broker, msgFileHandle);
PROV_LOG ("++++ Status of CMCloseMessageFile (%s) ",
strCMPIStatus (rc));
CMRelease(instance1);
CMRelease(instanceErr);
return flag ;
}
CMPIInstance *SoftwareIdentityCreateInstance(
const char *ns,
const char *name,
CMPIStatus *status)
{
CMPIInstance *ci;
char buf[256];
CMPIValue val;
_SMI_TRACE(1,("SoftwareIdentityCreateInstance() called"));
if (strcasecmp(name, SMIVolumeManagementName) == 0)
{
ci = CMNewInstance(
_BROKER,
CMNewObjectPath(_BROKER, ns, VolumeManagementSoftwareName, status),
status);
if ((status->rc != CMPI_RC_OK) || CMIsNullObject(ci))
{
_SMI_TRACE(1,("SoftwareIdentityCreateInstance(): CMNewInstance() failed - %s", CMGetCharPtr(status->msg)));
CMSetStatusWithChars(_BROKER, status, CMPI_RC_ERROR_SYSTEM, "Cannot create new instance");
goto exit;
}
CMSetProperty(ci, InstanceIDName,
cmpiutilMakeInstanceID(name, buf, 256), CMPI_chars);
CMSetProperty(ci, ElementName, VMProfileName, CMPI_chars);
CMSetProperty(ci, ParamName, VMProfileName, CMPI_chars);
CMSetProperty(ci, Caption, VMProfileName, CMPI_chars);
CMSetProperty(ci, Description, VMProfileName, CMPI_chars);
CMSetProperty(ci, VersionString, VersionStringValue, CMPI_chars);
CMSetProperty(ci, Manufacturer, ManufacturerName, CMPI_chars);
CMSetProperty(ci, Status, OK, CMPI_chars);
val.uint16 = 5;
CMSetProperty(ci, HealthState, &val, CMPI_uint16);
CMPIArray *arr = CMNewArray(_BROKER, 2, CMPI_uint16, NULL);
val.uint16 = 3;
CMSetArrayElementAt(arr, 0, &val, CMPI_uint16);
val.uint16 = 5;
CMSetArrayElementAt(arr, 1, &val, CMPI_uint16);
val.array = arr;
CMSetProperty(ci, Classifications, &val, CMPI_uint16A);
arr = CMNewArray(_BROKER, 1, CMPI_uint16, NULL);
val.uint16 = 2;
CMSetArrayElementAt(arr, 0, &val, CMPI_uint16);
val.array = arr;
CMSetProperty(ci, OperationalStatus, &val, CMPI_uint16A);
}
else if (strcasecmp(name, SMIArrayName) == 0)
{
ci = CMNewInstance(
_BROKER,
CMNewObjectPath(_BROKER, ns, ArraySoftwareName, status),
status);
if ((status->rc != CMPI_RC_OK) || CMIsNullObject(ci))
{
_SMI_TRACE(1,("SoftwareIdentityCreateInstance(): CMNewInstance() failed - %s", CMGetCharPtr(status->msg)));
CMSetStatusWithChars(_BROKER, status, CMPI_RC_ERROR_SYSTEM, "Cannot create new instance");
goto exit;
}
CMSetProperty(ci, InstanceIDName,
cmpiutilMakeInstanceID(name, buf, 256), CMPI_chars);
CMSetProperty(ci, ElementName, ArrayProfileName, CMPI_chars);
CMSetProperty(ci, ParamName, ArrayProfileName, CMPI_chars);
CMSetProperty(ci, Caption, ArrayProfileName, CMPI_chars);
CMSetProperty(ci, Description, ArrayProfileName, CMPI_chars);
CMSetProperty(ci, VersionString, VersionStringValue, CMPI_chars);
CMSetProperty(ci, Manufacturer, ManufacturerName, CMPI_chars);
CMSetProperty(ci, Status, OK, CMPI_chars);
val.uint16 = 5;
CMSetProperty(ci, HealthState, &val, CMPI_uint16);
CMPIArray *arr = CMNewArray(_BROKER, 2, CMPI_uint16, NULL);
val.uint16 = 3;
CMSetArrayElementAt(arr, 0, &val, CMPI_uint16);
val.uint16 = 5;
CMSetArrayElementAt(arr, 1, &val, CMPI_uint16);
val.array = arr;
CMSetProperty(ci, Classifications, &val, CMPI_uint16A);
arr = CMNewArray(_BROKER, 1, CMPI_uint16, NULL);
val.uint16 = 2;
CMSetArrayElementAt(arr, 0, &val, CMPI_uint16);
val.array = arr;
CMSetProperty(ci, OperationalStatus, &val, CMPI_uint16A);
}
exit:
_SMI_TRACE(1,("SoftwareIdentityCreateInstance() done"));
return ci;
}
