int makeFileBuf(const CMPIInstance *instance, CWS_FILE *cwsf)
{
CMPIData dt;
CMPIStatus rc = {CMPI_RC_OK,NULL};
if (instance && cwsf) {
dt=CMGetProperty(instance,"Name",&rc);
if (rc.rc == CMPI_RC_OK)
{
// Name needs be valid before copied using strcpy
if (CMPI_goodValue == dt.state)
{
strcpy(cwsf->cws_name,CMGetCharsPtr(dt.value.string,NULL));
}
}
dt=CMGetProperty(instance,"FileSize",&rc);
if (rc.rc == CMPI_RC_OK)
{
cwsf->cws_size=dt.value.uint64;
}
#ifndef SIMULATED
dt=CMGetProperty(instance,"CreationDate",&rc);
if (rc.rc == CMPI_RC_OK)
{
cwsf->cws_ctime=CMGetBinaryFormat(dt.value.dateTime,NULL);
}
dt=CMGetProperty(instance,"LastModified",&rc);
if (rc.rc == CMPI_RC_OK)
{
cwsf->cws_mtime=CMGetBinaryFormat(dt.value.dateTime,NULL);
}
dt=CMGetProperty(instance,"LastAccessed",&rc);
if (rc.rc == CMPI_RC_OK)
{
cwsf->cws_atime=CMGetBinaryFormat(dt.value.dateTime,NULL);
}
#endif
dt=CMGetProperty(instance,"Readable",&rc);
if (rc.rc == CMPI_RC_OK)
{
cwsf->cws_mode=dt.value.boolean ? 0400 : 0;
}
dt=CMGetProperty(instance,"Writeable",&rc);
if (rc.rc == CMPI_RC_OK)
{
cwsf->cws_mode+=(dt.value.boolean ? 0200 : 0);
}
dt=CMGetProperty(instance,"Executable",&rc);
if (rc.rc == CMPI_RC_OK)
{
cwsf->cws_mode+=(dt.value.boolean ? 0100 : 0);
}
return 1;
}
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;
}
static int
_testCMPIDateTime()
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIBoolean isInterval = 0;
CMPIBoolean interval = 0;
CMPIBoolean cloneSuccessful = 0;
CMPIBoolean binaryDateTimeEqual = 0;
CMPIDateTime *dateTime = NULL;
CMPIDateTime *new_dateTime = NULL;
CMPIDateTime *clonedDateTime = NULL;
CMPIDateTime *dateTimeFromBinary = NULL;
CMPIUint64 dateTimeInBinary = UINT64_LITERAL(1150892800000000);
CMPIUint64 returnedDateTimeInBinary = 0;
CMPIString *stringDate = NULL;
CMPIString *clonedStringDate = NULL;
const char *normalString = NULL;
const char *clonedString = NULL;
void *dtptr;
dateTime = CMNewDateTime(_broker, &rc);
if (dateTime == NULL) {
return 1;
}
dateTimeFromBinary =
CMNewDateTimeFromBinary(_broker, dateTimeInBinary, interval, &rc);
returnedDateTimeInBinary = CMGetBinaryFormat(dateTimeFromBinary, &rc);
if (dateTimeInBinary == returnedDateTimeInBinary) {
binaryDateTimeEqual = 1;
}
isInterval = CMIsInterval(dateTime, &rc);
interval = 1;
new_dateTime =
CMNewDateTimeFromBinary(_broker, dateTimeInBinary, interval, &rc);
isInterval = CMIsInterval(new_dateTime, &rc);
clonedDateTime = dateTime->ft->clone(dateTime, &rc);
stringDate = CMGetStringFormat(dateTime, &rc);
clonedStringDate = CMGetStringFormat(clonedDateTime, &rc);
rc = clonedDateTime->ft->release(clonedDateTime);
normalString = CMGetCharsPtr(stringDate, &rc);
clonedString = CMGetCharsPtr(clonedStringDate, &rc);
if (strcmp(normalString, clonedString) == 0) {
cloneSuccessful = 1;
}
dtptr = dateTime->hdl;
dateTime->hdl = NULL;
CMGetBinaryFormat(dateTime, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
dateTime->ft->clone(dateTime, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
CMGetStringFormat(dateTime, &rc);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
rc = dateTime->ft->release(dateTime);
if (rc.rc != CMPI_RC_ERR_INVALID_HANDLE) {
return 1;
}
dateTime->hdl = dtptr;
rc = dateTime->ft->release(dateTime);
return 0;
}
static CMPIBoolean _match_key(const CMPIData* cd1, const CMPIData* cd2)
{
if (cd1->type != cd2->type)
{
return 0;
}
if (cd1->state & CMPI_nullValue)
{
return cd2->state & CMPI_nullValue ? 1 : 0;
}
if (cd2->state & CMPI_nullValue)
{
return cd1->state & CMPI_nullValue ? 1 : 0;
}
switch (cd1->type)
{
case CMPI_boolean:
return cd1->value.boolean == cd2->value.boolean;
case CMPI_uint8:
return cd1->value.uint8 == cd2->value.uint8;
case CMPI_sint8:
return cd1->value.sint8 == cd2->value.sint8;
case CMPI_uint16:
return cd1->value.uint16 == cd2->value.uint16;
case CMPI_sint16:
return cd1->value.sint16 == cd2->value.sint16;
case CMPI_uint32:
return cd1->value.uint32 == cd2->value.uint32;
case CMPI_sint32:
return cd1->value.sint32 == cd2->value.sint32;
case CMPI_uint64:
return cd1->value.uint64 == cd2->value.uint64;
case CMPI_sint64:
return cd1->value.sint64 == cd2->value.sint64;
case CMPI_real32:
return cd1->value.real32 == cd2->value.real32;
case CMPI_real64:
return cd1->value.real64 == cd2->value.real64;
case CMPI_char16:
return cd1->value.char16 == cd2->value.char16;
case CMPI_string:
{
const char* s1 = KChars(cd1->value.string);
const char* s2 = KChars(cd2->value.string);
return s1 && s2 && strcmp(s1, s2) == 0;
}
case CMPI_dateTime:
{
CMPIUint64 x1 = CMGetBinaryFormat(cd1->value.dateTime, NULL);
CMPIUint64 x2 = CMGetBinaryFormat(cd2->value.dateTime, NULL);
return x1 == x2;
}
case CMPI_ref:
return KMatch(cd1->value.ref, cd2->value.ref);
default:
return 0;
}
return 1;
}
