void test_profile_update(void **state)
{
(void)state;
char* pattern = "a94a8fe5ccb19ba61c4c0873d391e987982fbbd3";
kaa_error_t err;
char* body = "test";
kaa_digest calculated_hash;
err = ext_calculate_sha_hash(NULL, 50, calculated_hash);
ASSERT_NOT_EQUAL(err, KAA_ERR_NONE);
err = ext_calculate_sha_hash(body, 0, calculated_hash);
ASSERT_EQUAL(err, KAA_ERR_NONE);
err = ext_calculate_sha_hash(body, 4, NULL);
ASSERT_NOT_EQUAL(err, KAA_ERR_NONE);
err = ext_calculate_sha_hash(body, 4, calculated_hash);
ASSERT_EQUAL(err, KAA_ERR_NONE);
char buf[SHA_1_DIGEST_LENGTH * 2 + 1];
for (int i = 0; i < SHA_1_DIGEST_LENGTH; ++i) {
sprintf(&buf[i * 2], "%02x", calculated_hash[i]);
}
ASSERT_EQUAL(0, memcmp(buf, pattern, SHA_1_DIGEST_LENGTH * 2));
}
/** @deprecated Use kaa_extension_profile_init(). */
kaa_error_t kaa_profile_manager_create(kaa_profile_manager_t **profile_manager_p, kaa_status_t *status
, kaa_channel_manager_t *channel_manager, kaa_logger_t *logger)
{
if (!profile_manager_p || !channel_manager || !status) {
return KAA_ERR_BADPARAM;
}
kaa_profile_manager_t *profile_manager = KAA_MALLOC(sizeof(kaa_profile_manager_t));
if (!profile_manager) {
return KAA_ERR_NOMEM;
}
/**
* KAA_CALLOC is really needed.
*/
profile_manager->extension_data = KAA_CALLOC(1, sizeof(kaa_profile_extension_data_t));
if (!profile_manager->extension_data) {
KAA_FREE(profile_manager);
return KAA_ERR_NOMEM;
}
profile_manager->need_resync = true;
profile_manager->profile_body.size = 0;
profile_manager->profile_body.buffer = NULL;
profile_manager->channel_manager = channel_manager;
profile_manager->status = status;
profile_manager->logger = logger;
ext_calculate_sha_hash(NULL, 0, profile_manager->profile_hash);
ext_copy_sha_hash(profile_manager->status->profile_hash, profile_manager->profile_hash);
*profile_manager_p = profile_manager;
return KAA_ERR_NONE;
}
kaa_error_t kaa_init_security_stuff(void)
{
sndc_file_ref_t key_file = sndc_file_open(KAA_KEY_STORAGE, DE_FRDONLY);
if (key_file) {
sndc_file_seek(key_file, 0, SEEK_END);
kaa_public_key_length = sndc_file_tell(key_file);
kaa_public_key = (char*)sndc_mem_calloc(kaa_public_key_length, sizeof(char));
if (kaa_public_key == NULL) {
sndc_printf("Failed to allocate %u bytes for public key\n", kaa_public_key_length);
return KAA_ERR_NOMEM;
}
sndc_file_seek(key_file, 0, SEEK_SET);
if (sndc_file_read(key_file, kaa_public_key, kaa_public_key_length) == 0) {
sndc_mem_free(kaa_public_key);
sndc_printf("Failed to read public key (size %u)\n", kaa_public_key_length);
return KAA_ERR_INVALID_PUB_KEY;
}
sndc_file_close(key_file);
sndc_printf("Restored public key (size %u)\n", kaa_public_key_length);
} else {
sndc_printf("No RSA key file %s found\n", KAA_KEY_STORAGE);
}
ext_calculate_sha_hash(kaa_public_key, kaa_public_key_length, kaa_public_key_hash);
sndc_printf("SHA calculated\n");
return KAA_ERR_NONE;
}
kaa_error_t kaa_init_security_stuff(const char *kaa_public_key, const size_t kaa_public_key_length)
{
KAA_RETURN_IF_NIL2(kaa_public_key, kaa_public_key_length, KAA_ERR_BADPARAM);
ext_calculate_sha_hash(kaa_public_key, kaa_public_key_length, kaa_public_key_hash);
debug("SHA calculated\r\n");
return KAA_ERR_NONE;
}
void test_create_request(void)
{
KAA_TRACE_IN(logger);
size_t expected_size = 0;
ASSERT_EQUAL(kaa_configuration_manager_get_size(config_manager, &expected_size), KAA_ERR_NONE);
ASSERT_EQUAL(expected_size, sizeof(uint32_t) + KAA_EXTENSION_HEADER_SIZE + SHA_1_DIGEST_LENGTH);
char request_buffer[expected_size];
kaa_platform_message_writer_t *writer = NULL;
ASSERT_EQUAL(kaa_platform_message_writer_create(&writer, request_buffer, expected_size), KAA_ERR_NONE);
ASSERT_EQUAL(kaa_configuration_manager_request_serialize(config_manager, writer), KAA_ERR_NONE);
char *cursor = writer->begin;
ASSERT_EQUAL(*cursor, KAA_CONFIGURATION_EXTENSION_TYPE);
cursor += sizeof(uint32_t);
ASSERT_EQUAL(KAA_NTOHL(*((uint32_t *) cursor)), sizeof(uint32_t) + SHA_1_DIGEST_LENGTH); // checking payload size
cursor += sizeof(uint32_t);
ASSERT_EQUAL(KAA_NTOHL(*((uint32_t *) cursor)), CONFIG_START_SEQ_N); // checking sequence number
cursor += sizeof(uint32_t);
kaa_digest check_hash;
ext_calculate_sha_hash(KAA_CONFIGURATION_DATA, KAA_CONFIGURATION_DATA_LENGTH, check_hash); // checking configuration hash
ASSERT_EQUAL(memcmp(cursor, check_hash, SHA_1_DIGEST_LENGTH), 0);
cursor += SHA_1_DIGEST_LENGTH;
ASSERT_EQUAL(cursor, writer->end);
kaa_platform_message_writer_destroy(writer);
}
void test_create_request(void **state)
{
(void)state;
size_t expected_size = 0;
ASSERT_EQUAL(kaa_configuration_manager_get_size(config_manager, &expected_size), KAA_ERR_NONE);
ASSERT_EQUAL(expected_size, KAA_EXTENSION_HEADER_SIZE + SHA_1_DIGEST_LENGTH);
uint8_t request_buffer[expected_size];
kaa_platform_message_writer_t *writer = NULL;
ASSERT_EQUAL(kaa_platform_message_writer_create(&writer, request_buffer, expected_size), KAA_ERR_NONE);
ASSERT_EQUAL(kaa_configuration_manager_request_serialize(config_manager, writer), KAA_ERR_NONE);
uint8_t *cursor = writer->begin;
ASSERT_EQUAL(KAA_HTONS(*((uint16_t *) cursor)), KAA_EXTENSION_CONFIGURATION);
cursor += sizeof(uint32_t);
ASSERT_EQUAL(KAA_NTOHL(*((uint32_t *) cursor)), SHA_1_DIGEST_LENGTH); // checking payload size
cursor += sizeof(uint32_t);
kaa_digest check_hash;
ext_calculate_sha_hash(KAA_CONFIGURATION_DATA, KAA_CONFIGURATION_DATA_LENGTH, check_hash); // checking configuration hash
ASSERT_EQUAL(memcmp(cursor, check_hash, SHA_1_DIGEST_LENGTH), 0);
cursor += SHA_1_DIGEST_LENGTH;
ASSERT_EQUAL(cursor, writer->end);
kaa_platform_message_writer_destroy(writer);
}
kaa_error_t kaa_profile_manager_update_profile(kaa_profile_manager_t *self, kaa_profile_t *profile_body)
{
#if KAA_PROFILE_SCHEMA_VERSION > 0
KAA_RETURN_IF_NIL2(self, profile_body, KAA_ERR_BADPARAM);
size_t serialized_profile_size = profile_body->get_size(profile_body);
if (!serialized_profile_size) {
KAA_LOG_ERROR(self->logger, KAA_ERR_BADDATA,
"Failed to update profile: serialize profile size is null. Maybe profile schema is empty");
return KAA_ERR_BADDATA;
}
char *serialized_profile = (char *) KAA_MALLOC(serialized_profile_size * sizeof(char));
KAA_RETURN_IF_NIL(serialized_profile, KAA_ERR_NOMEM);
avro_writer_t writer = avro_writer_memory(serialized_profile, serialized_profile_size);
if (!writer) {
KAA_FREE(serialized_profile);
return KAA_ERR_NOMEM;
}
profile_body->serialize(writer, profile_body);
avro_writer_free(writer);
kaa_digest new_hash;
ext_calculate_sha_hash(serialized_profile, serialized_profile_size, new_hash);
if (!memcmp(new_hash, self->status->profile_hash, SHA_1_DIGEST_LENGTH)) {
self->need_resync = false;
KAA_FREE(serialized_profile);
return KAA_ERR_NONE;
}
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Endpoint profile is updated");
if (ext_copy_sha_hash(self->status->profile_hash, new_hash)) {
KAA_FREE(serialized_profile);
return KAA_ERR_BAD_STATE;
}
if (self->profile_body.size > 0) {
KAA_FREE(self->profile_body.buffer);
self->profile_body.buffer = NULL;
}
self->profile_body.buffer = (uint8_t*)serialized_profile;
self->profile_body.size = serialized_profile_size;
self->need_resync = true;
kaa_transport_channel_interface_t *channel =
kaa_channel_manager_get_transport_channel(self->channel_manager, profile_sync_services[0]);
if (channel)
channel->sync_handler(channel->context, profile_sync_services, 1);
#endif
return KAA_ERR_NONE;
}
kaa_error_t kaa_init(kaa_context_t **kaa_context_p)
{
KAA_RETURN_IF_NIL(kaa_context_p, KAA_ERR_BADPARAM);
// Initialize logger
kaa_logger_t *logger = NULL;
FILE *logfile = fopen("run.log", "w");
kaa_error_t error = kaa_log_create(&logger, KAA_MAX_LOG_MESSAGE_LENGTH, KAA_MAX_LOG_LEVEL, logfile); // TODO: make log destination configurable
if (error)
return error;
KAA_LOG_INFO(logger, KAA_ERR_NONE, "Kaa SDK version %s, commit hash %s", BUILD_VERSION, BUILD_COMMIT_HASH);
// Initialize general Kaa context
error = kaa_context_create(kaa_context_p, logger);
if (error) {
KAA_LOG_FATAL(logger, error, "Failed to create Kaa context");
kaa_log_destroy(logger);
*kaa_context_p = NULL;
return error;
}
// Initialize endpoint identity
char *pub_key_buffer = NULL;
size_t pub_key_buffer_size = 0;
bool need_deallocation = false;
ext_get_endpoint_public_key(&pub_key_buffer, &pub_key_buffer_size, &need_deallocation);
kaa_digest pub_key_hash;
error = ext_calculate_sha_hash(pub_key_buffer, pub_key_buffer_size, pub_key_hash);
if (need_deallocation && pub_key_buffer_size > 0) {
KAA_FREE(pub_key_buffer);
}
if (error) {
KAA_LOG_FATAL(logger, error, "Failed to calculate EP ID");
kaa_context_destroy(*kaa_context_p);
*kaa_context_p = NULL;
kaa_log_destroy(logger);
return error;
}
error = ext_copy_sha_hash((*kaa_context_p)->status->status_instance->endpoint_public_key_hash, pub_key_hash);
if (error) {
KAA_LOG_FATAL(logger, error, "Failed to set Endpoint public key");
kaa_context_destroy(*kaa_context_p);
*kaa_context_p = NULL;
kaa_log_destroy(logger);
return error;
}
return KAA_ERR_NONE;
}
kaa_error_t kaa_configuration_manager_handle_server_sync(kaa_configuration_manager_t *self
, kaa_platform_message_reader_t *reader
, uint32_t extension_options
, size_t extension_length)
{
KAA_RETURN_IF_NIL2(self, reader, KAA_ERR_BADPARAM);
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Received configuration server sync: options %u, payload size %u", extension_options, extension_length);
if (extension_length >= sizeof(uint32_t)) {
self->status->config_seq_n = KAA_NTOHL(*((uint32_t *) reader->current));
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Configuration state sequence number is '%d'", self->status->config_seq_n);
reader->current += sizeof(uint32_t);
if (extension_options & KAA_CONFIGURATION_BODY_PRESENT) {
uint32_t body_size = KAA_NTOHL(*((uint32_t *) reader->current));
reader->current += sizeof(uint32_t);
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Received configuration body, size '%u' ", body_size);
const char* body = reader->current;
kaa_error_t error = kaa_platform_message_skip(reader, kaa_aligned_size_get(body_size));
if (error) {
KAA_LOG_ERROR(self->logger, error, "Failed to read configuration body, size %u", body_size);
return error;
}
#if KAA_CONFIGURATION_DELTA_SUPPORT
#else
if (self->root_record)
self->root_record->destroy(self->root_record);
self->root_record = kaa_configuration_manager_deserialize(body, body_size);
if (!self->root_record) {
KAA_LOG_ERROR(self->logger, KAA_ERR_READ_FAILED, "Failed to deserialize configuration body, size %u", body_size);
return KAA_ERR_READ_FAILED;
}
kaa_error_t err = ext_calculate_sha_hash(body, body_size, self->configuration_hash);
if (err) {
KAA_LOG_WARN(self->logger, err, "Failed to calculate configuration body hash");
return err;
}
ext_configuration_store(body, body_size);
#endif
if (self->root_receiver.on_configuration_updated)
self->root_receiver.on_configuration_updated(self->root_receiver.context, self->root_record);
kaa_transport_channel_interface_t *channel =
kaa_channel_manager_get_transport_channel(self->channel_manager, configuration_sync_services[0]);
if (channel)
channel->sync_handler(channel->context, configuration_sync_services, 1);
}
}
return KAA_ERR_NONE;
}
kaa_error_t kaa_configuration_manager_create(kaa_configuration_manager_t **configuration_manager_p, kaa_channel_manager_t *channel_manager, kaa_status_t *status, kaa_logger_t *logger)
{
KAA_RETURN_IF_NIL3(configuration_manager_p, status, logger, KAA_ERR_BADPARAM);
kaa_configuration_manager_t *manager = (kaa_configuration_manager_t *) KAA_MALLOC(sizeof(kaa_configuration_manager_t));
KAA_RETURN_IF_NIL(manager, KAA_ERR_NOMEM);
manager->channel_manager = channel_manager;
manager->status = status;
manager->logger = logger;
manager->root_receiver = (kaa_configuration_root_receiver_t) { NULL, NULL };
char *buffer = NULL;
size_t buffer_size = 0;
bool need_deallocation = false;
if (status->is_updated)
ext_configuration_read(&buffer, &buffer_size, &need_deallocation);
else
ext_configuration_delete();
if (!buffer || !buffer_size) {
need_deallocation = false;
#if KAA_CONFIGURATION_DATA_LENGTH > 0
buffer = (char *)KAA_CONFIGURATION_DATA;
buffer_size = KAA_CONFIGURATION_DATA_LENGTH;
#endif
}
if (buffer && buffer_size > 0) {
ext_calculate_sha_hash(buffer, buffer_size, manager->configuration_hash);
manager->root_record = kaa_configuration_manager_deserialize(buffer, buffer_size);
if (!manager->root_record) {
KAA_FREE(manager);
if (need_deallocation && buffer)
KAA_FREE(buffer);
return KAA_ERR_NOMEM;
}
if (need_deallocation)
KAA_FREE(buffer);
}
*configuration_manager_p = manager;
return KAA_ERR_NONE;
}
