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;
}
kaa_error_t kaa_meta_data_request_serialize(kaa_platform_protocol_t *self,
kaa_platform_message_writer_t *writer, uint32_t request_id)
{
// TODO(KAA-982): Use assert here
if (!self || !self->status || !writer) {
return KAA_ERR_BADPARAM;
}
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Going to serialize client meta sync");
uint16_t options = TIMEOUT_VALUE | PUBLIC_KEY_HASH_VALUE | PROFILE_HASH_VALUE | APP_TOKEN_VALUE;
const size_t payload_length = kaa_meta_data_request_size - KAA_EXTENSION_HEADER_SIZE;
kaa_error_t err_code = kaa_platform_message_write_extension_header(writer,
KAA_EXTENSION_META_DATA, options, payload_length);
if (err_code) {
return err_code;
}
uint32_t request_id_network = KAA_HTONL(request_id);
err_code = kaa_platform_message_write(writer, &request_id_network, sizeof(uint32_t));
if (err_code) {
return err_code;
}
uint32_t timeout = KAA_HTONL(KAA_SYNC_TIMEOUT);
err_code = kaa_platform_message_write(writer, &timeout, sizeof(timeout));
if (err_code) {
return err_code;
}
err_code = kaa_platform_message_write_aligned(writer,
self->status->endpoint_public_key_hash, SHA_1_DIGEST_LENGTH);
if (err_code) {
return err_code;
}
err_code = kaa_platform_message_write_aligned(writer,
self->status->profile_hash, SHA_1_DIGEST_LENGTH);
if (err_code) {
return err_code;
}
err_code = kaa_platform_message_write_aligned(writer, KAA_SDK_TOKEN, KAA_SDK_TOKEN_LENGTH);
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE,
"Meta sync: payload length '%u', request id '%u'", payload_length, request_id);
return err_code;
}
void test_write(void)
{
kaa_error_t error_code = KAA_ERR_NONE;
char buffer[16];
size_t buffer_size = sizeof(buffer) / sizeof(char);
kaa_platform_message_writer_t *writer = NULL;
error_code = kaa_platform_message_writer_create(&writer, buffer, buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
const char *test_data = "test data";
size_t test_data_len = strlen(test_data);
error_code = kaa_platform_message_write(writer, test_data, test_data_len);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL((writer->current - writer->begin), test_data_len);
error_code = (memcmp(writer->begin, test_data, test_data_len) == 0 ? KAA_ERR_NONE : KAA_ERR_WRITE_FAILED);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_platform_message_writer_destroy(writer);
}
kaa_error_t kaa_profile_request_serialize(kaa_profile_manager_t *self, kaa_platform_message_writer_t *writer)
{
KAA_RETURN_IF_NIL2(self, writer, KAA_ERR_BADPARAM);
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Going to compile profile client sync");
kaa_error_t error_code = kaa_platform_message_write_extension_header(writer
, KAA_EXTENSION_PROFILE
, 0
, self->extension_data->payload_size);
KAA_RETURN_IF_ERR(error_code);
uint32_t network_order_32 = KAA_HTONL(0);
#if KAA_PROFILE_SCHEMA_VERSION > 0
if (resync_is_required(self)) {
network_order_32 = KAA_HTONL(self->profile_body.size);
error_code = kaa_platform_message_write(writer, &network_order_32, sizeof(uint32_t));
KAA_RETURN_IF_ERR(error_code);
if (self->profile_body.size) {
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Writing profile body (size %u)...", self->profile_body.size);
error_code = kaa_platform_message_write_aligned(writer, self->profile_body.buffer, self->profile_body.size);
if (error_code) {
KAA_LOG_ERROR(self->logger, error_code, "Failed to write profile body");
return error_code;
}
}
} else {
error_code = kaa_platform_message_write(writer, &network_order_32, sizeof(uint32_t));
KAA_RETURN_IF_ERR(error_code);
}
#else
error_code = kaa_platform_message_write(writer, &network_order_32, sizeof(uint32_t));
KAA_RETURN_IF_ERR(error_code);
#endif
uint16_t network_order_16 = 0;
uint16_t field_number_with_reserved = 0;
if (!self->status->is_registered) {
field_number_with_reserved = KAA_HTONS(PUB_KEY_VALUE << 8);
error_code = kaa_platform_message_write(writer
, &field_number_with_reserved
, sizeof(uint16_t));
KAA_RETURN_IF_ERR(error_code);
network_order_16 = KAA_HTONS(self->extension_data->public_key.size);
error_code = kaa_platform_message_write(writer, &network_order_16, sizeof(uint16_t));
KAA_RETURN_IF_ERR(error_code);
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Writing public key (size %u)...", self->extension_data->public_key.size);
error_code = kaa_platform_message_write_aligned(writer
, (char*)self->extension_data->public_key.buffer
, self->extension_data->public_key.size);
if (error_code) {
KAA_LOG_ERROR(self->logger, error_code, "Failed to write public key");
return error_code;
}
}
if (self->extension_data->access_token.buffer) {
field_number_with_reserved = KAA_HTONS(ACCESS_TOKEN_VALUE << 8);
error_code = kaa_platform_message_write(writer
, &field_number_with_reserved
, sizeof(uint16_t));
KAA_RETURN_IF_ERR(error_code);
network_order_16 = KAA_HTONS(self->extension_data->access_token.size);
error_code = kaa_platform_message_write(writer, &network_order_16, sizeof(uint16_t));
KAA_RETURN_IF_ERR(error_code);
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Writing access token (size %u)...", self->extension_data->access_token.size);
error_code = kaa_platform_message_write_aligned(writer
, (char*)self->extension_data->access_token.buffer
, self->extension_data->access_token.size);
if (error_code) {
KAA_LOG_ERROR(self->logger, error_code, "Failed to write access token");
return error_code;
}
}
return error_code;
}
void test_profile_sync_serialize(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code;
kaa_platform_message_writer_t *manual_writer;
kaa_platform_message_writer_t *auto_writer;
const char *access_token = "access token";
const size_t access_token_size = strlen(access_token);
kaa_profile_t *profile = kaa_profile_basic_endpoint_profile_test_create();
profile->profile_body = kaa_string_copy_create("dummy");
size_t serialized_profile_size = profile->get_size(profile);
char *serialized_profile = (char *) KAA_MALLOC(serialized_profile_size * sizeof(char));
avro_writer_t avro_writer = avro_writer_memory(serialized_profile, serialized_profile_size);
profile->serialize(avro_writer, profile);
error_code = kaa_profile_manager_update_profile(profile_manager, profile);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
status->is_registered = false;
error_code = kaa_profile_manager_set_endpoint_access_token(profile_manager, access_token);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
size_t profile_sync_size;
error_code = kaa_profile_request_get_size(profile_manager, &profile_sync_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
char buffer[profile_sync_size];
error_code = kaa_platform_message_writer_create(&manual_writer, buffer, profile_sync_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
uint32_t network_order_32;
error_code = kaa_platform_message_write_extension_header(manual_writer
, KAA_PROFILE_EXTENSION_TYPE
, 0
, profile_sync_size - KAA_EXTENSION_HEADER_SIZE);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
bool need_resync = true;
ASSERT_EQUAL(kaa_profile_need_profile_resync(profile_manager, &need_resync), KAA_ERR_NONE);
network_order_32 = KAA_HTONL(0);
if (need_resync)
network_order_32 = KAA_HTONL(serialized_profile_size);
error_code = kaa_platform_message_write(manual_writer, &network_order_32, sizeof(uint32_t));
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
if (need_resync) {
error_code = kaa_platform_message_write_aligned(manual_writer, serialized_profile, serialized_profile_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
}
network_order_32 = KAA_HTONS(TEST_PUB_KEY_SIZE) << 16 | PUB_KEY_VALUE;
error_code = kaa_platform_message_write(manual_writer, &network_order_32, sizeof(uint32_t));
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_platform_message_write_aligned(manual_writer, test_ep_key, TEST_PUB_KEY_SIZE);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
network_order_32 = KAA_HTONS(access_token_size) << 16 | ACCESS_TOKEN_VALUE;
error_code = kaa_platform_message_write(manual_writer, &network_order_32, sizeof(uint32_t));
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_platform_message_write_aligned(manual_writer, access_token, access_token_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
char buffer2[profile_sync_size];
error_code = kaa_platform_message_writer_create(&auto_writer, buffer2, profile_sync_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_profile_request_serialize(profile_manager, auto_writer);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = (memcmp(buffer, buffer2, profile_sync_size) == 0 ? KAA_ERR_NONE : KAA_ERR_BADDATA);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
KAA_FREE(serialized_profile);
avro_writer_free(avro_writer);
profile->destroy(profile);
kaa_platform_message_writer_destroy(auto_writer);
kaa_platform_message_writer_destroy(manual_writer);
KAA_TRACE_OUT(logger);
}
