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_on_configuration_updated(void *context, const kaa_root_configuration_t *configuration) { int i = 0; sndc_printf("Configuration updated\n"); kaa_list_node_t *it = kaa_list_begin(configuration->light_zones); while (it) { kaa_configuration_light_zone_t *zone = (kaa_configuration_light_zone_t *) kaa_list_get_data(it); if (zone->zone_id >= 0 && zone->zone_id < LIGHT_ZONES_COUNT) { switch (zone->zone_status) { case ENUM_ZONE_STATUS_ENABLE: if (light_states[i] != LIGHT_ON) { sndc_io_write(light_zones[zone->zone_id], LIGHT_ON); light_states[i] = LIGHT_ON; } break; case ENUM_ZONE_STATUS_DISABLE: if (light_states[i] != LIGHT_OFF) { sndc_io_write(light_zones[zone->zone_id], LIGHT_OFF); light_states[i] = LIGHT_OFF; } break; } } it = kaa_list_next(it); i++; } for(; i < LIGHT_ZONES_COUNT; ++i) { if (light_states[i] != LIGHT_OFF) { sndc_io_write(light_zones[i], LIGHT_OFF); light_states[i] = LIGHT_OFF; } } return KAA_ERR_NONE; }
void ext_write_log(FILE * sink, const char * buffer, size_t message_size) { if (!buffer) { return; } sndc_printf(buffer); sndc_thrd_delay(TRACE_DELAY * SNDC_MILLISECOND); }
static void start_client(void) { sndc_printf("Connecting as client...\n"); /* Clear all profiles */ sndc_profile_eraseAll(); /* clean the local profile and read the stored valies */ sndc_profile_t *connect_profile = sndc_profile_getNew(); /* lock the profile for direct writing */ sndc_profile_writeLock(); /*copy ssid*/ sndc_profile_set_ssidStr(connect_profile, SSID_STR); #ifdef USE_ENCRYPTION sndc_profile_set_passphraseStr(connect_profile, PASSPHRASE); sndc_profile_set_wpa1wpa2(connect_profile, TRUE); #else sndc_profile_set_open(connect_profile, TRUE); #endif /* work as client station*/ sndc_profile_set_role(connect_profile, SNDC_PROFILE_ROLE_CLIENT); /* do not keep profile */ sndc_profile_set_deleteOnDisconnect(connect_profile, TRUE); /* unlock the profile */ sndc_profile_writeUnlock(); /* request connection to the specific profile */ sndc_cm_profileConnect(connect_profile); /* Release profile reference */ sndc_profile_release(connect_profile); }
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."); }
kaa_error_t kaa_client_create(kaa_client_t **kaa_client, kaa_client_props_t *props) { KAA_RETURN_IF_NIL2(kaa_client, props, KAA_ERR_BADPARAM); kaa_error_t error_code = KAA_ERR_NONE; error_code = kaa_init_security_stuff(); KAA_RETURN_IF_ERR(error_code); kaa_client_t *self = sndc_mem_calloc(1,sizeof(kaa_client_t)); KAA_RETURN_IF_NIL(self,KAA_ERR_NOMEM); self->thread_name = sndc_mem_strdup("Kaa-Client-Thread"); self->operate = true; self->max_update_time = props->max_update_time; print_mem_stat(self); sndc_printf("Initializing Kaa SDK...\n"); sndc_thrd_delay(TRACE_DELAY * SNDC_MILLISECOND); error_code = kaa_init(&self->kaa_context); if (error_code) { sndc_printf("Error during Kaa context creation %d\n", error_code); sndc_thrd_delay(TRACE_DELAY * SNDC_MILLISECOND); goto error; } KAA_LOG_INFO(self->kaa_context->logger, KAA_ERR_NONE, "Kaa framework initialized."); print_mem_stat(self); error_code = kaa_log_collector_init(self); if (error_code) { sndc_printf("Failed to init Kaa log collector %d\n", error_code); sndc_thrd_delay(TRACE_DELAY * SNDC_MILLISECOND); goto error; } KAA_LOG_INFO(self->kaa_context->logger, KAA_ERR_NONE, "Kaa log collector initialized."); *kaa_client = self; /* initialize semaphore */ sndc_sem_init(&self->start_semophore, 0); sndc_sem_init(&self->logging_semophore, 0); int status = sndc_thrd_create( self->thread_name, thread_run_fn, (uintptr_t)self, SNDC_THRD_PRIORITY_DEFAULT, THREAD_STACKSIZE_DMR_START); //Defined 4K-8 bytes of stack switch (status) { case 0: break; case -EINVAL: error_code = KAA_ERR_BADPARAM; break; case -ENOMEM: error_code = KAA_ERR_NOMEM; break; default: error_code = KAA_ERR_BADDATA; break; } return error_code; error: sndc_printf("Kaa initialization failed. error_code %d\n", error_code); sndc_thrd_delay(TRACE_DELAY * SNDC_MILLISECOND); kaa_client_destroy(self); return error_code; }
static bool_t APP_handle_msg(sndc_appmsg_msg_t* msg) { bool_t consumed = FALSE; switch(msg->id) { case SNDC_APPMSG_SCAN_COMPLETED: { sndc_printf("SNDC_APPMSG_SCAN_COMPLETED\n"); break; } case SNDC_APPMSG_SCAN_IND: { sndc_printf("SNDC_APPMSG_SCAN_IND\n"); break; } case SNDC_APPMSG_P2P_EVENT: { sndc_printf("SNDC_APPMSG_P2P_EVENT\n"); break; } case SNDC_APPMSG_CM_EVENT: { sndc_printf("SNDC_APPMSG_CM_EVENT\n"); sndc_appmsg_cmEvent_t *cm_event = (sndc_appmsg_cmEvent_t *)msg->par; sndc_printf("GOT SNDC_APPMSG_CM_EVENT FROM PROFILE ID: %d WITH ID: %d \n", cm_event->priv.profileID, cm_event->id); switch(cm_event->id) { case EVENT_TYPE_CM_PEER_STATUS: { switch(cm_event->priv.u.peer_status){ case SNDC_CM_WLAN_DISCONNECTED: sndc_printf( "SNDC_CM_WLAN_DISCONNECTED\n"); break; case SNDC_CM_WLAN_CONNECT_TIMEOUT: sndc_printf( "SNDC_CM_WLAN_CONNECT_TIMEOUT\n"); break; case SNDC_CM_WLAN_CONNECT_FAILED: sndc_printf( "SNDC_CM_WLAN_CONNECT_FAILED\n"); break; case SNDC_CM_WLAN_WPS_FAILED: sndc_printf( "SNDC_CM_WLAN_WPS_FAILED\n"); break; case SNDC_CM_WLAN_WPS_TIMEOUT: sndc_printf( "SNDC_CM_WLAN_WPS_TIMEOUT\n"); break; case SNDC_CM_WLAN_CONNECTED: sndc_printf( "SNDC_CM_WLAN_CONNECTED\n"); break; default: sndc_printf( "[%d] peer_status:%d \n",cm_event->priv.profileID, cm_event->priv.u.peer_status); break; } break; } case EVENT_TYPE_CM_CLIENT_STATUS: break; case EVENT_TYPE_CM_GO_STATUS: break; case EVENT_TYPE_CM_IP_ACQUIRED: { sndc_profile_ipConfig_t *ipconfig = cm_event->priv.u.ip_acquired.ipconfig; sndc_printf("**********************\n"); sndc_printf("IP acquired, status = %d\n", cm_event->priv.u.ip_acquired.status); if(cm_event->priv.u.ip_acquired.status == 0) { assert(ipconfig); sndc_printf("IP addr: %s\n", sndc_inet_ntoa(ipconfig->ip_address)); sndc_printf("Netmask: %s\n", sndc_inet_ntoa(ipconfig->netmask)); sndc_printf("Gateway: %s\n", sndc_inet_ntoa(ipconfig->gateway)); ip_connected = true; sndc_sys_initRandom(sndc_sys_getTimestamp_msec()); } sndc_printf("**********************\n"); break; } case EVENT_TYPE_CM_AUTO_MODE_STATE_CHANGED: { sndc_printf( "[%d] AutoMode state changed:%d \n",cm_event->priv.profileID, cm_event->priv.u.auto_mode_state); break; } } break; } case SNDC_APPMSG_IO_EVENT: { sndc_printf("SNDC_APPMSG_IO_EVENT\n"); sndc_appmsg_ioEvent_t *io_event = (sndc_appmsg_ioEvent_t *)msg->par; if (testDone) { sndc_printf("SNDC_APPMSG_IO_EVENT level %d, pinMask %d\n", io_event->level, io_event->pin_mask); } else { testDone = true; sndc_printf("Button pressed. \n"); start_client(); } break; } default: break; } return consumed; }
static void APP_main() { ip_connected = false; kaa_started = false; kaa_error_t kaa_error = KAA_ERR_NONE; { //Used to limit kaa_props visibility, it creates on stack and release once is used kaa_client_props_t kaa_props; kaa_props.max_update_time = 2; kaa_error = kaa_client_create(&kaa_client, &kaa_props); if (kaa_error) { sndc_printf("Error %d initializing Kaa client \n",kaa_error); return; } } kaa_list_t *zones = kaa_list_create(); int i = 0; for(; i < LIGHT_ZONES_COUNT; ++i) { sndc_io_setMode(light_zones[i], IO_MODE_OUTPUT); sndc_io_write(light_zones[i], LIGHT_OFF); int32_t *zone_id = (int32_t *) KAA_MALLOC(sizeof(int32_t)); *zone_id = i; kaa_list_push_front(zones, zone_id); } kaa_profile_street_lights_profile_t *profile = kaa_profile_street_lights_profile_create(); profile->light_zones = zones; kaa_profile_manager_update_profile(kaa_client_get_context(kaa_client)->profile_manager, profile); profile->destroy(profile); /** * Configuration example, below is how to configure and read default configuration values */ kaa_configuration_root_receiver_t receiver = { NULL, &kaa_on_configuration_updated }; kaa_error = kaa_configuration_manager_set_root_receiver(kaa_client_get_context(kaa_client)->configuration_manager, &receiver); sndc_printf("Configuration setting done. %d\n", kaa_error); //sndc_thrd_delay(TRACE_DELAY * SNDC_MILLISECOND); const kaa_root_configuration_t *root_config = kaa_configuration_manager_get_configuration(kaa_client_get_context(kaa_client)->configuration_manager); kaa_on_configuration_updated(NULL, root_config); //set SW2 button as key input //sndc_io_ctrl(BUTTON, // IO_PIN_FUNC_PULL_UP, // IO_PIN_DRIVE_DEFAULT, // IO_PIN_SLEW_RATE_DEFAULT); //sndc_io_setMode(BUTTON, IO_MODE_KEY); //sndc_device_config = sndc_config_get(); /* clean all profiles */ //sndc_profile_eraseAll(); //sndc_printf("Press SW2 to start test. \n"); start_client(); //infinite thread loop, button press is monitored by system events while(1) { if (ip_connected && !kaa_started) { kaa_client_start(kaa_client, NULL, NULL, 0); kaa_started = true; } //thread sleep for 500 ms sndc_thrd_delay(500 * SNDC_MILLISECOND); } }