From 2983fbcb5f584a282815c88fddfa0ea19a1aaf4a Mon Sep 17 00:00:00 2001 From: Matthias Ringwald Date: Sun, 14 Jul 2019 15:43:24 +0200 Subject: [PATCH] mesh: fix unused, shadowing, signed compares --- src/mesh/adv_bearer.c | 1 + src/mesh/gatt_bearer.c | 4 +- src/mesh/mesh_access.c | 12 ++-- src/mesh/mesh_access.h | 2 + src/mesh/mesh_configuration_server.c | 92 ++++++++++++++++++--------- src/mesh/mesh_crypto.c | 2 + src/mesh/mesh_network.c | 3 + src/mesh/mesh_upper_transport.c | 6 +- src/mesh/pb_adv.c | 21 +++--- src/mesh/pb_gatt.c | 7 +- src/mesh/provisioning_device.c | 25 +++++--- src/mesh/provisioning_provisioner.c | 95 ++++++++++++++++------------ 12 files changed, 168 insertions(+), 102 deletions(-) diff --git a/src/mesh/adv_bearer.c b/src/mesh/adv_bearer.c index 020b810f9..3aa035f64 100644 --- a/src/mesh/adv_bearer.c +++ b/src/mesh/adv_bearer.c @@ -198,6 +198,7 @@ static void adv_bearer_emit_can_send_now(void){ } static void adv_bearer_timeout_handler(btstack_timer_source_t * ts){ + UNUSED(ts); uint32_t now = btstack_run_loop_get_time_ms(); switch (adv_bearer_state){ case STATE_GAP: diff --git a/src/mesh/gatt_bearer.c b/src/mesh/gatt_bearer.c index ef1c7b2d7..74893b1b6 100644 --- a/src/mesh/gatt_bearer.c +++ b/src/mesh/gatt_bearer.c @@ -159,8 +159,8 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe UNUSED(size); mesh_msg_sar_field_t msg_sar_field; - int pdu_segment_len; - int pos; + uint16_t pdu_segment_len; + uint16_t pos; hci_con_handle_t con_handle; int send_to_mesh_network; diff --git a/src/mesh/mesh_access.c b/src/mesh/mesh_access.c index f144b4978..89f5e6667 100644 --- a/src/mesh/mesh_access.c +++ b/src/mesh/mesh_access.c @@ -74,7 +74,7 @@ static void * btstack_tlv_singleton_context; // Transitions static btstack_linked_list_t transitions; static btstack_timer_source_t transitions_timer; -static int transition_step_min_ms; +static uint32_t transition_step_min_ms; static uint8_t mesh_transaction_id_counter = 0; static void mesh_access_setup_tlv(void){ @@ -994,7 +994,7 @@ void mesh_access_message_processed(mesh_pdu_t * pdu){ } int mesh_model_contains_subscription(mesh_model_t * mesh_model, uint16_t address){ - int i; + uint16_t i; for (i=0;isubscriptions[i] == address) return 1; } @@ -1274,14 +1274,14 @@ void mesh_delete_appkey_lists(void){ } void mesh_model_reset_appkeys(mesh_model_t * mesh_model){ - int i; + uint16_t i; for (i=0;iappkey_indices[i] = MESH_APPKEY_INVALID; } } uint8_t mesh_model_bind_appkey(mesh_model_t * mesh_model, uint16_t appkey_index){ - int i; + uint16_t i; for (i=0;iappkey_indices[i] == appkey_index) return MESH_FOUNDATION_STATUS_SUCCESS; } @@ -1296,7 +1296,7 @@ uint8_t mesh_model_bind_appkey(mesh_model_t * mesh_model, uint16_t appkey_index) } void mesh_model_unbind_appkey(mesh_model_t * mesh_model, uint16_t appkey_index){ - int i; + uint16_t i; for (i=0;iappkey_indices[i] == appkey_index) { mesh_model->appkey_indices[i] = MESH_APPKEY_INVALID; @@ -1591,6 +1591,8 @@ void mesh_access_key_refresh_revoke_keys(mesh_subnet_t * subnet){ static void mesh_access_secure_network_beacon_handler(uint8_t packet_type, uint16_t channel, uint8_t * packet, uint16_t size){ UNUSED(channel); + UNUSED(size); + if (packet_type != MESH_BEACON_PACKET) return; // lookup subnet and netkey by network id diff --git a/src/mesh/mesh_access.h b/src/mesh/mesh_access.h index 0c8a0b48c..273f3775b 100644 --- a/src/mesh/mesh_access.h +++ b/src/mesh/mesh_access.h @@ -290,6 +290,8 @@ uint16_t mesh_model_get_model_id(uint32_t model_identifier); uint32_t mesh_model_get_model_identifier(uint16_t vendor_id, uint16_t model_id); +uint16_t mesh_model_get_vendor_id(uint32_t model_identifier); + mesh_model_t * mesh_model_get_configuration_server(void); mesh_model_t * mesh_access_model_for_address_and_model_identifier(uint16_t element_address, uint32_t model_identifier, uint8_t * status); diff --git a/src/mesh/mesh_configuration_server.c b/src/mesh/mesh_configuration_server.c index 1e9c849dd..0f7eec491 100644 --- a/src/mesh/mesh_configuration_server.c +++ b/src/mesh/mesh_configuration_server.c @@ -266,7 +266,7 @@ void mesh_delete_subscriptions(void){ } static uint8_t mesh_model_add_subscription(mesh_model_t * mesh_model, uint16_t address){ - int i; + uint16_t i; for (i=0;isubscriptions[i] == address) return MESH_FOUNDATION_STATUS_SUCCESS; } @@ -280,7 +280,7 @@ static uint8_t mesh_model_add_subscription(mesh_model_t * mesh_model, uint16_t a } static void mesh_model_delete_subscription(mesh_model_t * mesh_model, uint16_t address){ - int i; + uint16_t i; for (i=0;isubscriptions[i] == address) { mesh_model->subscriptions[i] = MESH_ADDRESS_UNSASSIGNED; @@ -289,7 +289,7 @@ static void mesh_model_delete_subscription(mesh_model_t * mesh_model, uint16_t a } static void mesh_model_delete_all_subscriptions(mesh_model_t * mesh_model){ - int i; + uint16_t i; for (i=0;isubscriptions[i] = MESH_ADDRESS_UNSASSIGNED; } @@ -472,7 +472,7 @@ static void config_server_send_message(uint16_t netkey_index, uint16_t dest, mes mesh_access_send_unacknowledged_pdu(pdu); } -static void config_composition_data_status(mesh_model_t * mesh_model, uint16_t netkey_index, uint16_t dest){ +static void config_composition_data_status(uint16_t netkey_index, uint16_t dest){ printf("Received Config Composition Data Get -> send Config Composition Data Status\n"); @@ -493,10 +493,10 @@ static void config_composition_data_status(mesh_model_t * mesh_model, uint16_t n // Features - Relay, Proxy, Friend, Lower Power, ... mesh_access_transport_add_uint16(transport_pdu, 0); - mesh_element_iterator_t it; - mesh_element_iterator_init(&it); - while (mesh_element_iterator_has_next(&it)){ - mesh_element_t * element = mesh_element_iterator_next(&it); + mesh_element_iterator_t element_it; + mesh_element_iterator_init(&element_it); + while (mesh_element_iterator_has_next(&element_it)){ + mesh_element_t * element = mesh_element_iterator_next(&element_it); // Loc mesh_access_transport_add_uint16(transport_pdu, element->loc); @@ -505,19 +505,19 @@ static void config_composition_data_status(mesh_model_t * mesh_model, uint16_t n // NumV mesh_access_transport_add_uint8( transport_pdu, element->models_count_vendor); - mesh_model_iterator_t it; + mesh_model_iterator_t model_it; // SIG Models - mesh_model_iterator_init(&it, element); - while (mesh_model_iterator_has_next(&it)){ - mesh_model_t * model = mesh_model_iterator_next(&it); + mesh_model_iterator_init(&model_it, element); + while (mesh_model_iterator_has_next(&model_it)){ + mesh_model_t * model = mesh_model_iterator_next(&model_it); if (!mesh_model_is_bluetooth_sig(model->model_identifier)) continue; mesh_access_transport_add_uint16(transport_pdu, model->model_identifier); } // Vendor Models - mesh_model_iterator_init(&it, element); - while (mesh_model_iterator_has_next(&it)){ - mesh_model_t * model = mesh_model_iterator_next(&it); + mesh_model_iterator_init(&model_it, element); + while (mesh_model_iterator_has_next(&model_it)){ + mesh_model_t * model = mesh_model_iterator_next(&model_it); if (mesh_model_is_bluetooth_sig(model->model_identifier)) continue; mesh_access_transport_add_uint32(transport_pdu, model->model_identifier); } @@ -528,12 +528,14 @@ static void config_composition_data_status(mesh_model_t * mesh_model, uint16_t n } static void config_composition_data_get_handler(mesh_model_t *mesh_model, mesh_pdu_t * pdu){ - config_composition_data_status(mesh_model, mesh_pdu_netkey_index(pdu), mesh_pdu_src(pdu)); + UNUSED(mesh_model); + config_composition_data_status(mesh_pdu_netkey_index(pdu), mesh_pdu_src(pdu)); mesh_access_message_processed(pdu); } static void config_model_beacon_status(mesh_model_t * mesh_model, uint16_t netkey_index, uint16_t dest){ + UNUSED(mesh_model); // setup message mesh_transport_pdu_t * transport_pdu = mesh_access_setup_segmented_message(&mesh_foundation_config_beacon_status, mesh_foundation_beacon_get()); @@ -569,6 +571,7 @@ static void config_beacon_set_handler(mesh_model_t *mesh_model, mesh_pdu_t * pdu } static void config_model_default_ttl_status(mesh_model_t * mesh_model, uint16_t netkey_index, uint16_t dest){ + UNUSED(mesh_model); // setup message mesh_transport_pdu_t * transport_pdu = mesh_access_setup_segmented_message( &mesh_foundation_config_default_ttl_status, mesh_foundation_default_ttl_get()); @@ -603,6 +606,8 @@ static void config_default_ttl_set_handler(mesh_model_t *mesh_model, mesh_pdu_t } static void config_friend_status(mesh_model_t * mesh_model, uint16_t netkey_index, uint16_t dest){ + UNUSED(mesh_model); + // setup message mesh_transport_pdu_t * transport_pdu = mesh_access_setup_segmented_message( &mesh_foundation_config_friend_status, mesh_foundation_friend_get()); @@ -640,6 +645,7 @@ static void config_friend_set_handler(mesh_model_t *mesh_model, mesh_pdu_t * pdu } static void config_model_gatt_proxy_status(mesh_model_t * mesh_model, uint16_t netkey_index, uint16_t dest){ + UNUSED(mesh_model); // setup message mesh_transport_pdu_t * transport_pdu = mesh_access_setup_segmented_message( &mesh_foundation_config_gatt_proxy_status, mesh_foundation_gatt_proxy_get()); @@ -677,6 +683,8 @@ static void config_gatt_proxy_set_handler(mesh_model_t *mesh_model, mesh_pdu_t * } static void config_model_relay_status(mesh_model_t * mesh_model, uint16_t netkey_index, uint16_t dest){ + UNUSED(mesh_model); + // setup message mesh_transport_pdu_t * transport_pdu = mesh_access_setup_segmented_message(&mesh_foundation_config_relay_status, mesh_foundation_relay_get(), @@ -722,6 +730,8 @@ static void config_relay_set_handler(mesh_model_t *mesh_model, mesh_pdu_t * pdu) } static void config_model_network_transmit_status(mesh_model_t * mesh_model, uint16_t netkey_index, uint16_t dest){ + UNUSED(mesh_model); + // setup message mesh_transport_pdu_t * transport_pdu = mesh_access_setup_segmented_message( &mesh_foundation_config_network_transmit_status, mesh_foundation_network_transmit_get()); @@ -760,6 +770,8 @@ void config_nekey_list_set_max(uint16_t max){ } static void config_netkey_status(mesh_model_t * mesh_model, uint16_t netkey_index, uint16_t dest, uint8_t status, uint16_t new_netkey_index){ + UNUSED(mesh_model); + // setup message mesh_transport_pdu_t * transport_pdu = mesh_access_setup_segmented_message( &mesh_foundation_config_netkey_status, status, new_netkey_index); @@ -770,6 +782,8 @@ static void config_netkey_status(mesh_model_t * mesh_model, uint16_t netkey_inde } static void config_netkey_list(mesh_model_t * mesh_model, uint16_t netkey_index, uint16_t dest) { + UNUSED(mesh_model); + mesh_transport_pdu_t * transport_pdu = mesh_access_transport_init(MESH_FOUNDATION_OPERATION_NETKEY_LIST); if (!transport_pdu) return; @@ -984,6 +998,8 @@ static void config_netkey_get_handler(mesh_model_t * mesh_model, mesh_pdu_t * pd // AppKey List static void config_appkey_status(mesh_model_t * mesh_model, uint16_t netkey_index, uint16_t dest, uint32_t netkey_and_appkey_index, uint8_t status){ + UNUSED(mesh_model); + // setup message mesh_transport_pdu_t * transport_pdu = mesh_access_setup_segmented_message(&mesh_foundation_config_appkey_status, status, netkey_and_appkey_index); @@ -994,6 +1010,8 @@ static void config_appkey_status(mesh_model_t * mesh_model, uint16_t netkey_inde } static void config_appkey_list(mesh_model_t * mesh_model, uint16_t netkey_index, uint16_t dest, uint32_t netkey_index_of_list){ + UNUSED(mesh_model); + mesh_transport_pdu_t * transport_pdu = mesh_access_transport_init(MESH_FOUNDATION_OPERATION_APPKEY_LIST); if (!transport_pdu) return; @@ -1219,6 +1237,8 @@ static void config_appkey_get_handler(mesh_model_t *mesh_model, mesh_pdu_t * pdu // Configuration Model Subscriptions (messages) static void config_model_subscription_list_status(mesh_model_t * mesh_model, uint16_t netkey_index, uint16_t dest, uint8_t status, uint16_t element_address, uint32_t model_identifier, mesh_model_t * target_model){ + UNUSED(mesh_model); + uint16_t opcode; if (mesh_model_is_bluetooth_sig(model_identifier)){ opcode = MESH_FOUNDATION_OPERATION_SIG_MODEL_SUBSCRIPTION_LIST; @@ -1235,7 +1255,7 @@ static void config_model_subscription_list_status(mesh_model_t * mesh_model, uin mesh_access_transport_add_model_identifier(transport_pdu, model_identifier); if (target_model != NULL){ - int i; + uint16_t i; for (i = 0; i < MAX_NR_MESH_SUBSCRIPTION_PER_MODEL; i++){ if (target_model->subscriptions[i] == MESH_ADDRESS_UNSASSIGNED) continue; if (mesh_network_address_virtual(target_model->subscriptions[i])) continue; @@ -1260,6 +1280,8 @@ static void config_model_subscription_get_handler(mesh_model_t *mesh_model, mesh } static void config_model_subscription_status(mesh_model_t * mesh_model, uint16_t netkey_index, uint16_t dest, uint8_t status, uint16_t element_address, uint16_t address, uint32_t model_identifier){ + UNUSED(mesh_model); + // setup message mesh_transport_pdu_t * transport_pdu = mesh_access_setup_segmented_message(&mesh_foundation_config_model_subscription_status, status, element_address, address, model_identifier); @@ -1507,6 +1529,8 @@ static void config_model_subscription_delete_all_handler(mesh_model_t *mesh_mode // Configuration Model to AppKey List static void config_model_app_status(mesh_model_t * mesh_model, uint16_t netkey_index, uint16_t dest, uint8_t status, uint16_t element_address, uint16_t appkey_index, uint32_t model_identifier){ + UNUSED(mesh_model); + // setup message mesh_transport_pdu_t * transport_pdu = mesh_access_setup_segmented_message(&mesh_foundation_config_model_app_status, status, element_address, appkey_index, model_identifier); @@ -1517,6 +1541,8 @@ static void config_model_app_status(mesh_model_t * mesh_model, uint16_t netkey_i } static void config_model_app_list(mesh_model_t * config_server_model, uint16_t netkey_index, uint16_t dest, uint8_t status, uint16_t element_address, uint32_t model_identifier, mesh_model_t * mesh_model){ + UNUSED(config_server_model); + uint16_t opcode; if (mesh_model_is_bluetooth_sig(model_identifier)){ opcode = MESH_FOUNDATION_OPERATION_SIG_MODEL_APP_LIST; @@ -1536,7 +1562,7 @@ static void config_model_app_list(mesh_model_t * config_server_model, uint16_t n // add list of appkey indexes if (mesh_model){ - int i; + uint16_t i; for (i=0;iappkey_indices[i]; if (appkey_index == MESH_APPKEY_INVALID) continue; @@ -1610,7 +1636,7 @@ static void config_model_app_unbind_handler(mesh_model_t *config_server_model, m mesh_access_message_processed(pdu); } -static void config_model_app_get(mesh_model_t *config_server_model, mesh_pdu_t * pdu, int sig_model){ +static void config_model_app_get_handler(mesh_model_t *config_server_model, mesh_pdu_t * pdu){ mesh_access_parser_state_t parser; mesh_access_parser_init(&parser, (mesh_pdu_t*) pdu); @@ -1623,14 +1649,6 @@ static void config_model_app_get(mesh_model_t *config_server_model, mesh_pdu_t * mesh_access_message_processed(pdu); } -static void config_sig_model_app_get_handler(mesh_model_t *config_server_model, mesh_pdu_t * pdu) { - config_model_app_get(config_server_model, pdu, 1); -} - -static void config_vendor_model_app_get_handler(mesh_model_t *config_server_model, mesh_pdu_t * pdu) { - config_model_app_get(config_server_model, pdu, 0); -} - // Model Publication static void config_model_publication_changed(mesh_model_t *mesh_model, mesh_publication_model_t * new_publication_model){ @@ -1655,6 +1673,8 @@ static void config_model_publication_changed(mesh_model_t *mesh_model, mesh_publ static void config_model_publication_status(mesh_model_t *mesh_model, uint16_t netkey_index, uint16_t dest, uint8_t status, uint16_t element_address, uint32_t model_identifier, mesh_publication_model_t *publication_model) { + UNUSED(mesh_model); + // setup message uint16_t app_key_index_and_credential_flag = (publication_model->friendship_credential_flag << 12) | publication_model->appkey_index; mesh_transport_pdu_t * transport_pdu = mesh_access_setup_segmented_message( @@ -1892,6 +1912,7 @@ static void config_heartbeat_publication_timeout_handler(btstack_timer_source_t } static void config_heartbeat_publication_status(mesh_model_t *mesh_model, uint16_t netkey_index, uint16_t dest, uint8_t status, mesh_heartbeat_publication_t * mesh_heartbeat_publication){ + UNUSED(mesh_model); // setup message uint8_t count_log = heartbeat_count_log(mesh_heartbeat_publication->count); @@ -1978,6 +1999,7 @@ static void config_heartbeat_publication_get_handler(mesh_model_t *mesh_model, m // Heartbeat Subscription static void config_heartbeat_subscription_status(mesh_model_t *mesh_model, uint16_t netkey_index, uint16_t dest, uint8_t status, mesh_heartbeat_subscription_t * mesh_heartbeat_subscription){ + UNUSED(mesh_model); // setup message uint8_t count_log = heartbeat_count_log(mesh_heartbeat_subscription->count_log); @@ -2068,11 +2090,13 @@ static void config_heartbeat_subscription_get_handler(mesh_model_t *mesh_model, static void config_key_refresh_phase_status(mesh_model_t *mesh_model, uint16_t netkey_index_dest, uint16_t dest, uint8_t status, uint16_t netkey_index, mesh_key_refresh_state_t key_refresh_state){ + UNUSED(mesh_model); + // setup message mesh_transport_pdu_t * transport_pdu = mesh_access_setup_segmented_message( &mesh_key_refresh_phase_status, status, - netkey_index_dest, + netkey_index, key_refresh_state); if (!transport_pdu) return; @@ -2145,6 +2169,8 @@ static void config_key_refresh_phase_set_handler(mesh_model_t *mesh_model, mesh_ static void config_node_reset_status(mesh_model_t *mesh_model, uint16_t netkey_index, uint16_t dest){ + UNUSED(mesh_model); + // setup message mesh_transport_pdu_t * transport_pdu = mesh_access_setup_segmented_message(&mesh_foundation_node_reset_status); if (!transport_pdu) return; @@ -2160,6 +2186,8 @@ static void config_node_reset_handler(mesh_model_t *mesh_model, mesh_pdu_t * pdu } static void low_power_node_poll_timeout_status(mesh_model_t *mesh_model, uint16_t netkey_index_dest, uint16_t dest, uint8_t status){ + UNUSED(mesh_model); + mesh_transport_pdu_t * transport_pdu = mesh_access_setup_segmented_message( &mesh_foundation_low_power_node_poll_timeout_status, status, @@ -2181,11 +2209,13 @@ static void config_low_power_node_poll_timeout_get_handler(mesh_model_t *mesh_mo static void config_node_identity_status(mesh_model_t *mesh_model, uint16_t netkey_index_dest, uint16_t dest, uint8_t status, uint16_t netkey_index, mesh_node_identity_state_t node_identity_state){ + UNUSED(mesh_model); + // setup message mesh_transport_pdu_t * transport_pdu = mesh_access_setup_segmented_message( &mesh_foundation_node_identity_status, status, - netkey_index_dest, + netkey_index, node_identity_state); if (!transport_pdu) return; @@ -2250,8 +2280,8 @@ const static mesh_operation_t mesh_configuration_server_model_operations[] = { { MESH_FOUNDATION_OPERATION_MODEL_SUBSCRIPTION_DELETE_ALL, 4, config_model_subscription_delete_all_handler }, { MESH_FOUNDATION_OPERATION_SIG_MODEL_SUBSCRIPTION_GET, 4, config_model_subscription_get_handler }, { MESH_FOUNDATION_OPERATION_VENDOR_MODEL_SUBSCRIPTION_GET, 6, config_model_subscription_get_handler }, - { MESH_FOUNDATION_OPERATION_SIG_MODEL_APP_GET, 4, config_sig_model_app_get_handler }, - { MESH_FOUNDATION_OPERATION_VENDOR_MODEL_APP_GET, 6, config_vendor_model_app_get_handler }, + { MESH_FOUNDATION_OPERATION_SIG_MODEL_APP_GET, 4, config_model_app_get_handler }, + { MESH_FOUNDATION_OPERATION_VENDOR_MODEL_APP_GET, 6, config_model_app_get_handler }, { MESH_FOUNDATION_OPERATION_MODEL_PUBLICATION_SET, 11, config_model_publication_set_handler }, { MESH_FOUNDATION_OPERATION_MODEL_PUBLICATION_VIRTUAL_ADDRESS_SET, 25, config_model_publication_virtual_address_set_handler }, { MESH_FOUNDATION_OPERATION_MODEL_PUBLICATION_GET, 4, config_model_publication_get_handler }, diff --git a/src/mesh/mesh_crypto.c b/src/mesh/mesh_crypto.c index 9af71abb6..92d294acf 100644 --- a/src/mesh/mesh_crypto.c +++ b/src/mesh/mesh_crypto.c @@ -197,6 +197,7 @@ static uint16_t * mesh_virtual_address_hash; static uint8_t mesh_virtual_address_temp[16]; static void mesh_virtual_address_temp_callback(void * arg){ + UNUSED(arg); uint16_t addr = (big_endian_read_16(mesh_virtual_address_temp, 14) & 0x3fff) | 0x8000; *mesh_virtual_address_hash = addr; (*mesh_virtual_address_callback)(mesh_virtual_address_arg); @@ -228,6 +229,7 @@ static const uint8_t id128_tag[] = { 'i', 'd', '1', '2', '8', 0x01}; static uint8_t k2_result[33]; static void mesh_network_key_derive_network_id_calculated(void * arg) { + UNUSED(arg); // done (*mesh_network_key_derive_callback)(mesh_network_key_derive_arg); } diff --git a/src/mesh/mesh_network.c b/src/mesh/mesh_network.c index a7572080b..176f11216 100644 --- a/src/mesh/mesh_network.c +++ b/src/mesh/mesh_network.c @@ -685,6 +685,7 @@ static void mesh_network_run(void){ #ifdef ENABLE_MESH_ADV_BEARER static void mesh_adv_bearer_handle_network_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ + UNUSED(channel); mesh_network_pdu_t * network_pdu; switch (packet_type){ @@ -751,6 +752,7 @@ static void mesh_network_gatt_bearer_outgoing_complete(void){ } static void mesh_network_gatt_bearer_handle_network_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ + UNUSED(channel); switch (packet_type){ case MESH_PROXY_DATA_PACKET: if (mesh_foundation_gatt_proxy_get() == 0) break; @@ -799,6 +801,7 @@ static void mesh_network_gatt_bearer_handle_network_event(uint8_t packet_type, u #ifdef ENABLE_MESH_GATT_BEARER static void mesh_netework_gatt_bearer_handle_proxy_configuration(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ + UNUSED(channel); switch (packet_type){ case MESH_PROXY_DATA_PACKET: mesh_network_process_proxy_configuration_message(packet, size); diff --git a/src/mesh/mesh_upper_transport.c b/src/mesh/mesh_upper_transport.c index 1c971b457..b17a53438 100644 --- a/src/mesh/mesh_upper_transport.c +++ b/src/mesh/mesh_upper_transport.c @@ -147,7 +147,7 @@ static void (*mesh_control_message_handler)(mesh_pdu_t * pdu); static btstack_linked_list_t upper_transport_incoming; -void mesh_upper_unsegmented_control_message_received(mesh_network_pdu_t * network_pdu){ +static void mesh_upper_unsegmented_control_message_received(mesh_network_pdu_t * network_pdu){ uint8_t * lower_transport_pdu = mesh_network_pdu_data(network_pdu); uint8_t opcode = lower_transport_pdu[0]; if (mesh_control_message_handler){ @@ -486,7 +486,7 @@ static void mesh_upper_transport_process_message(mesh_transport_pdu_t * transpor mesh_upper_transport_validate_segmented_message(transport_pdu); } -void mesh_upper_transport_message_received(mesh_pdu_t * pdu){ +static void mesh_upper_transport_message_received(mesh_pdu_t * pdu){ btstack_linked_list_add_tail(&upper_transport_incoming, (btstack_linked_item_t*) pdu); mesh_transport_run(); } @@ -508,7 +508,7 @@ void mesh_upper_transport_pdu_free(mesh_pdu_t * pdu){ } } -void mesh_upper_transport_pdu_handler(mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu){ +static void mesh_upper_transport_pdu_handler(mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu){ switch (callback_type){ case MESH_TRANSPORT_PDU_RECEIVED: mesh_upper_transport_message_received(pdu); diff --git a/src/mesh/pb_adv.c b/src/mesh/pb_adv.c index 6ce7c32ba..bddb6b4b7 100644 --- a/src/mesh/pb_adv.c +++ b/src/mesh/pb_adv.c @@ -141,16 +141,16 @@ static void pb_adv_emit_pdu_sent(uint8_t status){ pb_adv_packet_handler(HCI_EVENT_PACKET, 0, event, sizeof(event)); } -static void pb_adv_emit_link_open(uint8_t status, uint16_t pb_adv_cid){ +static void pb_adv_emit_link_open(uint8_t status, uint16_t the_pb_adv_cid){ uint8_t event[7] = { HCI_EVENT_MESH_META, 5, MESH_SUBEVENT_PB_TRANSPORT_LINK_OPEN, status}; - little_endian_store_16(event, 4, pb_adv_cid); + little_endian_store_16(event, 4, the_pb_adv_cid); event[6] = PB_TYPE_ADV; pb_adv_packet_handler(HCI_EVENT_PACKET, 0, event, sizeof(event)); } -static void pb_adv_emit_link_close(uint16_t pb_adv_cid, uint8_t reason){ +static void pb_adv_emit_link_close(uint16_t the_pb_adv_cid, uint8_t reason){ uint8_t event[5] = { HCI_EVENT_MESH_META, 3, MESH_SUBEVENT_PB_TRANSPORT_LINK_CLOSED}; - little_endian_store_16(event, 4, pb_adv_cid); + little_endian_store_16(event, 4, the_pb_adv_cid); pb_adv_packet_handler(HCI_EVENT_PACKET, 0, event, sizeof(event)); } @@ -370,6 +370,7 @@ static int pb_adv_packet_to_send(void){ } static void pb_adv_timer_handler(btstack_timer_source_t * ts){ + UNUSED(ts); pb_adv_random_delay_active = 0; if (!pb_adv_packet_to_send()) return; adv_bearer_request_can_send_now_for_provisioning_pdu(); @@ -389,6 +390,8 @@ static void pb_adv_run(void){ } static void pb_adv_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ + UNUSED(channel); + if (packet_type != HCI_EVENT_PACKET) return; const uint8_t * data; uint8_t length; @@ -565,8 +568,8 @@ void pb_adv_register_packet_handler(btstack_packet_handler_t packet_handler){ pb_adv_packet_handler = packet_handler; } -void pb_adv_send_pdu(uint16_t pb_adv_cid, const uint8_t * pdu, uint16_t size){ - UNUSED(pb_adv_cid); +void pb_adv_send_pdu(uint16_t the_pb_adv_cid, const uint8_t * pdu, uint16_t size){ + UNUSED(the_pb_adv_cid); printf("PB-ADV: Send packet "); printf_hexdump(pdu, size); pb_adv_msg_out_buffer = pdu; @@ -579,14 +582,14 @@ void pb_adv_send_pdu(uint16_t pb_adv_cid, const uint8_t * pdu, uint16_t size){ /** * Close Link - * @param pb_adv_cid + * @param the_pb_adv_cid */ -void pb_adv_close_link(uint16_t pb_adv_cid, uint8_t reason){ +void pb_adv_close_link(uint16_t the_pb_adv_cid, uint8_t reason){ switch (link_state){ case LINK_STATE_W4_ACK: case LINK_STATE_OPEN: case LINK_STATE_W2_SEND_ACK: - pb_adv_emit_link_close(pb_adv_cid, 0); + pb_adv_emit_link_close(the_pb_adv_cid, 0); link_state = LINK_STATE_CLOSING; pb_adv_link_close_countdown = 3; pb_adv_link_close_reason = reason; diff --git a/src/mesh/pb_gatt.c b/src/mesh/pb_gatt.c index a0d0c489e..29aa158ac 100644 --- a/src/mesh/pb_gatt.c +++ b/src/mesh/pb_gatt.c @@ -80,8 +80,8 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe UNUSED(size); mesh_msg_sar_field_t msg_sar_field; mesh_msg_type_t msg_type; - int pdu_segment_len; - int pos; + uint16_t pdu_segment_len; + uint16_t pos; hci_con_handle_t con_handle; switch (packet_type) { @@ -223,6 +223,8 @@ void pb_gatt_send_pdu(uint16_t con_handle, const uint8_t * pdu, uint16_t size){ * @param reason 0 = success, 1 = timeout, 2 = fail */ void pb_gatt_close_link(hci_con_handle_t con_handle, uint8_t reason){ + UNUSED(con_handle); + UNUSED(reason); } /** @@ -231,5 +233,6 @@ void pb_gatt_close_link(hci_con_handle_t con_handle, uint8_t reason){ * @returns con_handle or HCI_CON_HANDLE_INVALID */ uint16_t pb_gatt_create_link(const uint8_t * device_uuid){ + UNUSED(device_uuid); return HCI_CON_HANDLE_INVALID; } diff --git a/src/mesh/provisioning_device.c b/src/mesh/provisioning_device.c index 86240a36a..3ec6ca8f9 100644 --- a/src/mesh/provisioning_device.c +++ b/src/mesh/provisioning_device.c @@ -339,6 +339,7 @@ static void provisioning_done(void){ } static void provisioning_handle_auth_value_output_oob(void * arg){ + UNUSED(arg); // limit auth value to single digit auth_value[15] = auth_value[15] % 9 + 1; @@ -564,7 +565,6 @@ static void provisioning_handle_public_key(uint8_t *packet, uint16_t size){ } static void provisioning_handle_confirmation_device_calculated(void * arg){ - UNUSED(arg); printf("ConfirmationDevice: "); @@ -575,6 +575,8 @@ static void provisioning_handle_confirmation_device_calculated(void * arg){ } static void provisioning_handle_confirmation_random_device(void * arg){ + UNUSED(arg); + // re-use prov_confirmation_inputs buffer memcpy(&prov_confirmation_inputs[0], random_device, 16); memcpy(&prov_confirmation_inputs[16], auth_value, 16); @@ -584,6 +586,8 @@ static void provisioning_handle_confirmation_random_device(void * arg){ } static void provisioning_handle_confirmation_k1_calculated(void * arg){ + UNUSED(arg); + printf("ConfirmationKey: "); printf_hexdump(confirmation_key, sizeof(confirmation_key)); @@ -606,7 +610,6 @@ static void provisioning_handle_confirmation_s1_calculated(void * arg){ } static void provisioning_handle_confirmation(uint8_t *packet, uint16_t size){ - UNUSED(size); UNUSED(packet); @@ -680,6 +683,8 @@ static void provisioning_handle_random(uint8_t *packet, uint16_t size){ // PROV_DATA static void provisioning_handle_network_dervived(void * arg){ + UNUSED(arg); + provisioning_timer_stop(); // notify client @@ -691,6 +696,8 @@ static void provisioning_handle_network_dervived(void * arg){ } static void provisioning_handle_data_device_key(void * arg){ + UNUSED(arg); + // derive full network key mesh_network_key_derive(&prov_cmac_request, network_key, &provisioning_handle_network_dervived, NULL); } @@ -732,11 +739,13 @@ static void provisioning_handle_data(uint8_t *packet, uint16_t size){ } static void provisioning_handle_unexpected_pdu(uint8_t *packet, uint16_t size){ + UNUSED(size); printf("Unexpected PDU #%u in state #%u\n", packet[0], (int) device_state); provisioning_handle_provisioning_error(0x03); } static void provisioning_handle_pdu(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ + UNUSED(channel); if (size < 1) return; @@ -905,10 +914,10 @@ mesh_network_key_t * provisioning_device_data_get_network_key(void){ return network_key; } -void provisioning_device_data_get(mesh_provisioning_data_t * provisioning_data){ - provisioning_data->unicast_address = unicast_address; - provisioning_data->iv_index = iv_index; - provisioning_data->flags = flags; - memcpy(provisioning_data->device_key, device_key, 16); - provisioning_data->network_key = network_key; +void provisioning_device_data_get(mesh_provisioning_data_t * the_provisioning_data){ + the_provisioning_data->unicast_address = unicast_address; + the_provisioning_data->iv_index = iv_index; + the_provisioning_data->flags = flags; + memcpy(the_provisioning_data->device_key, device_key, 16); + the_provisioning_data->network_key = network_key; } diff --git a/src/mesh/provisioning_provisioner.c b/src/mesh/provisioning_provisioner.c index 225a64f1d..bba7feae5 100644 --- a/src/mesh/provisioning_provisioner.c +++ b/src/mesh/provisioning_provisioner.c @@ -142,18 +142,18 @@ static void provisioning_attention_timer_set(void){ } #endif -static void provisioning_emit_output_oob_event(uint16_t pb_adv_cid, uint32_t number){ +static void provisioning_emit_output_oob_event(uint16_t the_pb_adv_cid, uint32_t number){ if (!prov_packet_handler) return; uint8_t event[9] = { HCI_EVENT_MESH_META, 7, MESH_SUBEVENT_PB_PROV_START_EMIT_OUTPUT_OOB}; - little_endian_store_16(event, 3, pb_adv_cid); + little_endian_store_16(event, 3, the_pb_adv_cid); little_endian_store_16(event, 5, number); prov_packet_handler(HCI_EVENT_PACKET, 0, event, sizeof(event)); } -static void provisioning_emit_event(uint8_t mesh_subevent, uint16_t pb_adv_cid){ +static void provisioning_emit_event(uint8_t mesh_subevent, uint16_t the_pb_adv_cid){ if (!prov_packet_handler) return; uint8_t event[5] = { HCI_EVENT_MESH_META, 3, mesh_subevent}; - little_endian_store_16(event, 3, pb_adv_cid); + little_endian_store_16(event, 3, the_pb_adv_cid); prov_packet_handler(HCI_EVENT_PACKET, 0, event, sizeof(event)); } @@ -179,57 +179,57 @@ static void provisioning_timer_stop(void){ // Outgoing Provisioning PDUs -static void provisioning_send_invite(uint16_t pb_adv_cid){ +static void provisioning_send_invite(uint16_t the_pb_adv_cid){ prov_buffer_out[0] = MESH_PROV_INVITE; prov_buffer_out[1] = prov_attention_timer; - pb_adv_send_pdu(pb_adv_cid, prov_buffer_out, 2); + pb_adv_send_pdu(the_pb_adv_cid, prov_buffer_out, 2); // collect confirmation_inputs memcpy(&prov_confirmation_inputs[0], &prov_buffer_out[1], 1); } -static void provisioning_send_start(uint16_t pb_adv_cid){ +static void provisioning_send_start(uint16_t the_pb_adv_cid){ prov_buffer_out[0] = MESH_PROV_START; prov_buffer_out[1] = prov_start_algorithm; prov_buffer_out[2] = prov_start_public_key_used; prov_buffer_out[3] = prov_start_authentication_method; prov_buffer_out[4] = prov_start_authentication_action; prov_buffer_out[5] = prov_start_authentication_size; - pb_adv_send_pdu(pb_adv_cid, prov_buffer_out, 6); + pb_adv_send_pdu(the_pb_adv_cid, prov_buffer_out, 6); // store for confirmation inputs: len 5 memcpy(&prov_confirmation_inputs[12], &prov_buffer_out[1], 5); } -static void provisioning_send_provisioning_error(void){ +static void provisioning_send_provisioning_error(uint16_t the_pb_adv_cid){ prov_buffer_out[0] = MESH_PROV_FAILED; prov_buffer_out[1] = prov_error_code; - pb_adv_send_pdu(pb_adv_cid, prov_buffer_out, 2); + pb_adv_send_pdu(the_pb_adv_cid, prov_buffer_out, 2); } -static void provisioning_send_public_key(void){ +static void provisioning_send_public_key(uint16_t the_pb_adv_cid){ prov_buffer_out[0] = MESH_PROV_PUB_KEY; memcpy(&prov_buffer_out[1], prov_ec_q, 64); - pb_adv_send_pdu(pb_adv_cid, prov_buffer_out, 65); + pb_adv_send_pdu(the_pb_adv_cid, prov_buffer_out, 65); // store for confirmation inputs: len 64 memcpy(&prov_confirmation_inputs[17], &prov_buffer_out[1], 64); } -static void provisioning_send_confirm(void){ +static void provisioning_send_confirm(uint16_t the_pb_adv_cid){ prov_buffer_out[0] = MESH_PROV_CONFIRM; memcpy(&prov_buffer_out[1], confirmation_provisioner, 16); - pb_adv_send_pdu(pb_adv_cid, prov_buffer_out, 17); + pb_adv_send_pdu(the_pb_adv_cid, prov_buffer_out, 17); } -static void provisioning_send_random(void){ +static void provisioning_send_random(uint16_t the_pb_adv_cid){ prov_buffer_out[0] = MESH_PROV_RANDOM; memcpy(&prov_buffer_out[1], random_provisioner, 16); - pb_adv_send_pdu(pb_adv_cid, prov_buffer_out, 17); + pb_adv_send_pdu(the_pb_adv_cid, prov_buffer_out, 17); } -static void provisioning_send_data(void){ +static void provisioning_send_data(uint16_t the_pb_adv_cid){ prov_buffer_out[0] = MESH_PROV_DATA; memcpy(&prov_buffer_out[1], enc_provisioning_data, 25); memcpy(&prov_buffer_out[26], provisioning_data_mic, 8); - pb_adv_send_pdu(pb_adv_cid, prov_buffer_out, 34); + pb_adv_send_pdu(the_pb_adv_cid, prov_buffer_out, 34); } typedef enum { @@ -261,7 +261,7 @@ static void provisioning_run(void){ switch (provisioner_state){ case PROVISIONER_SEND_ERROR: start_timer = 0; // game over - provisioning_send_provisioning_error(); + provisioning_send_provisioning_error(pb_adv_cid); break; case PROVISIONER_SEND_INVITE: provisioning_send_invite(pb_adv_cid); @@ -281,7 +281,7 @@ static void provisioning_run(void){ provisioning_emit_event(MESH_SUBEVENT_PB_PROV_START_RECEIVE_PUBLIC_KEY_OOB, 1); break; case PROVISIONER_SEND_PUB_KEY: - provisioning_send_public_key(); + provisioning_send_public_key(pb_adv_cid); if (prov_start_public_key_used){ provisioning_public_key_ready(); } else { @@ -289,15 +289,15 @@ static void provisioning_run(void){ } break; case PROVISIONER_SEND_CONFIRM: - provisioning_send_confirm(); + provisioning_send_confirm(pb_adv_cid); provisioner_state = PROVISIONER_W4_CONFIRM; break; case PROVISIONER_SEND_RANDOM: - provisioning_send_random(); + provisioning_send_random(pb_adv_cid); provisioner_state = PROVISIONER_W4_RANDOM; break; case PROVISIONER_SEND_DATA: - provisioning_send_data(); + provisioning_send_data(pb_adv_cid); provisioner_state = PROVISIONER_W4_COMPLETE; break; default: @@ -331,11 +331,12 @@ static void provisioning_handle_provisioning_error(uint8_t error_code){ provisioning_run(); } -static void provisioning_handle_link_opened(uint16_t pb_adv_cid){ +static void provisioning_handle_link_opened(uint16_t the_pb_adv_cid){ + UNUSED(the_pb_adv_cid); provisioner_state = PROVISIONER_SEND_INVITE; } -static void provisioning_handle_capabilities(uint16_t pb_adv_cid, const uint8_t * packet_data, uint16_t packet_len){ +static void provisioning_handle_capabilities(uint16_t the_pb_adv_cid, const uint8_t * packet_data, uint16_t packet_len){ if (packet_len != 11) return; @@ -346,7 +347,7 @@ static void provisioning_handle_capabilities(uint16_t pb_adv_cid, const uint8_t // notify client and wait for auth method selection uint8_t event[16] = { HCI_EVENT_MESH_META, 3, MESH_SUBEVENT_PB_PROV_CAPABILITIES}; - little_endian_store_16(event, 3, pb_adv_cid); + little_endian_store_16(event, 3, the_pb_adv_cid); event[5] = packet_data[0]; little_endian_store_16(event, 6, big_endian_read_16(packet_data, 1)); event[8] = packet_data[3]; @@ -369,6 +370,8 @@ static void provisioning_handle_confirmation_provisioner_calculated(void * arg){ } static void provisioning_handle_random_provisioner(void * arg){ + UNUSED(arg); + printf("RandomProvisioner: "); printf_hexdump(random_provisioner, sizeof(random_provisioner)); @@ -381,6 +384,8 @@ static void provisioning_handle_random_provisioner(void * arg){ } static void provisioning_handle_confirmation_k1_calculated(void * arg){ + UNUSED(arg); + printf("ConfirmationKey: "); printf_hexdump(confirmation_key, sizeof(confirmation_key)); @@ -409,6 +414,7 @@ static void provisioning_handle_auth_value_ready(void){ } static void provisioning_handle_auth_value_input_oob(void * arg){ + UNUSED(arg); // limit auth value to single digit auth_value[15] = auth_value[15] % 9 + 1; @@ -430,7 +436,8 @@ static void provisioning_handle_auth_value_input_oob(void * arg){ provisioner_state = PROVISIONER_W4_INPUT_COMPLETE; } -static void provisioning_handle_input_complete(uint16_t pb_adv_cid){ +static void provisioning_handle_input_complete(uint16_t the_pb_adv_cid){ + UNUSED(the_pb_adv_cid); provisioning_handle_auth_value_ready(); } @@ -493,14 +500,13 @@ static void provisioning_public_key_ready(void){ btstack_crypto_ecc_p256_calculate_dhkey(&prov_ecc_p256_request, remote_ec_q, dhkey, provisioning_handle_public_key_dhkey, NULL); } -static void provisioning_handle_public_key(uint16_t pb_adv_cid, const uint8_t *packet_data, uint16_t packet_len){ - +static void provisioning_handle_public_key(uint16_t the_pb_adv_cid, const uint8_t *packet_data, uint16_t packet_len){ // validate public key if (packet_len != sizeof(remote_ec_q) || btstack_crypto_ecc_p256_validate_public_key(packet_data) != 0){ printf("Public Key invalid, abort provisioning\n"); // disconnect provisioning link - pb_adv_close_link(pb_adv_cid, 0x02); // reason: fail + pb_adv_close_link(the_pb_adv_cid, 0x02); // reason: fail provisioning_timer_stop(); return; } @@ -526,8 +532,9 @@ static void provisioning_handle_public_key(uint16_t pb_adv_cid, const uint8_t *p provisioning_public_key_ready(); } -static void provisioning_handle_confirmation(uint16_t pb_adv_cid, const uint8_t *packet_data, uint16_t packet_len){ +static void provisioning_handle_confirmation(uint16_t the_pb_adv_cid, const uint8_t *packet_data, uint16_t packet_len){ + UNUSED(the_pb_adv_cid); UNUSED(packet_data); UNUSED(packet_len); @@ -610,9 +617,9 @@ static void provisioning_handle_provisioning_salt_calculated(void * arg){ mesh_k1(&prov_cmac_request, dhkey, sizeof(dhkey), provisioning_salt, (const uint8_t*) "prsk", 4, session_key, &provisioning_handle_session_key_calculated, NULL); } -static void provisioning_handle_random(uint16_t pb_adv_cid, const uint8_t *packet_data, uint16_t packet_len){ +static void provisioning_handle_random(uint16_t the_pb_adv_cid, const uint8_t *packet_data, uint16_t packet_len){ - UNUSED(packet_data); + UNUSED(the_pb_adv_cid); UNUSED(packet_len); // TODO: validate Confirmation @@ -624,10 +631,12 @@ static void provisioning_handle_random(uint16_t pb_adv_cid, const uint8_t *packe btstack_crypto_aes128_cmac_zero(&prov_cmac_request, 48, prov_confirmation_inputs, provisioning_salt, &provisioning_handle_provisioning_salt_calculated, NULL); } -static void provisioning_handle_complete(uint16_t pb_adv_cid){ +static void provisioning_handle_complete(uint16_t the_pb_adv_cid){ + UNUSED(the_pb_adv_cid); } static void provisioning_handle_pdu(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ + UNUSED(channel); if (size < 1) return; @@ -731,13 +740,14 @@ uint16_t provisioning_provisioner_start_provisioning(const uint8_t * device_uuid return pb_adv_cid; } -void provisioning_provisioner_set_static_oob(uint16_t pb_adv_cid, uint16_t static_oob_len, const uint8_t * static_oob_data){ - UNUSED(pb_adv_cid); +void provisioning_provisioner_set_static_oob(uint16_t the_pb_adv_cid, uint16_t static_oob_len, const uint8_t * static_oob_data){ + UNUSED(the_pb_adv_cid); prov_static_oob_data = static_oob_data; prov_static_oob_len = btstack_min(static_oob_len, 16); } -uint8_t provisioning_provisioner_select_authentication_method(uint16_t pb_adv_cid, uint8_t algorithm, uint8_t public_key_used, uint8_t authentication_method, uint8_t authentication_action, uint8_t authentication_size){ +uint8_t provisioning_provisioner_select_authentication_method(uint16_t the_pb_adv_cid, uint8_t algorithm, uint8_t public_key_used, uint8_t authentication_method, uint8_t authentication_action, uint8_t authentication_size){ + UNUSED(the_pb_adv_cid); if (provisioner_state != PROVISIONER_W4_AUTH_CONFIGURATION) return ERROR_CODE_COMMAND_DISALLOWED; @@ -751,7 +761,8 @@ uint8_t provisioning_provisioner_select_authentication_method(uint16_t pb_adv_ci return ERROR_CODE_SUCCESS; } -uint8_t provisioning_provisioner_public_key_oob_received(uint16_t pb_adv_cid, const uint8_t * public_key){ +uint8_t provisioning_provisioner_public_key_oob_received(uint16_t the_pb_adv_cid, const uint8_t * public_key){ + UNUSED(the_pb_adv_cid); if (provisioner_state != PROVISIONER_W4_PUB_KEY_OOB) return ERROR_CODE_COMMAND_DISALLOWED; @@ -768,8 +779,8 @@ uint8_t provisioning_provisioner_public_key_oob_received(uint16_t pb_adv_cid, co return ERROR_CODE_SUCCESS; } -void provisioning_provisioner_input_oob_complete_numeric(uint16_t pb_adv_cid, uint32_t input_oob){ - UNUSED(pb_adv_cid); +void provisioning_provisioner_input_oob_complete_numeric(uint16_t the_pb_adv_cid, uint32_t input_oob){ + UNUSED(the_pb_adv_cid); if (provisioner_state != PROVISIONER_W4_INPUT_OOK) return; // store input_oob as auth value @@ -777,8 +788,8 @@ void provisioning_provisioner_input_oob_complete_numeric(uint16_t pb_adv_cid, ui provisioning_handle_auth_value_ready(); } -void provisioning_provisioner_input_oob_complete_alphanumeric(uint16_t pb_adv_cid, const uint8_t * input_oob_data, uint16_t input_oob_len){ - UNUSED(pb_adv_cid); +void provisioning_provisioner_input_oob_complete_alphanumeric(uint16_t the_pb_adv_cid, const uint8_t * input_oob_data, uint16_t input_oob_len){ + UNUSED(the_pb_adv_cid); if (provisioner_state != PROVISIONER_W4_INPUT_OOK) return; // store input_oob and fillup with zeros