kaa_error_t kaa_meta_data_request_serialize(kaa_status_t *status, kaa_platform_message_writer_t* writer, uint32_t request_id)
{
KAA_RETURN_IF_NIL2(status, writer, KAA_ERR_BADPARAM);
uint32_t options = TIMEOUT_VALUE | PUBLIC_KEY_HASH_VALUE | PROFILE_HASH_VALUE | APP_TOKEN_VALUE;
size_t payload_length = 0;
kaa_error_t err_code = kaa_meta_data_request_get_size(&payload_length);
KAA_RETURN_IF_ERR(err_code);
payload_length -= KAA_EXTENSION_HEADER_SIZE;
err_code = kaa_platform_message_write_extension_header(writer
, KAA_META_DATA_EXTENSION_TYPE
, options
, payload_length);
KAA_RETURN_IF_ERR(err_code);
uint32_t request_id_network = KAA_HTONL(request_id);
err_code = kaa_platform_message_write(writer, &request_id_network, sizeof(uint32_t));
KAA_RETURN_IF_ERR(err_code);
uint32_t timeout = KAA_HTONL(KAA_SYNC_TIMEOUT);
err_code = kaa_platform_message_write(writer, &timeout, sizeof(timeout));
KAA_RETURN_IF_ERR(err_code);
err_code = kaa_platform_message_write_aligned(writer, status->endpoint_public_key_hash, SHA_1_DIGEST_LENGTH);
KAA_RETURN_IF_ERR(err_code);
err_code = kaa_platform_message_write_aligned(writer, status->profile_hash, SHA_1_DIGEST_LENGTH);
KAA_RETURN_IF_ERR(err_code);
err_code = kaa_platform_message_write_aligned(writer, KAA_SDK_TOKEN, KAA_SDK_TOKEN_LENGTH);
return err_code;
}
void test_meta_extension_get_size_failed(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code = kaa_meta_data_request_get_size(NULL);
ASSERT_NOT_EQUAL(error_code, KAA_ERR_NONE);
}
void test_meta_extension_get_size(void)
{
KAA_TRACE_IN(logger);
const size_t expected_meta_extension_size = KAA_EXTENSION_HEADER_SIZE
+ sizeof(uint32_t) /* request id */
+ sizeof(uint32_t) /* timeout */
+ SHA_1_DIGEST_LENGTH
+ SHA_1_DIGEST_LENGTH
+ KAA_SDK_TOKEN_LENGTH;
size_t meta_extension_size;
kaa_error_t error_code = kaa_meta_data_request_get_size(&meta_extension_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(expected_meta_extension_size, meta_extension_size);
}
static kaa_error_t kaa_client_sync_get_size(kaa_platform_protocol_t *self
, const kaa_service_t services[]
, size_t services_count
, size_t *expected_size)
{
KAA_RETURN_IF_NIL4(self, services, services_count, expected_size, KAA_ERR_BADPARAM)
*expected_size = KAA_PROTOCOL_MESSAGE_HEADER_SIZE;
size_t extension_size = 0;
kaa_error_t err_code = kaa_meta_data_request_get_size(&extension_size);
if (err_code) {
KAA_LOG_ERROR(self->logger, err_code, "Failed to query size for meta extension");
return err_code;
}
*expected_size += extension_size;
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated meta extension size %u", extension_size);
while (!err_code && services_count--) {
switch (services[services_count]) {
case KAA_SERVICE_BOOTSTRAP: {
err_code = kaa_channel_manager_bootstrap_request_get_size(self->kaa_context->channel_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated bootstrap extension size %u", extension_size);
break;
}
case KAA_SERVICE_PROFILE: {
bool need_resync = false;
err_code = kaa_profile_need_profile_resync(self->kaa_context->profile_manager
, &need_resync);
if (err_code) {
KAA_LOG_ERROR(self->logger, err_code, "Failed to read 'need_resync' flag");
}
if (!err_code && need_resync) {
err_code = kaa_profile_request_get_size(self->kaa_context->profile_manager
, &extension_size);
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated profile extension size %u", extension_size);
}
break;
}
case KAA_SERVICE_USER: {
err_code = kaa_user_request_get_size(self->kaa_context->user_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated user extension size %u", extension_size);
break;
}
#ifndef KAA_DISABLE_FEATURE_EVENTS
case KAA_SERVICE_EVENT: {
err_code = kaa_event_request_get_size(self->kaa_context->event_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated event extension size %u", extension_size);
break;
}
#endif
#ifndef KAA_DISABLE_FEATURE_LOGGING
case KAA_SERVICE_LOGGING: {
err_code = kaa_logging_request_get_size(self->kaa_context->log_collector
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated logging extension size %u", extension_size);
break;
}
#endif
#ifndef KAA_DISABLE_FEATURE_CONFIGURATION
case KAA_SERVICE_CONFIGURATION: {
err_code = kaa_configuration_manager_get_size(self->kaa_context->configuration_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated configuration extension size %u", extension_size);
break;
}
#endif
#ifndef KAA_DISABLE_FEATURE_NOTIFICATION
case KAA_SERVICE_NOTIFICATION: {
err_code = kaa_notification_manager_get_size(self->kaa_context->notification_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated notification extension size %u", extension_size);
break;
}
#endif
default:
extension_size = 0;
break;
}
*expected_size += extension_size;
}
if (err_code) {
KAA_LOG_ERROR(self->logger, err_code, "Failed to query extension size in %u service"
, services[services_count]);
}
return err_code;
}
void test_meta_extension_serialize(void)
{
KAA_TRACE_IN(logger);
size_t meta_extension_size;
kaa_error_t error_code = kaa_meta_data_request_get_size(&meta_extension_size);
char buffer[meta_extension_size];
kaa_platform_message_writer_t *writer;
error_code = kaa_platform_message_writer_create(&writer, buffer, meta_extension_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
uint32_t expected_timeout = KAA_SYNC_TIMEOUT;
kaa_digest expected_public_key_hash = {0x74, 0xc7, 0x51, 0x43, 0x00, 0xf7, 0xb8, 0x21, 0x2c, 0xc3, 0x6b, 0xa5, 0x9c, 0xb4, 0x03, 0xef, 0xc2, 0x5c, 0x65, 0x6c};
kaa_digest expected_profile_hash = {0xfa, 0x71, 0xb5, 0x02, 0xe7, 0xdf, 0x96, 0x86, 0x6c, 0xdc, 0xe1, 0x4a, 0x17, 0x35, 0x7f, 0xd9, 0xa8, 0xfb, 0x71, 0x09};
error_code = ext_copy_sha_hash(status->endpoint_public_key_hash, expected_public_key_hash);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_copy_sha_hash(status->profile_hash, expected_profile_hash);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_context_t *context = NULL;
kaa_init(&context);
kaa_platform_protocol_t *protocol = NULL;
kaa_platform_protocol_create(&protocol, context, status);
error_code = kaa_meta_data_request_serialize(protocol, writer, 1);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_deinit(context);
kaa_platform_message_reader_t *reader;
error_code = kaa_platform_message_reader_create(&reader, buffer, meta_extension_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
uint8_t extension_type;
uint32_t extension_options;
uint32_t extension_payload;
error_code = kaa_platform_message_read_extension_header(
reader, &extension_type, &extension_options, &extension_payload);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(extension_type, KAA_META_DATA_EXTENSION_TYPE);
ASSERT_EQUAL(extension_options, (TIMEOUT_VALUE | PUBLIC_KEY_HASH_VALUE | PROFILE_HASH_VALUE | APP_TOKEN_VALUE));
ASSERT_EQUAL(extension_payload, meta_extension_size - KAA_EXTENSION_HEADER_SIZE);
uint32_t request_id;
uint32_t timeout;
kaa_digest public_key_hash;
kaa_digest profile_hash;
char sdk_token[KAA_SDK_TOKEN_LENGTH];
error_code = kaa_platform_message_read(reader, &request_id, sizeof(uint32_t));
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(KAA_NTOHL(request_id), 1);
error_code = kaa_platform_message_read(reader, &timeout, sizeof(uint32_t));
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
timeout = KAA_NTOHL(timeout);
ASSERT_EQUAL(expected_timeout, timeout);
error_code = kaa_platform_message_read_aligned(reader, public_key_hash, SHA_1_DIGEST_LENGTH);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = (memcmp(public_key_hash, expected_public_key_hash, SHA_1_DIGEST_LENGTH) == 0 ? KAA_ERR_NONE : KAA_ERR_READ_FAILED);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_platform_message_read_aligned(reader, profile_hash, SHA_1_DIGEST_LENGTH);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = (memcmp(profile_hash, expected_profile_hash, SHA_1_DIGEST_LENGTH) == 0 ? KAA_ERR_NONE : KAA_ERR_READ_FAILED);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_platform_message_read_aligned(reader, sdk_token, KAA_SDK_TOKEN_LENGTH);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = (memcmp(sdk_token, KAA_SDK_TOKEN, KAA_SDK_TOKEN_LENGTH) == 0 ? KAA_ERR_NONE : KAA_ERR_READ_FAILED);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_platform_message_reader_destroy(reader);
kaa_platform_message_writer_destroy(writer);
}
