static kaa_error_t kaa_context_create(kaa_context_t **context_p, kaa_logger_t *logger)
{
// TODO(KAA-982): use asserts
if (!context_p || !logger) {
return KAA_ERR_BADPARAM;
}
kaa_context_t *context = KAA_CALLOC(1, sizeof(*context));
if (!context) {
return KAA_ERR_NOMEM;
}
context->logger = logger;
kaa_error_t error = KAA_ERR_NONE;
context->status = KAA_CALLOC(1, sizeof(*context->status));
if (!context->status) {
error = KAA_ERR_NOMEM;
goto exit;
}
error = kaa_status_create(&context->status->status_instance);
if (error) {
goto exit;
}
error = kaa_platform_protocol_create(&context->platform_protocol, context->logger,
context->status->status_instance);
if (error) {
goto exit;
}
error = kaa_channel_manager_create(&context->channel_manager, context);
if (error) {
goto exit;
}
error = kaa_extension_init_all(context);
if (error) {
goto exit;
}
error = kaa_failover_strategy_create(&context->failover_strategy, logger);
if (error) {
goto extensions_deinit;
}
*context_p = context;
return KAA_ERR_NONE;
extensions_deinit:
kaa_extension_deinit_all();
exit:
kaa_context_destroy(context);
return error;
}
/** @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_client_create(kaa_client_t **client, kaa_client_props_t *props) {
(void)props;
KAA_RETURN_IF_NIL(client, KAA_ERR_BADPARAM);
kaa_client_t *self = (kaa_client_t*)KAA_CALLOC(1, sizeof(kaa_client_t));
KAA_RETURN_IF_NIL(self, KAA_ERR_NOMEM);
kaa_error_t error_code = kaa_init(&self->context);
if(error_code) {
printf("Error initialising kaa_context\n");
kaa_client_destroy(self);
return error_code;
}
self->operate = true;
#ifndef KAA_DISABLE_FEATURE_LOGGING
error_code = kaa_log_collector_init(self);
if (error_code) {
KAA_LOG_ERROR(self->context->logger, error_code, "Failed to init Kaa log collector, error %d", error_code);
kaa_client_destroy(self);
return error_code;
}
#endif
KAA_LOG_INFO(self->context->logger,KAA_ERR_NONE, "Kaa client initiallized");
*client = self;
return error_code;
}
/*
* Test Check bootstrap channel sync call.
* 1. Set access point, check connect and authorize sending CONNECT and receiving CONNACK
* 2. Receive Bootstrap Kaa Sync message.
* 3. Send disconnect, check sending.
* 4. Check socket close.
* 5. Call sync
* 6. Check connect and authorize sending CONNECT and receiving CONNACK
* 7. Receive Bootstrap Kaa Sync message.
* 8. Send disconnect, check sending.
* 9. Check socket close.
*/
void test_bootstrap_sync_success(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code;
kaa_transport_channel_interface_t *channel = NULL;
channel = KAA_CALLOC(1,sizeof(kaa_transport_channel_interface_t));
kaa_service_t bootstrap_services[] = {KAA_SERVICE_BOOTSTRAP};
error_code = kaa_tcp_channel_create(channel,logger,bootstrap_services,1);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
//Set access point and imitate start of connection to destination
test_set_access_point(channel);
//Check standard bootstrap flow (connect, authenticate, sync receive and disconnect)
test_check_bootstrap_sync(channel);
//Imitate sync call
channel->sync_handler(channel->context, bootstrap_services, 1);
//Check standard bootstrap flow (connect, authenticate, sync receive and disconnect)
test_check_bootstrap_sync(channel);
channel->destroy(channel->context);
KAA_TRACE_OUT(logger);
KAA_FREE(channel);
}
mock_storage_context_t *create_mock_storage(void)
{
mock_storage_context_t *storage = KAA_CALLOC(1, sizeof(mock_storage_context_t));
KAA_RETURN_IF_NIL(storage, NULL);
storage->logs = kaa_list_create();
return storage;
}
/*
* Test IO error during operation.
* 1. Set access point, check connect and authorize sending CONNECT and receiving CONNACK
* 2. Imitate IO error on read
* 3. Close socket, check bootstrap manager access point failure notification
*/
void test_set_access_point_io_error(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code;
kaa_transport_channel_interface_t *channel = NULL;
channel = KAA_CALLOC(1,sizeof(kaa_transport_channel_interface_t));
kaa_service_t bootstrap_services[] = {KAA_SERVICE_BOOTSTRAP};
error_code = kaa_tcp_channel_create(channel,logger,bootstrap_services,1);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
//Set access point and imitate start of connection to destination
test_set_access_point(channel);
//Imitate WR event, and wait socket connect call, channel should start authorization, prepare
//CONNECT message
error_code = kaa_tcp_channel_process_event(channel,FD_WRITE);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(access_point_test_info.socket_connected, true);
ASSERT_EQUAL(access_point_test_info.socket_connected_callback, true);
ASSERT_EQUAL(access_point_test_info.fill_connect_message, true);
ASSERT_EQUAL(access_point_test_info.request_connect, true);
//Check correct RD,WR operation, in this point we waiting for RD,WR operations true
CHECK_SOCKET_RW(channel,true,true);
//Imitate socket ready for writing, and writing CONNECT message
error_code = kaa_tcp_channel_process_event(channel,FD_WRITE);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(access_point_test_info.auth_packet_written, true);
//Check correct RD,WR operation, in this point we waiting for RD operations true
//and WR false, no pending services and empty buffer.
CHECK_SOCKET_RW(channel,true,false);
//Imitate socket ready for reading, and got IO error during read
access_point_test_info.socket_connecting_error_scenario = true;
error_code = kaa_tcp_channel_process_event(channel,FD_READ);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(access_point_test_info.connack_read, false);
ASSERT_EQUAL(access_point_test_info.socket_disconnected_callback, true);
ASSERT_EQUAL(access_point_test_info.socket_disconnected_closed, true);
ASSERT_EQUAL(access_point_test_info.bootstrap_manager_on_access_point_failed, true);
channel->destroy(channel->context);
KAA_TRACE_OUT(logger);
KAA_FREE(channel);
}
static void test_kaa_channel_create(kaa_transport_channel_interface_t *self)
{
self->context = KAA_CALLOC(1, sizeof(mock_transport_channel_context_t));
self->get_protocol_id = test_kaa_get_protocol_id;
self->get_supported_services = test_kaa_get_supported_services;
self->destroy = test_kaa_channel_destroy;
self->sync_handler = test_kaa_sync_handler;
self->init = test_kaa_init_channel;
self->set_access_point = test_kaa_set_access_point;
}
avro_writer_t avro_writer_memory(const char *buf, int64_t len)
{
struct avro_writer_t_ *mem_writer = (struct avro_writer_t_ *) KAA_CALLOC(1,
sizeof(struct avro_writer_t_));
if (!mem_writer) {
return NULL;
}
mem_writer->buf = buf;
mem_writer->len = len;
mem_writer->written = 0;
return mem_writer;
}
static kaa_union_t *kaa_union_null_or_fixed_create(void)
{
kaa_union_t *kaa_union = KAA_CALLOC(1, sizeof(kaa_union_t));
if (kaa_union) {
kaa_union->serialize = kaa_union_null_or_fixed_serialize;
kaa_union->get_size = kaa_union_null_or_fixed_get_size;
kaa_union->destroy = kaa_union_null_or_fixed_destroy;
}
return kaa_union;
}
kaa_profile_basic_endpoint_profile_test_t *kaa_profile_basic_endpoint_profile_test_create(void)
{
kaa_profile_basic_endpoint_profile_test_t *record =
(kaa_profile_basic_endpoint_profile_test_t *)KAA_CALLOC(1, sizeof(kaa_profile_basic_endpoint_profile_test_t));
if (record) {
record->serialize = kaa_profile_basic_endpoint_profile_test_serialize;
record->get_size = kaa_profile_basic_endpoint_profile_test_get_size;
record->destroy = kaa_profile_basic_endpoint_profile_test_destroy;
}
return record;
}
kaa_configuration_root_record_t *kaa_configuration_root_record_create(void)
{
kaa_configuration_root_record_t *record =
(kaa_configuration_root_record_t *)KAA_CALLOC(1, sizeof(kaa_configuration_root_record_t));
if (record) {
record->serialize = kaa_configuration_root_record_serialize;
record->get_size = kaa_configuration_root_record_get_size;
record->destroy = kaa_configuration_root_record_destroy;
}
return record;
}
kaa_movement_class_movement_direction_t *kaa_movement_class_movement_direction_create()
{
kaa_movement_class_movement_direction_t *record =
(kaa_movement_class_movement_direction_t *)KAA_CALLOC(1, sizeof(kaa_movement_class_movement_direction_t));
if (record) {
record->serialize = kaa_movement_class_movement_direction_serialize;
record->get_size = kaa_movement_class_movement_direction_get_size;
record->destroy = kaa_data_destroy;
}
return record;
}
kaa_error_t kaa_buffer_create_buffer(kaa_buffer_t **buffer_p, size_t buffer_size)
{
KAA_RETURN_IF_NIL2(buffer_p, buffer_size, KAA_ERR_BADPARAM);
kaa_buffer_t *buffer = (kaa_buffer_t *) KAA_MALLOC(sizeof(kaa_buffer_t));
KAA_RETURN_IF_NIL(buffer, KAA_ERR_NOMEM);
buffer->begin = (char *) KAA_CALLOC(buffer_size , sizeof(char));
if (!buffer->begin) {
KAA_FREE(buffer);
return KAA_ERR_NOMEM;
}
buffer->end = buffer->begin + buffer_size;
buffer->current = buffer->begin;
*buffer_p = buffer;
return KAA_ERR_NONE;
}
/*
* Test create and destroy bootstrap channel
*/
void test_create_kaa_tcp_channel(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code;
kaa_transport_channel_interface_t *channel = NULL;
channel = KAA_CALLOC(1,sizeof(kaa_transport_channel_interface_t));
kaa_service_t bootstrap_services[] = {KAA_SERVICE_BOOTSTRAP};
error_code = kaa_tcp_channel_create(channel,logger,bootstrap_services,1);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(channel->context);
ASSERT_NOT_NULL(channel->get_protocol_id);
ASSERT_NOT_NULL(channel->get_supported_services);
ASSERT_NOT_NULL(channel->init);
ASSERT_NOT_NULL(channel->destroy);
ASSERT_NOT_NULL(channel->set_access_point);
ASSERT_NOT_NULL(channel->sync_handler);
kaa_transport_protocol_id_t protocol_info;
error_code = channel->get_protocol_id(channel->context,&protocol_info);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(protocol_info.id, 0x56c8ff92);
ASSERT_EQUAL(protocol_info.version, 1);
kaa_service_t *r_supported_services;
size_t r_supported_service_count = 0;
error_code = channel->get_supported_services(channel->context,&r_supported_services,&r_supported_service_count);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(r_supported_service_count, 1);
ASSERT_EQUAL(r_supported_services[0], KAA_SERVICE_BOOTSTRAP);
channel->destroy(channel->context);
KAA_TRACE_OUT(logger);
KAA_FREE(channel);
}
/*
* Test connecting error during set access point.
*/
void test_set_access_point_connecting_error(void)
{
KAA_TRACE_IN(logger);
kaa_error_t error_code;
kaa_transport_channel_interface_t *channel = NULL;
channel = KAA_CALLOC(1,sizeof(kaa_transport_channel_interface_t));
kaa_service_t bootstrap_services[] = {KAA_SERVICE_BOOTSTRAP};
error_code = kaa_tcp_channel_create(channel,logger,bootstrap_services,1);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
//Set access point and imitate start of connection to destination
test_set_access_point(channel);
//Imitate WR event, and wait socket connect call and return socket connection error
access_point_test_info.socket_connecting_error_scenario = true;
error_code = kaa_tcp_channel_process_event(channel,FD_WRITE);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(access_point_test_info.socket_connected_callback, false);
ASSERT_EQUAL(access_point_test_info.fill_connect_message, false);
ASSERT_EQUAL(access_point_test_info.request_connect, false);
ASSERT_EQUAL(access_point_test_info.socket_connecting_error_callback, true);
ASSERT_EQUAL(access_point_test_info.socket_disconnected_closed, true);
ASSERT_EQUAL(access_point_test_info.bootstrap_manager_on_access_point_failed, true);
channel->destroy(channel->context);
KAA_TRACE_OUT(logger);
KAA_FREE(channel);
}
void test_kaatcp_parser()
{
KAA_TRACE_IN(logger);
kaatcp_parser_handlers_t handlers = { NULL, &connack_listener, &disconnect_listener, &kaasync_listener, &ping_listener };
kaatcp_parser_t parser;
parser.payload_buffer_size = 1;
parser.payload = KAA_CALLOC(parser.payload_buffer_size, sizeof(char));
kaatcp_error_t rval = kaatcp_parser_init(&parser, &handlers);
ASSERT_EQUAL(rval, KAATCP_ERR_NONE);
char connack_and_ping_messages[] = { 0x20, 0x02, 0x00, 0x03, 0xD0, 0x00 };
rval = kaatcp_parser_process_buffer(&parser, connack_and_ping_messages, 6);
ASSERT_EQUAL(rval, KAATCP_ERR_NONE);
ASSERT_NOT_EQUAL(ping_received, 0);
ASSERT_NOT_EQUAL(connack_received, 0);
unsigned char kaa_sync_message[] = { 0xF0, 0x0D, 0x00, 0x06, 'K', 'a', 'a', 't', 'c', 'p', 0x01, 0x00, 0x05, 0x14, 0xFF };
rval = kaatcp_parser_process_buffer(&parser, (const char *)kaa_sync_message, 15);
ASSERT_EQUAL(rval, KAATCP_ERR_NONE);
ASSERT_NOT_EQUAL(kaasync_received, 0);
unsigned char disconnect_message[] = { 0xE0, 0x02, 0x00, 0x01 };
rval = kaatcp_parser_process_buffer(&parser, (const char *) disconnect_message, 4);
ASSERT_EQUAL(rval, KAATCP_ERR_NONE);
ASSERT_NOT_EQUAL(disconnect_received, 0);
KAA_FREE(parser.payload);
KAA_TRACE_OUT(logger);
}
