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; }