/*
* 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);
}
/*
* 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);
}
kaa_error_t kaa_client_process_channel_connected(kaa_client_t *kaa_client)
{
KAA_RETURN_IF_NIL(kaa_client, KAA_ERR_BADPARAM);
fd_set read_fds, write_fds, except_fds;
struct timeval select_tv = { get_poll_timeout(kaa_client), 0 };
int channel_fd = 0;
FD_ZERO(&read_fds);
FD_ZERO(&write_fds);
FD_ZERO(&except_fds);
kaa_error_t error_code = kaa_tcp_channel_get_descriptor(&kaa_client->channel, &channel_fd);
if(error_code) KAA_LOG_ERROR(kaa_client->context->logger, error_code, "No descriptor provided!");
if (kaa_tcp_channel_is_ready(&kaa_client->channel, FD_READ))
FD_SET(channel_fd, &read_fds);
if (kaa_tcp_channel_is_ready(&kaa_client->channel, FD_WRITE))
FD_SET(channel_fd, &write_fds);
int poll_result = select(channel_fd + 1, &read_fds, &write_fds, NULL, &select_tv);
if (poll_result == 0) {
error_code = kaa_tcp_channel_check_keepalive(&kaa_client->channel);
} else if (poll_result > 0) {
if (channel_fd >= 0) {
if (FD_ISSET(channel_fd, &read_fds)) {
KAA_LOG_DEBUG(kaa_client->context->logger, KAA_ERR_NONE,
"Processing IN event for the client socket %d", channel_fd);
error_code = kaa_tcp_channel_process_event(&kaa_client->channel, FD_READ);
if (error_code) {
KAA_LOG_ERROR(kaa_client->context->logger, error_code,
"Failed to process IN event for the client socket %d", channel_fd);
}
}
if (FD_ISSET(channel_fd, &write_fds)) {
KAA_LOG_DEBUG(kaa_client->context->logger, KAA_ERR_NONE,
"Processing OUT event for the client socket %d", channel_fd);
error_code = kaa_tcp_channel_process_event(&kaa_client->channel, FD_WRITE);
if (error_code) {
KAA_LOG_ERROR(kaa_client->context->logger, error_code,
"Failed to process OUT event for the client socket %d", channel_fd);
}
}
}
} else {
KAA_LOG_ERROR(kaa_client->context->logger, KAA_ERR_BAD_STATE, "Failed to poll descriptors");
error_code = KAA_ERR_BAD_STATE;
}
if (kaa_client->channel_socket_closed) {
KAA_LOG_INFO(kaa_client->context->logger, KAA_ERR_NONE,
"Channel [0x%08X] connection terminated", kaa_client->channel_id);
kaa_client->channel_state = KAA_CLIENT_CHANNEL_STATE_NOT_CONNECTED;
if (error_code != KAA_ERR_EVENT_NOT_ATTACHED) {
kaa_client_deinit_channel(kaa_client);
}
}
return error_code;
}
void test_check_bootstrap_sync(kaa_transport_channel_interface_t *channel)
{
ASSERT_NOT_NULL(channel);
//Reset test bools
access_point_test_info.socket_connected = false;
access_point_test_info.socket_connected_callback = false;
access_point_test_info.fill_connect_message = false;
access_point_test_info.request_connect = false;
access_point_test_info.auth_packet_written = false;
access_point_test_info.connack_read = false;
access_point_test_info.kaasync_read = false;
access_point_test_info.kaasync_processed = false;
access_point_test_info.socket_disconnected_write = false;
access_point_test_info.socket_disconnected_callback = false;
access_point_test_info.socket_disconnected_closed = false;
access_point_test_info.bootstrap_manager_on_access_point_failed = false;
//Imitate WR event, and wait socket connect call, channel should start authorization, prepare
//CONNECT message
kaa_error_t 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 read CONNACK message
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, true);
//Check correct RD,WR operation, in this point we waiting for RD operations true
//and WR false, no pending services and empty buffer.
//Checking receiving KAA_SYNC message
CHECK_SOCKET_RW(channel,true,false);
//Imitate socket ready for reading, and read KAA_SYNC Bootstrap message
error_code = kaa_tcp_channel_process_event(channel,FD_READ);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(access_point_test_info.kaasync_read, true);
ASSERT_EQUAL(access_point_test_info.kaasync_processed, true);
//Check correct RD,WR operation, in this point we waiting for WR operations true
//and RD true, no pending services and buffer with Disconnect message.
//Checking receiving KAA_SYNC message
CHECK_SOCKET_RW(channel,true,true);
//Imitate socket ready for writing, and write Disconnect 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_disconnected_write, true);
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, false);
}
int kaa_demo_event_loop()
{
kaa_error_t error_code = kaa_start(kaa_context_);
if (error_code) {
KAA_LOG_FATAL(kaa_context_->logger, error_code,"Failed to start Kaa workflow");
return -1;
}
uint16_t select_timeout;
error_code = kaa_tcp_channel_get_max_timeout(&operations_channel, &select_timeout);
if (error_code) {
KAA_LOG_FATAL(kaa_context_->logger, error_code,"Failed to get Operations channel keepalive timeout");
return -1;
}
if (select_timeout > KAA_DEMO_LOG_GENERATION_FREQUENCY) {
select_timeout = KAA_DEMO_LOG_GENERATION_FREQUENCY;
}
fd_set read_fds, write_fds, except_fds;
int ops_fd = 0, bootstrap_fd = 0;
struct timeval select_tv = { 0, 0 };
int max_fd = 0;
while (log_record_counter < KAA_DEMO_LOGS_TO_SEND) {
FD_ZERO(&read_fds);
FD_ZERO(&write_fds);
FD_ZERO(&except_fds);
max_fd = 0;
kaa_tcp_channel_get_descriptor(&operations_channel, &ops_fd);
if (max_fd < ops_fd)
max_fd = ops_fd;
kaa_tcp_channel_get_descriptor(&bootstrap_channel, &bootstrap_fd);
if (max_fd < bootstrap_fd)
max_fd = bootstrap_fd;
if (kaa_tcp_channel_is_ready(&operations_channel, FD_READ))
FD_SET(ops_fd, &read_fds);
if (kaa_tcp_channel_is_ready(&operations_channel, FD_WRITE))
FD_SET(ops_fd, &write_fds);
if (kaa_tcp_channel_is_ready(&bootstrap_channel, FD_READ))
FD_SET(bootstrap_fd, &read_fds);
if (kaa_tcp_channel_is_ready(&bootstrap_channel, FD_WRITE))
FD_SET(bootstrap_fd, &write_fds);
select_tv.tv_sec = select_timeout;
select_tv.tv_usec = 0;
int poll_result = select(max_fd + 1, &read_fds, &write_fds, NULL, &select_tv);
if (poll_result == 0) {
kaa_demo_add_log_record();
kaa_tcp_channel_check_keepalive(&operations_channel);
kaa_tcp_channel_check_keepalive(&bootstrap_channel);
} else if (poll_result > 0) {
if (bootstrap_fd >= 0) {
if (FD_ISSET(bootstrap_fd, &read_fds)) {
KAA_LOG_DEBUG(kaa_context_->logger, KAA_ERR_NONE,"Processing IN event for the Bootstrap client socket %d", bootstrap_fd);
error_code = kaa_tcp_channel_process_event(&bootstrap_channel, FD_READ);
if (error_code)
KAA_LOG_ERROR(kaa_context_->logger, KAA_ERR_NONE,"Failed to process IN event for the Bootstrap client socket %d", bootstrap_fd);
}
if (FD_ISSET(bootstrap_fd, &write_fds)) {
KAA_LOG_DEBUG(kaa_context_->logger, KAA_ERR_NONE,"Processing OUT event for the Bootstrap client socket %d", bootstrap_fd);
error_code = kaa_tcp_channel_process_event(&bootstrap_channel, FD_WRITE);
if (error_code)
KAA_LOG_ERROR(kaa_context_->logger, error_code,"Failed to process OUT event for the Bootstrap client socket %d", bootstrap_fd);
}
}
if (ops_fd >= 0) {
if (FD_ISSET(ops_fd, &read_fds)) {
KAA_LOG_DEBUG(kaa_context_->logger, KAA_ERR_NONE,"Processing IN event for the Operations client socket %d", ops_fd);
error_code = kaa_tcp_channel_process_event(&operations_channel, FD_READ);
if (error_code)
KAA_LOG_ERROR(kaa_context_->logger, error_code,"Failed to process IN event for the Operations client socket %d", ops_fd);
}
if (FD_ISSET(ops_fd, &write_fds)) {
KAA_LOG_DEBUG(kaa_context_->logger, KAA_ERR_NONE,"Processing OUT event for the Operations client socket %d", ops_fd);
error_code = kaa_tcp_channel_process_event(&operations_channel, FD_WRITE);
if (error_code)
KAA_LOG_ERROR(kaa_context_->logger, error_code,"Failed to process OUT event for the Operations client socket %d", ops_fd);
}
}
} else {
KAA_LOG_ERROR(kaa_context_->logger, KAA_ERR_BAD_STATE,"Failed to poll descriptors: %s", strerror(errno));
return -1;
}
}
return 0;
}
void thread_run_fn(uintptr_t arg)
{
if(!arg) {
sndc_printf("Kaa client thread function Error, no args\n");
return;
}
kaa_client_t *self = (kaa_client_t *)arg;
KAA_LOG_TRACE(self->kaa_context->logger, KAA_ERR_NONE, "Kaa client working thread started....");
sndc_sem_post(&self->logging_semophore);
sndc_sock_fdset r_set;
sndc_sock_fdset w_set;
sndc_sock_fdset x_set;
int r = 0;
int max_fd = 0;
uint32_t msec = 0;
int ops_fd = -1, bootstrap_fd = -1;
bool_t fdset = false;
uint16_t timeout = self->max_update_time;
kaa_error_t error_code;
KAA_LOG_TRACE(self->kaa_context->logger, KAA_ERR_NONE, "Kaa client working thread(%s) wait starting...", self->thread_name);
sndc_sem_wait(&self->start_semophore);
KAA_LOG_INFO(self->kaa_context->logger, KAA_ERR_NONE, "Kaa client working thread(%s) started", self->thread_name);
while(self->operate) {
max_fd = 0;
SNDC_FD_ZERO(&r_set);
SNDC_FD_ZERO(&w_set);
SNDC_FD_ZERO(&x_set);
// This semaphore is used to synchronize main thread and kaa_client thread,
// mostly for logging proposes.
sndc_sem_tryWait(&self->logging_semophore);
if (self->operations_channel.context)
kaa_tcp_channel_get_descriptor(&self->operations_channel, &ops_fd);
if(self->bootstrap_channel.context)
kaa_tcp_channel_get_descriptor(&self->bootstrap_channel, &bootstrap_fd);
KAA_LOG_DEBUG(self->kaa_context->logger, KAA_ERR_NONE, "IO LOOP: descriptors: bootstrap(%d), operations(%d)", bootstrap_fd, ops_fd);
print_mem_stat(self);
if (bootstrap_fd >= 0) {
fdset = false;
if (kaa_tcp_channel_is_ready(&self->bootstrap_channel, FD_READ)) {
SNDC_FD_SET(bootstrap_fd, &r_set);
KAA_LOG_DEBUG(self->kaa_context->logger,
KAA_ERR_NONE,
"IO LOOP: Bootstrap READ set wait");
fdset = true;
}
if (kaa_tcp_channel_is_ready(&self->bootstrap_channel, FD_WRITE)) {
SNDC_FD_SET(bootstrap_fd, &w_set);
KAA_LOG_DEBUG(self->kaa_context->logger,
KAA_ERR_NONE,
"IO LOOP: Bootstrap WRITE set wait");
fdset = true;
}
if (fdset) {
max_fd = MAX(max_fd, bootstrap_fd);
SNDC_FD_SET(bootstrap_fd, &x_set);
}
}
if (ops_fd >= 0) {
fdset = false;
if (kaa_tcp_channel_is_ready(&self->operations_channel, FD_READ)) {
SNDC_FD_SET(ops_fd, &r_set);
KAA_LOG_DEBUG(self->kaa_context->logger,
KAA_ERR_NONE,
"IO LOOP: Operations READ set wait");
fdset = true;
}
if (kaa_tcp_channel_is_ready(&self->operations_channel, FD_WRITE)) {
SNDC_FD_SET(ops_fd, &w_set);
KAA_LOG_DEBUG(self->kaa_context->logger,
KAA_ERR_NONE,
"IO LOOP: Operations WRITE set wait");
fdset = true;
}
if (fdset) {
max_fd = MAX(max_fd, ops_fd);
SNDC_FD_SET(ops_fd, &x_set);
}
}
kaa_tcp_channel_get_max_timeout(&self->operations_channel, &timeout);
self->timeval.tv_sec = timeout;
if (timeout > self->max_update_time)
self->timeval.tv_sec = self->max_update_time;
self->timeval.tv_usec = 0;
sndc_sem_post(&self->logging_semophore);
r = sndc_sock_select(max_fd+1,&r_set,&w_set,&x_set,&self->timeval);
sndc_sem_tryWait(&self->logging_semophore);
if (r == 0) {
msec = sndc_sys_getTimestamp_msec();
KAA_LOG_DEBUG(self->kaa_context->logger,
KAA_ERR_NONE,
"IO LOOP: timeout (%d) expired",
self->timeval.tv_sec);
if (self->bootstrap_state == BOOTSRAP_FINISHED && bootstrap_fd == -1) {
sndc_printf("Bootstrap channel deinit, Operations channel init %d\n", bootstrap_fd);
KAA_LOG_INFO(self->kaa_context->logger,
KAA_ERR_NONE,
"IO LOOP: Bootstrap channel finish processing switching to Operations channel");
kaa_client_deinit_bootstrap_channel(self);
kaa_client_init_operations_channel(self);
}
if (self->bootstrap_channel.context) {
error_code = kaa_tcp_channel_check_keepalive(&self->bootstrap_channel);
if (error_code) {
KAA_LOG_ERROR(self->kaa_context->logger,
KAA_ERR_NONE,
"IO LOOP: Failed Keepalive Bootstrap(%d) check",
bootstrap_fd);
}
}
if (self->operations_channel.context) {
error_code = kaa_tcp_channel_check_keepalive(&self->operations_channel);
if (error_code) {
KAA_LOG_ERROR(self->kaa_context->logger,
KAA_ERR_NONE,
"IO LOOP: Failed Keepalive Operations(%d) check",
ops_fd);
}
}
} else if (r > 0) {
sndc_printf("FD SET return %d events\n", r);
KAA_LOG_DEBUG(self->kaa_context->logger,
KAA_ERR_NONE,
"IO LOOP: select() return %d events", r);
if (bootstrap_fd >= 0) {
fdset = false;
if (SNDC_FD_ISSET(bootstrap_fd, &r_set)) {
fdset = true;
KAA_LOG_DEBUG(self->kaa_context->logger,
KAA_ERR_NONE,
"IO LOOP: Read Event Bootstrap(%d)", bootstrap_fd);
error_code = kaa_tcp_channel_process_event(&self->bootstrap_channel, FD_READ);
if (error_code) {
KAA_LOG_ERROR(self->kaa_context->logger,
error_code,
"IO LOOP: Failed Read Event Bootstrap(%d)", bootstrap_fd);
}
}
if (fdset)
r--;
if (r > 0) {
fdset = false;
if (SNDC_FD_ISSET(bootstrap_fd, &w_set)) {
fdset = true;
KAA_LOG_DEBUG(self->kaa_context->logger,
KAA_ERR_NONE,
"IO LOOP: Write Event Bootstrap(%d)", bootstrap_fd);
error_code = kaa_tcp_channel_process_event(&self->bootstrap_channel, FD_WRITE);
if (error_code) {
KAA_LOG_ERROR(self->kaa_context->logger,
error_code,
"IO LOOP: Failed Write Event Bootstrap(%d)", bootstrap_fd);
}
}
if (fdset)
r--;
}
if (r > 0) {
fdset = false;
if (SNDC_FD_ISSET(bootstrap_fd, &x_set)) {
fdset = true;
sndc_printf("Exception Event Bootstrap %d\n", bootstrap_fd);
KAA_LOG_DEBUG(self->kaa_context->logger,
KAA_ERR_NONE,
"IO LOOP: Exception Event Bootstrap(%d)", bootstrap_fd);
error_code = kaa_tcp_channel_process_event(&self->bootstrap_channel, FD_EXCEPTION);
if (error_code) {
KAA_LOG_ERROR(self->kaa_context->logger,
error_code,
"IO LOOP: Failed Exception Event Bootstrap(%d)", bootstrap_fd);
}
}
if (fdset)
r--;
}
}
if (r > 0 && ops_fd >= 0) {
fdset = false;
if (SNDC_FD_ISSET(ops_fd, &r_set)) {
fdset = true;
KAA_LOG_DEBUG(self->kaa_context->logger,
KAA_ERR_NONE,
"IO LOOP: Read Event Operations(%d)", ops_fd);
error_code = kaa_tcp_channel_process_event(&self->operations_channel, FD_READ);
if (error_code) {
KAA_LOG_ERROR(self->kaa_context->logger,
error_code,
"IO LOOP: Failed Read Event Operations(%d)", ops_fd);
}
}
if (fdset)
r--;
if (r > 0) {
fdset = false;
if (SNDC_FD_ISSET(ops_fd, &w_set)) {
fdset = true;
KAA_LOG_DEBUG(self->kaa_context->logger,
KAA_ERR_NONE,
"IO LOOP: Write Event Operations(%d)", ops_fd);
error_code = kaa_tcp_channel_process_event(&self->operations_channel, FD_WRITE);
if (error_code) {
KAA_LOG_ERROR(self->kaa_context->logger,
error_code,
"IO LOOP: Failed Write Event Operations(%d)", ops_fd);
}
}
}
if (fdset)
r--;
if (r > 0) {
fdset = false;
if (SNDC_FD_ISSET(ops_fd, &x_set)) {
fdset = true;
sndc_printf("Exception Event Operations %d\n", ops_fd);
KAA_LOG_DEBUG(self->kaa_context->logger,
KAA_ERR_NONE,
"IO LOOP: Exception Event Operations(%d)", ops_fd);
error_code = kaa_tcp_channel_process_event(&self->operations_channel, FD_EXCEPTION);
if (error_code) {
KAA_LOG_ERROR(self->kaa_context->logger,
error_code,
"IO LOOP: Failed Exception Event Operations(%d)", ops_fd);
}
}
}
}
} else {
KAA_LOG_ERROR(self->kaa_context->logger,
KAA_ERR_BAD_STATE,
"IO LOOP: Error %d returned from select()", r);
}
}
KAA_LOG_INFO(self->kaa_context->logger,
KAA_ERR_NONE,
"IO LOOP: Finished.");
}