mirror/btstack
1
0
Fork 0
mirror of https://github.com/bluekitchen/btstack.git synced 2025-02-08 00:40:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

add missing default switch cases

Browse Source
This commit is contained in:
Milanka Ringwald 2020-10-27 13:44:18 +01:00
parent 24fd61d9d3
commit 7bbeb3ad8c
51 changed files with 639 additions and 465 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
3rd-party/bluedroid/decoder/srce/bitalloc.c vendored
View File

@ -48,6 +48,8 @@ OI_UINT32 OI_SBC_MaxBitpool(OI_CODEC_SBC_FRAME_INFO *frame)
case SBC_STEREO:
case SBC_JOINT_STEREO:
return 32 * frame->nrof_subbands;
default:
break;
}
ERROR(("Invalid frame mode %d", frame->mode));

2
3rd-party/yxml/yxml.c vendored
View File

@ -1057,6 +1057,8 @@ yxml_ret_t yxml_parse(yxml_t *x, int _ch) {
return YXML_OK;
}
break;
default:
break;
}
return YXML_ESYN;
}

3
chipset/em9301/btstack_chipset_em9301.c
View File

@ -270,6 +270,9 @@ static btstack_chipset_result_t chipset_next_command(uint8_t * hci_cmd_buffer){
upload_state = UPLOAD_IDLE;
}
return BTSTACK_CHIPSET_VALID_COMMAND;
default:
btstack_assert(false);
break;
}
return BTSTACK_CHIPSET_DONE;
}

3
example/a2dp_source_demo.c
View File

@ -612,6 +612,9 @@ static void a2dp_source_packet_handler(uint8_t packet_type, uint16_t channel, ui
sbc_configuration.channel_mode = 0;
sbc_configuration.num_channels = 1;
break;
default:
btstack_assert(false);
break;
}
dump_sbc_configuration(&sbc_configuration);

22
example/ancs_client_demo.c
View File

@ -91,17 +91,17 @@ static void app_packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *
UNUSED(channel);
UNUSED(size);
switch (packet_type) {
case HCI_EVENT_PACKET:
switch (hci_event_packet_get_type(packet)) {
case SM_EVENT_JUST_WORKS_REQUEST:
sm_just_works_confirm(sm_event_just_works_request_get_handle(packet));
printf("Just Works Confirmed.\n");
break;
case SM_EVENT_PASSKEY_DISPLAY_NUMBER:
printf("Passkey display: %"PRIu32"\n", sm_event_passkey_display_number_get_passkey(packet));
break;
}
if (packet_type != HCI_EVENT_PACKET) return;
switch (hci_event_packet_get_type(packet)) {
case SM_EVENT_JUST_WORKS_REQUEST:
sm_just_works_confirm(sm_event_just_works_request_get_handle(packet));
printf("Just Works Confirmed.\n");
break;
case SM_EVENT_PASSKEY_DISPLAY_NUMBER:
printf("Passkey display: %"PRIu32"\n", sm_event_passkey_display_number_get_passkey(packet));
break;
default:
break;
}
}

21
example/gatt_counter.c
View File

@ -203,19 +203,20 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
UNUSED(channel);
UNUSED(size);
switch (packet_type) {
case HCI_EVENT_PACKET:
switch (hci_event_packet_get_type(packet)) {
case HCI_EVENT_DISCONNECTION_COMPLETE:
le_notification_enabled = 0;
break;
case ATT_EVENT_CAN_SEND_NOW:
att_server_notify(con_handle, ATT_CHARACTERISTIC_0000FF11_0000_1000_8000_00805F9B34FB_01_VALUE_HANDLE, (uint8_t*) counter_string, counter_string_len);
break;
}
if (packet_type != HCI_EVENT_PACKET) return;
switch (hci_event_packet_get_type(packet)) {
case HCI_EVENT_DISCONNECTION_COMPLETE:
le_notification_enabled = 0;
break;
case ATT_EVENT_CAN_SEND_NOW:
att_server_notify(con_handle, ATT_CHARACTERISTIC_0000FF11_0000_1000_8000_00805F9B34FB_01_VALUE_HANDLE, (uint8_t*) counter_string, counter_string_len);
break;
default:
break;
}
}
/* LISTING_END */
/*

71
example/gatt_streamer_server.c
View File

@ -238,46 +238,47 @@ static void hci_packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *
uint16_t conn_interval;
hci_con_handle_t con_handle;
switch (packet_type) {
case HCI_EVENT_PACKET:
switch (hci_event_packet_get_type(packet)) {
case BTSTACK_EVENT_STATE:
// BTstack activated, get started
if (btstack_event_state_get_state(packet) == HCI_STATE_WORKING) {
printf("To start the streaming, please run the le_streamer_client example on other device, or use some GATT Explorer, e.g. LightBlue, BLExplr.\n");
}
break;
case HCI_EVENT_DISCONNECTION_COMPLETE:
con_handle = hci_event_disconnection_complete_get_connection_handle(packet);
printf("- LE Connection %04x: disconnect, reason %02x\n", con_handle, hci_event_disconnection_complete_get_reason(packet));
break;
case HCI_EVENT_LE_META:
switch (hci_event_le_meta_get_subevent_code(packet)) {
case HCI_SUBEVENT_LE_CONNECTION_COMPLETE:
// print connection parameters (without using float operations)
con_handle = hci_subevent_le_connection_complete_get_connection_handle(packet);
conn_interval = hci_subevent_le_connection_complete_get_conn_interval(packet);
printf("- LE Connection %04x: connected - connection interval %u.%02u ms, latency %u\n", con_handle, conn_interval * 125 / 100,
25 * (conn_interval & 3), hci_subevent_le_connection_complete_get_conn_latency(packet));
// request min con interval 15 ms for iOS 11+
printf("- LE Connection %04x: request 15 ms connection interval\n", con_handle);
gap_request_connection_parameter_update(con_handle, 12, 12, 0, 0x0048);
break;
case HCI_SUBEVENT_LE_CONNECTION_UPDATE_COMPLETE:
// print connection parameters (without using float operations)
con_handle = hci_subevent_le_connection_update_complete_get_connection_handle(packet);
conn_interval = hci_subevent_le_connection_update_complete_get_conn_interval(packet);
printf("- LE Connection %04x: connection update - connection interval %u.%02u ms, latency %u\n", con_handle, conn_interval * 125 / 100,
25 * (conn_interval & 3), hci_subevent_le_connection_update_complete_get_conn_latency(packet));
break;
default:
break;
}
if (packet_type != HCI_EVENT_PACKET) return;
switch (hci_event_packet_get_type(packet)) {
case BTSTACK_EVENT_STATE:
// BTstack activated, get started
if (btstack_event_state_get_state(packet) == HCI_STATE_WORKING) {
printf("To start the streaming, please run the le_streamer_client example on other device, or use some GATT Explorer, e.g. LightBlue, BLExplr.\n");
}
break;
case HCI_EVENT_DISCONNECTION_COMPLETE:
con_handle = hci_event_disconnection_complete_get_connection_handle(packet);
printf("- LE Connection %04x: disconnect, reason %02x\n", con_handle, hci_event_disconnection_complete_get_reason(packet));
break;
case HCI_EVENT_LE_META:
switch (hci_event_le_meta_get_subevent_code(packet)) {
case HCI_SUBEVENT_LE_CONNECTION_COMPLETE:
// print connection parameters (without using float operations)
con_handle = hci_subevent_le_connection_complete_get_connection_handle(packet);
conn_interval = hci_subevent_le_connection_complete_get_conn_interval(packet);
printf("- LE Connection %04x: connected - connection interval %u.%02u ms, latency %u\n", con_handle, conn_interval * 125 / 100,
25 * (conn_interval & 3), hci_subevent_le_connection_complete_get_conn_latency(packet));
// request min con interval 15 ms for iOS 11+
printf("- LE Connection %04x: request 15 ms connection interval\n", con_handle);
gap_request_connection_parameter_update(con_handle, 12, 12, 0, 0x0048);
break;
case HCI_SUBEVENT_LE_CONNECTION_UPDATE_COMPLETE:
// print connection parameters (without using float operations)
con_handle = hci_subevent_le_connection_update_complete_get_connection_handle(packet);
conn_interval = hci_subevent_le_connection_update_complete_get_conn_interval(packet);
printf("- LE Connection %04x: connection update - connection interval %u.%02u ms, latency %u\n", con_handle, conn_interval * 125 / 100,
25 * (conn_interval & 3), hci_subevent_le_connection_update_complete_get_conn_latency(packet));
break;
default:
break;
}
break;
default:
break;
}
}

3
example/hfp_ag_demo.c
View File

@ -127,6 +127,9 @@ static void dump_supported_codecs(void){
mSBC_skipped = 1;
}
break;
default:
btstack_assert(false);
break;
}
}
printf("\n");

3
example/hfp_hf_demo.c
View File

@ -106,6 +106,9 @@ static void dump_supported_codecs(void){
mSBC_skipped = 1;
}
break;
default:
btstack_assert(false);
break;
}
}
printf("\n");

3
example/hid_host_demo.c
View File

@ -280,6 +280,9 @@ static void handle_sdp_client_query_result(uint8_t packet_type, uint16_t channel
printf("Connecting to HID Control failed: 0x%02x\n", status);
}
break;
default:
break;
}
}

3
example/hid_keyboard_demo.c
View File

@ -257,6 +257,9 @@ static void stdin_process(char character){
printf("Connecting to %s...\n", bd_addr_to_str(device_addr));
hid_device_connect(device_addr, &hid_cid);
break;
default:
btstack_assert(false);
break;
}
}
#else

80
example/hog_keyboard_demo.c
View File

@ -403,49 +403,51 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
UNUSED(channel);
UNUSED(size);
switch (packet_type) {
case HCI_EVENT_PACKET:
switch (hci_event_packet_get_type(packet)) {
case HCI_EVENT_DISCONNECTION_COMPLETE:
con_handle = HCI_CON_HANDLE_INVALID;
printf("Disconnected\n");
break;
case SM_EVENT_JUST_WORKS_REQUEST:
printf("Just Works requested\n");
sm_just_works_confirm(sm_event_just_works_request_get_handle(packet));
break;
case SM_EVENT_NUMERIC_COMPARISON_REQUEST:
printf("Confirming numeric comparison: %"PRIu32"\n", sm_event_numeric_comparison_request_get_passkey(packet));
sm_numeric_comparison_confirm(sm_event_passkey_display_number_get_handle(packet));
break;
case SM_EVENT_PASSKEY_DISPLAY_NUMBER:
printf("Display Passkey: %"PRIu32"\n", sm_event_passkey_display_number_get_passkey(packet));
break;
case HCI_EVENT_HIDS_META:
switch (hci_event_hids_meta_get_subevent_code(packet)){
case HIDS_SUBEVENT_INPUT_REPORT_ENABLE:
con_handle = hids_subevent_input_report_enable_get_con_handle(packet);
printf("Report Characteristic Subscribed %u\n", hids_subevent_input_report_enable_get_enable(packet));
if (packet_type != HCI_EVENT_PACKET) return;
switch (hci_event_packet_get_type(packet)) {
case HCI_EVENT_DISCONNECTION_COMPLETE:
con_handle = HCI_CON_HANDLE_INVALID;
printf("Disconnected\n");
break;
case SM_EVENT_JUST_WORKS_REQUEST:
printf("Just Works requested\n");
sm_just_works_confirm(sm_event_just_works_request_get_handle(packet));
break;
case SM_EVENT_NUMERIC_COMPARISON_REQUEST:
printf("Confirming numeric comparison: %"PRIu32"\n", sm_event_numeric_comparison_request_get_passkey(packet));
sm_numeric_comparison_confirm(sm_event_passkey_display_number_get_handle(packet));
break;
case SM_EVENT_PASSKEY_DISPLAY_NUMBER:
printf("Display Passkey: %"PRIu32"\n", sm_event_passkey_display_number_get_passkey(packet));
break;
case HCI_EVENT_HIDS_META:
switch (hci_event_hids_meta_get_subevent_code(packet)){
case HIDS_SUBEVENT_INPUT_REPORT_ENABLE:
con_handle = hids_subevent_input_report_enable_get_con_handle(packet);
printf("Report Characteristic Subscribed %u\n", hids_subevent_input_report_enable_get_enable(packet));
#ifndef HAVE_BTSTACK_STDIN
hid_embedded_start_typing();
hid_embedded_start_typing();
#endif
break;
case HIDS_SUBEVENT_BOOT_KEYBOARD_INPUT_REPORT_ENABLE:
con_handle = hids_subevent_boot_keyboard_input_report_enable_get_con_handle(packet);
printf("Boot Keyboard Characteristic Subscribed %u\n", hids_subevent_boot_keyboard_input_report_enable_get_enable(packet));
break;
case HIDS_SUBEVENT_PROTOCOL_MODE:
protocol_mode = hids_subevent_protocol_mode_get_protocol_mode(packet);
printf("Protocol Mode: %s mode\n", hids_subevent_protocol_mode_get_protocol_mode(packet) ? "Report" : "Boot");
break;
case HIDS_SUBEVENT_CAN_SEND_NOW:
typing_can_send_now();
break;
default:
break;
}
break;
case HIDS_SUBEVENT_BOOT_KEYBOARD_INPUT_REPORT_ENABLE:
con_handle = hids_subevent_boot_keyboard_input_report_enable_get_con_handle(packet);
printf("Boot Keyboard Characteristic Subscribed %u\n", hids_subevent_boot_keyboard_input_report_enable_get_enable(packet));
break;
case HIDS_SUBEVENT_PROTOCOL_MODE:
protocol_mode = hids_subevent_protocol_mode_get_protocol_mode(packet);
printf("Protocol Mode: %s mode\n", hids_subevent_protocol_mode_get_protocol_mode(packet) ? "Report" : "Boot");
break;
case HIDS_SUBEVENT_CAN_SEND_NOW:
typing_can_send_now();
break;
default:
break;
}
break;
default:
break;
}
}

148
example/hog_mouse_demo.c
View File

@ -309,81 +309,83 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
UNUSED(size);
uint16_t conn_interval;
switch (packet_type) {
case HCI_EVENT_PACKET:
switch (hci_event_packet_get_type(packet)) {
case HCI_EVENT_DISCONNECTION_COMPLETE:
con_handle = HCI_CON_HANDLE_INVALID;
printf("Disconnected\n");
break;
case SM_EVENT_JUST_WORKS_REQUEST:
printf("Just Works requested\n");
sm_just_works_confirm(sm_event_just_works_request_get_handle(packet));
break;
case SM_EVENT_NUMERIC_COMPARISON_REQUEST:
printf("Confirming numeric comparison: %"PRIu32"\n", sm_event_numeric_comparison_request_get_passkey(packet));
sm_numeric_comparison_confirm(sm_event_passkey_display_number_get_handle(packet));
break;
case SM_EVENT_PASSKEY_DISPLAY_NUMBER:
printf("Display Passkey: %"PRIu32"\n", sm_event_passkey_display_number_get_passkey(packet));
break;
case L2CAP_EVENT_CONNECTION_PARAMETER_UPDATE_RESPONSE:
printf("L2CAP Connection Parameter Update Complete, response: %x\n", l2cap_event_connection_parameter_update_response_get_result(packet));
break;
case HCI_EVENT_LE_META:
switch (hci_event_le_meta_get_subevent_code(packet)) {
case HCI_SUBEVENT_LE_CONNECTION_COMPLETE:
// print connection parameters (without using float operations)
conn_interval = hci_subevent_le_connection_complete_get_conn_interval(packet);
printf("LE Connection Complete:\n");
printf("- Connection Interval: %u.%02u ms\n", conn_interval * 125 / 100, 25 * (conn_interval & 3));
printf("- Connection Latency: %u\n", hci_subevent_le_connection_complete_get_conn_latency(packet));
break;
case HCI_SUBEVENT_LE_CONNECTION_UPDATE_COMPLETE:
// print connection parameters (without using float operations)
conn_interval = hci_subevent_le_connection_update_complete_get_conn_interval(packet);
printf("LE Connection Update:\n");
printf("- Connection Interval: %u.%02u ms\n", conn_interval * 125 / 100, 25 * (conn_interval & 3));
printf("- Connection Latency: %u\n", hci_subevent_le_connection_update_complete_get_conn_latency(packet));
break;
default:
break;
}
break;
case HCI_EVENT_HIDS_META:
switch (hci_event_hids_meta_get_subevent_code(packet)){
case HIDS_SUBEVENT_INPUT_REPORT_ENABLE:
con_handle = hids_subevent_input_report_enable_get_con_handle(packet);
printf("Report Characteristic Subscribed %u\n", hids_subevent_input_report_enable_get_enable(packet));
#ifndef HAVE_BTSTACK_STDIN
hid_embedded_start_mousing();
#endif
// request connection param update via L2CAP following Apple Bluetooth Design Guidelines
// gap_request_connection_parameter_update(con_handle, 12, 12, 4, 100); // 15 ms, 4, 1s
if (packet_type != HCI_EVENT_PACKET) return;
// directly update connection params via HCI following Apple Bluetooth Design Guidelines
// gap_update_connection_parameters(con_handle, 12, 12, 4, 100); // 60-75 ms, 4, 1s
break;
case HIDS_SUBEVENT_BOOT_KEYBOARD_INPUT_REPORT_ENABLE:
con_handle = hids_subevent_boot_keyboard_input_report_enable_get_con_handle(packet);
printf("Boot Keyboard Characteristic Subscribed %u\n", hids_subevent_boot_keyboard_input_report_enable_get_enable(packet));
break;
case HIDS_SUBEVENT_BOOT_MOUSE_INPUT_REPORT_ENABLE:
con_handle = hids_subevent_boot_mouse_input_report_enable_get_con_handle(packet);
printf("Boot Mouse Characteristic Subscribed %u\n", hids_subevent_boot_mouse_input_report_enable_get_enable(packet));
break;
case HIDS_SUBEVENT_PROTOCOL_MODE:
protocol_mode = hids_subevent_protocol_mode_get_protocol_mode(packet);
printf("Protocol Mode: %s mode\n", hids_subevent_protocol_mode_get_protocol_mode(packet) ? "Report" : "Boot");
break;
case HIDS_SUBEVENT_CAN_SEND_NOW:
mousing_can_send_now();
break;
default:
break;
}
switch (hci_event_packet_get_type(packet)) {
case HCI_EVENT_DISCONNECTION_COMPLETE:
con_handle = HCI_CON_HANDLE_INVALID;
printf("Disconnected\n");
break;
case SM_EVENT_JUST_WORKS_REQUEST:
printf("Just Works requested\n");
sm_just_works_confirm(sm_event_just_works_request_get_handle(packet));
break;
case SM_EVENT_NUMERIC_COMPARISON_REQUEST:
printf("Confirming numeric comparison: %"PRIu32"\n", sm_event_numeric_comparison_request_get_passkey(packet));
sm_numeric_comparison_confirm(sm_event_passkey_display_number_get_handle(packet));
break;
case SM_EVENT_PASSKEY_DISPLAY_NUMBER:
printf("Display Passkey: %"PRIu32"\n", sm_event_passkey_display_number_get_passkey(packet));
break;
case L2CAP_EVENT_CONNECTION_PARAMETER_UPDATE_RESPONSE:
printf("L2CAP Connection Parameter Update Complete, response: %x\n", l2cap_event_connection_parameter_update_response_get_result(packet));
break;
case HCI_EVENT_LE_META:
switch (hci_event_le_meta_get_subevent_code(packet)) {
case HCI_SUBEVENT_LE_CONNECTION_COMPLETE:
// print connection parameters (without using float operations)
conn_interval = hci_subevent_le_connection_complete_get_conn_interval(packet);
printf("LE Connection Complete:\n");
printf("- Connection Interval: %u.%02u ms\n", conn_interval * 125 / 100, 25 * (conn_interval & 3));
printf("- Connection Latency: %u\n", hci_subevent_le_connection_complete_get_conn_latency(packet));
break;
case HCI_SUBEVENT_LE_CONNECTION_UPDATE_COMPLETE:
// print connection parameters (without using float operations)
conn_interval = hci_subevent_le_connection_update_complete_get_conn_interval(packet);
printf("LE Connection Update:\n");
printf("- Connection Interval: %u.%02u ms\n", conn_interval * 125 / 100, 25 * (conn_interval & 3));
printf("- Connection Latency: %u\n", hci_subevent_le_connection_update_complete_get_conn_latency(packet));
break;
default:
break;
}
break;
case HCI_EVENT_HIDS_META:
switch (hci_event_hids_meta_get_subevent_code(packet)){
case HIDS_SUBEVENT_INPUT_REPORT_ENABLE:
con_handle = hids_subevent_input_report_enable_get_con_handle(packet);
printf("Report Characteristic Subscribed %u\n", hids_subevent_input_report_enable_get_enable(packet));
#ifndef HAVE_BTSTACK_STDIN
hid_embedded_start_mousing();
#endif
// request connection param update via L2CAP following Apple Bluetooth Design Guidelines
// gap_request_connection_parameter_update(con_handle, 12, 12, 4, 100); // 15 ms, 4, 1s
// directly update connection params via HCI following Apple Bluetooth Design Guidelines
// gap_update_connection_parameters(con_handle, 12, 12, 4, 100); // 60-75 ms, 4, 1s
break;
case HIDS_SUBEVENT_BOOT_KEYBOARD_INPUT_REPORT_ENABLE:
con_handle = hids_subevent_boot_keyboard_input_report_enable_get_con_handle(packet);
printf("Boot Keyboard Characteristic Subscribed %u\n", hids_subevent_boot_keyboard_input_report_enable_get_enable(packet));
break;
case HIDS_SUBEVENT_BOOT_MOUSE_INPUT_REPORT_ENABLE:
con_handle = hids_subevent_boot_mouse_input_report_enable_get_con_handle(packet);
printf("Boot Mouse Characteristic Subscribed %u\n", hids_subevent_boot_mouse_input_report_enable_get_enable(packet));
break;
case HIDS_SUBEVENT_PROTOCOL_MODE:
protocol_mode = hids_subevent_protocol_mode_get_protocol_mode(packet);
printf("Protocol Mode: %s mode\n", hids_subevent_protocol_mode_get_protocol_mode(packet) ? "Report" : "Boot");
break;
case HIDS_SUBEVENT_CAN_SEND_NOW:
mousing_can_send_now();
break;
default:
break;
}
break;
default:
break;
}
}

2
example/le_data_channel_server.c
View File

@ -250,6 +250,8 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
printf("%c: Connection Interval: %u.%02u ms\n", le_data_channel_connection.name, conn_interval * 125 / 100, 25 * (conn_interval & 3));
printf("%c: Connection Latency: %u\n", le_data_channel_connection.name, hci_subevent_le_connection_update_complete_get_conn_latency(packet));
break;
default:
break;
}
break;

26
example/mesh_node_demo.c
View File

@ -66,20 +66,20 @@ static btstack_packet_callback_registration_t hci_event_callback_registration;
static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
UNUSED(channel);
UNUSED(size);
if (packet_type != HCI_EVENT_PACKET) return;
bd_addr_t addr;
switch (packet_type) {
case HCI_EVENT_PACKET:
switch (hci_event_packet_get_type(packet)) {
case BTSTACK_EVENT_STATE:
if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) break;
// setup gap name
gap_local_bd_addr(addr);
strcpy(gap_name_buffer, gap_name_prefix);
strcat(gap_name_buffer, bd_addr_to_str(addr));
break;
default:
break;
}
switch (hci_event_packet_get_type(packet)) {
case BTSTACK_EVENT_STATE:
if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) break;
// setup gap name
gap_local_bd_addr(addr);
strcpy(gap_name_buffer, gap_name_prefix);
strcat(gap_name_buffer, bd_addr_to_str(addr));
break;
default:
break;
}
}

16
example/nordic_spp_le_counter.c
View File

@ -146,15 +146,13 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
UNUSED(channel);
UNUSED(size);
switch (packet_type) {
case HCI_EVENT_PACKET:
switch (hci_event_packet_get_type(packet)) {
case HCI_EVENT_DISCONNECTION_COMPLETE:
con_handle = HCI_CON_HANDLE_INVALID;
break;
default:
break;
}
if (packet_type != HCI_EVENT_PACKET) return;
switch (hci_event_packet_get_type(packet)) {
case HCI_EVENT_DISCONNECTION_COMPLETE:
con_handle = HCI_CON_HANDLE_INVALID;
break;
default:
break;
}
}

121
example/nordic_spp_le_streamer.c
View File

@ -170,42 +170,41 @@ static void hci_packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *
uint16_t conn_interval;
hci_con_handle_t con_handle;
switch (packet_type) {
case HCI_EVENT_PACKET:
switch (hci_event_packet_get_type(packet)) {
case BTSTACK_EVENT_STATE:
// BTstack activated, get started
if (btstack_event_state_get_state(packet) == HCI_STATE_WORKING) {
printf("To start the streaming, please run nRF Toolbox -> UART to connect.\n");
}
break;
case HCI_EVENT_LE_META:
switch (hci_event_le_meta_get_subevent_code(packet)) {
case HCI_SUBEVENT_LE_CONNECTION_COMPLETE:
// print connection parameters (without using float operations)
con_handle = hci_subevent_le_connection_complete_get_connection_handle(packet);
conn_interval = hci_subevent_le_connection_complete_get_conn_interval(packet);
printf("LE Connection - Connection Interval: %u.%02u ms\n", conn_interval * 125 / 100, 25 * (conn_interval & 3));
printf("LE Connection - Connection Latency: %u\n", hci_subevent_le_connection_complete_get_conn_latency(packet));
if (packet_type != HCI_EVENT_PACKET) return;
// request min con interval 15 ms for iOS 11+
printf("LE Connection - Request 15 ms connection interval\n");
gap_request_connection_parameter_update(con_handle, 12, 12, 0, 0x0048);
break;
case HCI_SUBEVENT_LE_CONNECTION_UPDATE_COMPLETE:
// print connection parameters (without using float operations)
con_handle = hci_subevent_le_connection_update_complete_get_connection_handle(packet);
conn_interval = hci_subevent_le_connection_update_complete_get_conn_interval(packet);
printf("LE Connection - Connection Param update - connection interval %u.%02u ms, latency %u\n", conn_interval * 125 / 100,
25 * (conn_interval & 3), hci_subevent_le_connection_update_complete_get_conn_latency(packet));
break;
default:
break;
}
break;
switch (hci_event_packet_get_type(packet)) {
case BTSTACK_EVENT_STATE:
// BTstack activated, get started
if (btstack_event_state_get_state(packet) == HCI_STATE_WORKING) {
printf("To start the streaming, please run nRF Toolbox -> UART to connect.\n");
}
break;
case HCI_EVENT_LE_META:
switch (hci_event_le_meta_get_subevent_code(packet)) {
case HCI_SUBEVENT_LE_CONNECTION_COMPLETE:
// print connection parameters (without using float operations)
con_handle = hci_subevent_le_connection_complete_get_connection_handle(packet);
conn_interval = hci_subevent_le_connection_complete_get_conn_interval(packet);
printf("LE Connection - Connection Interval: %u.%02u ms\n", conn_interval * 125 / 100, 25 * (conn_interval & 3));
printf("LE Connection - Connection Latency: %u\n", hci_subevent_le_connection_complete_get_conn_latency(packet));
// request min con interval 15 ms for iOS 11+
printf("LE Connection - Request 15 ms connection interval\n");
gap_request_connection_parameter_update(con_handle, 12, 12, 0, 0x0048);
break;
case HCI_SUBEVENT_LE_CONNECTION_UPDATE_COMPLETE:
// print connection parameters (without using float operations)
con_handle = hci_subevent_le_connection_update_complete_get_connection_handle(packet);
conn_interval = hci_subevent_le_connection_update_complete_get_conn_interval(packet);
printf("LE Connection - Connection Param update - connection interval %u.%02u ms, latency %u\n", conn_interval * 125 / 100,
25 * (conn_interval & 3), hci_subevent_le_connection_update_complete_get_conn_latency(packet));
break;
default:
break;
}
break;
default:
break;
}
}
/* LISTING_END */
@ -221,37 +220,37 @@ static void att_packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *
UNUSED(channel);
UNUSED(size);
if (packet_type != HCI_EVENT_PACKET) return;
int mtu;
nordic_spp_le_streamer_connection_t * context;
switch (packet_type) {
case HCI_EVENT_PACKET:
switch (hci_event_packet_get_type(packet)) {
case ATT_EVENT_CONNECTED:
// setup new
context = connection_for_conn_handle(HCI_CON_HANDLE_INVALID);
if (!context) break;
context->counter = 'A';
context->test_data_len = ATT_DEFAULT_MTU - 4; // -1 for nordic 0x01 packet type
context->connection_handle = att_event_connected_get_handle(packet);
break;
case ATT_EVENT_MTU_EXCHANGE_COMPLETE:
mtu = att_event_mtu_exchange_complete_get_MTU(packet) - 3;
context = connection_for_conn_handle(att_event_mtu_exchange_complete_get_handle(packet));
if (!context) break;
context->test_data_len = btstack_min(mtu - 3, sizeof(context->test_data));
printf("%c: ATT MTU = %u => use test data of len %u\n", context->name, mtu, context->test_data_len);
break;
case ATT_EVENT_DISCONNECTED:
context = connection_for_conn_handle(att_event_disconnected_get_handle(packet));
if (!context) break;
// free connection
printf("%c: Disconnect\n", context->name);
context->le_notification_enabled = 0;
context->connection_handle = HCI_CON_HANDLE_INVALID;
break;
default:
break;
}
switch (hci_event_packet_get_type(packet)) {
case ATT_EVENT_CONNECTED:
// setup new
context = connection_for_conn_handle(HCI_CON_HANDLE_INVALID);
if (!context) break;
context->counter = 'A';
context->test_data_len = ATT_DEFAULT_MTU - 4; // -1 for nordic 0x01 packet type
context->connection_handle = att_event_connected_get_handle(packet);
break;
case ATT_EVENT_MTU_EXCHANGE_COMPLETE:
mtu = att_event_mtu_exchange_complete_get_MTU(packet) - 3;
context = connection_for_conn_handle(att_event_mtu_exchange_complete_get_handle(packet));
if (!context) break;
context->test_data_len = btstack_min(mtu - 3, sizeof(context->test_data));
printf("%c: ATT MTU = %u => use test data of len %u\n", context->name, mtu, context->test_data_len);
break;
case ATT_EVENT_DISCONNECTED:
context = connection_for_conn_handle(att_event_disconnected_get_handle(packet));
if (!context) break;
// free connection
printf("%c: Disconnect\n", context->name);
context->le_notification_enabled = 0;
context->connection_handle = HCI_CON_HANDLE_INVALID;
break;
default:
break;
}
}
/* LISTING_END */

2
example/sdp_bnep_query.c
View File

@ -259,6 +259,8 @@ static void handle_sdp_client_query_result(uint8_t packet_type, uint16_t channel
}
printf("SDP query done.\n");
break;
default:
break;
}
/* LISTING_RESUME */
}

4
example/sdp_general_query.c
View File

@ -150,7 +150,7 @@ static void handle_sdp_client_query_result(uint8_t packet_type, uint16_t channel
UNUSED(channel);
UNUSED(size);
switch (packet[0]){
switch (hci_event_packet_get_type(packet)){
case SDP_EVENT_QUERY_ATTRIBUTE_VALUE:
// handle new record
if (sdp_event_query_attribute_byte_get_record_id(packet) != record_id){
@ -173,6 +173,8 @@ static void handle_sdp_client_query_result(uint8_t packet_type, uint16_t channel
}
printf("SDP query done.\n");
break;
default:
break;
}
}
/* LISTING_END */

4
example/sdp_rfcomm_query.c
View File

@ -132,7 +132,7 @@ static void handle_query_rfcomm_event(uint8_t packet_type, uint16_t channel, uin
UNUSED(channel);
UNUSED(size);
switch (packet[0]){
switch (hci_event_packet_get_type(packet)){
case SDP_EVENT_QUERY_RFCOMM_SERVICE:
store_found_service(sdp_event_query_rfcomm_service_get_name(packet),
sdp_event_query_rfcomm_service_get_rfcomm_channel(packet));
@ -145,6 +145,8 @@ static void handle_query_rfcomm_event(uint8_t packet_type, uint16_t channel, uin
printf("SDP query done.\n");
report_found_services();
break;
default:
break;
}
}

114
example/sm_pairing_peripheral.c
View File

@ -166,70 +166,68 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
UNUSED(channel);
UNUSED(size);
if (packet_type != HCI_EVENT_PACKET) return;
hci_con_handle_t con_handle;
bd_addr_t addr;
switch (packet_type) {
case HCI_EVENT_PACKET:
switch (hci_event_packet_get_type(packet)) {
case HCI_EVENT_LE_META:
switch (hci_event_le_meta_get_subevent_code(packet)) {
case HCI_SUBEVENT_LE_CONNECTION_COMPLETE:
printf("Connection complete\n");
// Uncomment the next lines to trigger explicit pairing on connect
// con_handle = hci_subevent_le_connection_complete_get_connection_handle(packet);
// sm_send_security_request(con_handle);
UNUSED(con_handle);
break;
default:
break;
}
break;
case SM_EVENT_JUST_WORKS_REQUEST:
printf("Just Works requested\n");
sm_just_works_confirm(sm_event_just_works_request_get_handle(packet));
break;
case SM_EVENT_NUMERIC_COMPARISON_REQUEST:
printf("Confirming numeric comparison: %"PRIu32"\n", sm_event_numeric_comparison_request_get_passkey(packet));
sm_numeric_comparison_confirm(sm_event_passkey_display_number_get_handle(packet));
break;
case SM_EVENT_PASSKEY_DISPLAY_NUMBER:
printf("Display Passkey: %"PRIu32"\n", sm_event_passkey_display_number_get_passkey(packet));
break;
case SM_EVENT_IDENTITY_CREATED:
sm_event_identity_created_get_identity_address(packet, addr);
printf("Identity created: type %u address %s\n", sm_event_identity_created_get_identity_addr_type(packet), bd_addr_to_str(addr));
break;
case SM_EVENT_IDENTITY_RESOLVING_SUCCEEDED:
sm_event_identity_resolving_succeeded_get_identity_address(packet, addr);
printf("Identity resolved: type %u address %s\n", sm_event_identity_resolving_succeeded_get_identity_addr_type(packet), bd_addr_to_str(addr));
break;
case SM_EVENT_IDENTITY_RESOLVING_FAILED:
sm_event_identity_created_get_address(packet, addr);
printf("Identity resolving failed\n");
break;
case SM_EVENT_PAIRING_COMPLETE:
switch (sm_event_pairing_complete_get_status(packet)){
case ERROR_CODE_SUCCESS:
printf("Pairing complete, success\n");
break;
case ERROR_CODE_CONNECTION_TIMEOUT:
printf("Pairing failed, timeout\n");
break;
case ERROR_CODE_REMOTE_USER_TERMINATED_CONNECTION:
printf("Pairing failed, disconnected\n");
break;
case ERROR_CODE_AUTHENTICATION_FAILURE:
printf("Pairing failed, reason = %u\n", sm_event_pairing_complete_get_reason(packet));
break;
default:
break;
}
switch (hci_event_packet_get_type(packet)) {
case HCI_EVENT_LE_META:
switch (hci_event_le_meta_get_subevent_code(packet)) {
case HCI_SUBEVENT_LE_CONNECTION_COMPLETE:
printf("Connection complete\n");
// Uncomment the next lines to trigger explicit pairing on connect
// con_handle = hci_subevent_le_connection_complete_get_connection_handle(packet);
// sm_send_security_request(con_handle);
UNUSED(con_handle);
break;
default:
break;
}
break;
}
break;
case SM_EVENT_JUST_WORKS_REQUEST:
printf("Just Works requested\n");
sm_just_works_confirm(sm_event_just_works_request_get_handle(packet));
break;
case SM_EVENT_NUMERIC_COMPARISON_REQUEST:
printf("Confirming numeric comparison: %"PRIu32"\n", sm_event_numeric_comparison_request_get_passkey(packet));
sm_numeric_comparison_confirm(sm_event_passkey_display_number_get_handle(packet));
break;
case SM_EVENT_PASSKEY_DISPLAY_NUMBER:
printf("Display Passkey: %"PRIu32"\n", sm_event_passkey_display_number_get_passkey(packet));
break;
case SM_EVENT_IDENTITY_CREATED:
sm_event_identity_created_get_identity_address(packet, addr);
printf("Identity created: type %u address %s\n", sm_event_identity_created_get_identity_addr_type(packet), bd_addr_to_str(addr));
break;
case SM_EVENT_IDENTITY_RESOLVING_SUCCEEDED:
sm_event_identity_resolving_succeeded_get_identity_address(packet, addr);
printf("Identity resolved: type %u address %s\n", sm_event_identity_resolving_succeeded_get_identity_addr_type(packet), bd_addr_to_str(addr));
break;
case SM_EVENT_IDENTITY_RESOLVING_FAILED:
sm_event_identity_created_get_address(packet, addr);
printf("Identity resolving failed\n");
break;
case SM_EVENT_PAIRING_COMPLETE:
switch (sm_event_pairing_complete_get_status(packet)){
case ERROR_CODE_SUCCESS:
printf("Pairing complete, success\n");
break;
case ERROR_CODE_CONNECTION_TIMEOUT:
printf("Pairing failed, timeout\n");
break;
case ERROR_CODE_REMOTE_USER_TERMINATED_CONNECTION:
printf("Pairing failed, disconnected\n");
break;
case ERROR_CODE_AUTHENTICATION_FAILURE:
printf("Pairing failed, reason = %u\n", sm_event_pairing_complete_get_reason(packet));
break;
default:
break;
}
break;
default:
break;
}
}
/* LISTING_END */

46
example/spp_and_gatt_streamer.c
View File

@ -362,31 +362,33 @@ static void att_packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *
UNUSED(channel);
UNUSED(size);
switch (packet_type) {
case HCI_EVENT_PACKET:
switch (hci_event_packet_get_type(packet)) {
case ATT_EVENT_CONNECTED:
le_connection_handle = att_event_connected_get_handle(packet);
att_mtu = att_server_get_mtu(le_connection_handle);
le_test_data_len = btstack_min(att_server_get_mtu(le_connection_handle) - 3, sizeof(test_data));
printf("ATT MTU = %u\n", att_mtu);
break;
if (packet_type != HCI_EVENT_PACKET) return;
case ATT_EVENT_MTU_EXCHANGE_COMPLETE:
att_mtu = att_event_mtu_exchange_complete_get_MTU(packet);
le_test_data_len = btstack_min(att_mtu - 3, sizeof(test_data));
printf("ATT MTU = %u\n", att_mtu);
break;
switch (hci_event_packet_get_type(packet)) {
case ATT_EVENT_CONNECTED:
le_connection_handle = att_event_connected_get_handle(packet);
att_mtu = att_server_get_mtu(le_connection_handle);
le_test_data_len = btstack_min(att_server_get_mtu(le_connection_handle) - 3, sizeof(test_data));
printf("ATT MTU = %u\n", att_mtu);
break;
case ATT_EVENT_CAN_SEND_NOW:
le_streamer();
break;
case ATT_EVENT_MTU_EXCHANGE_COMPLETE:
att_mtu = att_event_mtu_exchange_complete_get_MTU(packet);
le_test_data_len = btstack_min(att_mtu - 3, sizeof(test_data));
printf("ATT MTU = %u\n", att_mtu);
break;
case ATT_EVENT_DISCONNECTED:
le_notification_enabled = 0;
le_connection_handle = HCI_CON_HANDLE_INVALID;
break;
}
case ATT_EVENT_CAN_SEND_NOW:
le_streamer();
break;
case ATT_EVENT_DISCONNECTED:
le_notification_enabled = 0;
le_connection_handle = HCI_CON_HANDLE_INVALID;
break;
default:
break;
}
}

4
example/spp_streamer_client.c
View File

@ -205,7 +205,7 @@ static void handle_query_rfcomm_event(uint8_t packet_type, uint16_t channel, uin
UNUSED(channel);
UNUSED(size);
switch (packet[0]){
switch (hci_event_packet_get_type(packet)){
case SDP_EVENT_QUERY_RFCOMM_SERVICE:
rfcomm_server_channel = sdp_event_query_rfcomm_service_get_rfcomm_channel(packet);
break;
@ -221,6 +221,8 @@ static void handle_query_rfcomm_event(uint8_t packet_type, uint16_t channel, uin
printf("SDP query done, channel %u.\n", rfcomm_server_channel);
rfcomm_create_channel(packet_handler, peer_addr, rfcomm_server_channel, NULL);
break;
default:
break;
}
}

2
example/ublox_spp_le_counter.c
View File

@ -165,6 +165,8 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
break;
}
break;
default:
break;
}
}
/* LISTING_END */

3
src/ble/ancs_client.c
View File

@ -172,6 +172,9 @@ static void ancs_chunk_parser_handle_byte(uint8_t data){
ancs_bytes_needed = 1;
chunk_parser_state = W4_ATTRIBUTE_ID;
break;
default:
btstack_assert(false);
break;
}
}

3
src/ble/att_db.c
View File

@ -319,6 +319,9 @@ static uint8_t att_validate_security(att_connection_t * att_connection, att_oper
requires_secure_connection = true;
}
break;
default:
btstack_assert(false);
break;
}
uint8_t required_encryption_size = it->flags >> 12;

11
src/ble/att_server.c
View File

@ -662,9 +662,10 @@ static int att_server_data_ready_for_phase(att_server_t * att_server, att_serve
return (!btstack_linked_list_empty(&att_server->indication_requests) && (att_server->value_indication_handle == 0));
case ATT_SERVER_RUN_PHASE_3_NOTIFICATIONS:
return (!btstack_linked_list_empty(&att_server->notification_requests));
default:
btstack_assert(false);
return 0;
}
// avoid warning
return 0;
}
static void att_server_trigger_send_for_phase(att_server_t * att_server, att_server_run_phase_t phase){
@ -683,6 +684,9 @@ static void att_server_trigger_send_for_phase(att_server_t * att_server, att_se
btstack_linked_list_remove(&att_server->notification_requests, (btstack_linked_item_t *) client);
client->callback(client->context);
break;
default:
btstack_assert(false);
break;
}
}
@ -834,6 +838,9 @@ static void att_packet_handler(uint8_t packet_type, uint16_t handle, uint8_t *pa
att_server_handle_att_pdu(att_server, packet, size);
break;
default:
break;
}
}

25
src/ble/sm.c
View File

@ -998,6 +998,9 @@ static void sm_trigger_user_response(sm_connection_t * sm_conn){
case OOB:
// client already provided OOB data, let's skip notification.
break;
default:
btstack_assert(false);
break;
}
}
@ -1268,6 +1271,10 @@ static void sm_address_resolution_handle_event(address_resolution_event_t event)
sm_connection->sm_engine_state = SM_INITIATOR_PH1_W2_SEND_PAIRING_REQUEST;
#endif
break;
default:
btstack_assert(false);
break;
}
break;
default:
@ -1281,6 +1288,9 @@ static void sm_address_resolution_handle_event(address_resolution_event_t event)
case ADDRESS_RESOLUTION_FAILED:
sm_notify_client_base(SM_EVENT_IDENTITY_RESOLVING_FAILED, con_handle, sm_address_resolution_addr_type, sm_address_resolution_address);
break;
default:
btstack_assert(false);
break;
}
}
@ -1454,6 +1464,9 @@ static void sm_sc_state_after_receiving_random(sm_connection_t * sm_conn){
case OOB:
sm_sc_prepare_dhkey_check(sm_conn);
break;
default:
btstack_assert(false);
break;
}
}
}
@ -2481,6 +2494,9 @@ static void sm_run(void){
connection->sm_engine_state = SM_SC_W4_PUBLIC_KEY_COMMAND;
}
break;
default:
btstack_assert(false);
break;
}
l2cap_send_connectionless(connection->sm_handle, L2CAP_CID_SECURITY_MANAGER_PROTOCOL, (uint8_t*) buffer, sizeof(buffer));
@ -2766,6 +2782,9 @@ static void sm_run(void){
gap_local_bd_addr(local_address);
buffer[1] = 0;
break;
default:
btstack_assert(false);
break;
}
reverse_bd_addr(local_address, &buffer[2]);
l2cap_send_connectionless(connection->sm_handle, L2CAP_CID_SECURITY_MANAGER_PROTOCOL, (uint8_t*) buffer, sizeof(buffer));
@ -3849,6 +3868,9 @@ static void sm_pdu_handler(uint8_t packet_type, hci_con_handle_t con_handle, uin
log_info("Generate Na");
btstack_crypto_random_generate(&sm_crypto_random_request, setup->sm_local_nonce, 16, &sm_handle_random_result_sc_next_send_pairing_random, (void*)(uintptr_t) sm_conn->sm_handle);
break;
default:
btstack_assert(false);
break;
}
}
break;
@ -4339,6 +4361,9 @@ void sm_bonding_decline(hci_con_handle_t con_handle){
case OOB:
sm_pairing_error(sm_conn, SM_REASON_UNSPECIFIED_REASON);
break;
default:
btstack_assert(false);
break;
}
break;
default:

25
src/btstack_hid_parser.c
View File

@ -121,7 +121,7 @@ static const char * local_tags[] = {
static void hid_pretty_print_item(btstack_hid_parser_t * parser, hid_descriptor_item_t * item){
#ifdef HID_PARSER_PRETTY_PRINT
const char ** item_tag_table;
switch (item->item_type){
switch ((TagType)item->item_type){
case Main:
item_tag_table = main_tags;
break;
@ -187,7 +187,7 @@ void btstack_hid_parse_descriptor_item(hid_descriptor_item_t * item, const uint8
}
static void btstack_hid_handle_global_item(btstack_hid_parser_t * parser, hid_descriptor_item_t * item){
switch(item->item_tag){
switch((GlobalItemTag)item->item_tag){
case UsagePage:
parser->global_usage_page = item->item_value;
break;
@ -211,7 +211,18 @@ static void btstack_hid_handle_global_item(btstack_hid_parser_t * parser, hid_de
case ReportCount:
parser->global_report_count = item->item_value;
break;
// TODO handle tags
case PhysicalMinimum:
case PhysicalMaximum:
case UnitExponent:
case Unit:
case Push:
case Pop:
break;
default:
btstack_assert(false);
break;
}
}
@ -255,9 +266,9 @@ static void hid_find_next_usage(btstack_hid_parser_t * parser){
static void hid_process_item(btstack_hid_parser_t * parser, hid_descriptor_item_t * item){
hid_pretty_print_item(parser, item);
int valid_field = 0;
switch (item->item_type){
switch ((TagType)item->item_type){
case Main:
switch (item->item_tag){
switch ((MainItemTag)item->item_tag){
case Input:
valid_field = parser->report_type == HID_REPORT_TYPE_INPUT;
break;
@ -275,6 +286,10 @@ static void hid_process_item(btstack_hid_parser_t * parser, hid_descriptor_item_
btstack_hid_handle_global_item(parser, item);
break;
case Local:
case Reserved:
break;
default:
btstack_assert(false);
break;
}
if (!valid_field) return;
@ -303,7 +318,7 @@ static void hid_process_item(btstack_hid_parser_t * parser, hid_descriptor_item_
}
static void hid_post_process_item(btstack_hid_parser_t * parser, hid_descriptor_item_t * item){
if (item->item_type == Main){
if ((TagType)item->item_type == Main){
// reset usage
parser->usage_pos = parser->descriptor_pos;
parser->usage_page = parser->global_usage_page;

3
src/classic/avdtp_util.c
View File

@ -183,6 +183,9 @@ int avdtp_read_signaling_header(avdtp_signaling_packet_t * signaling_header, uin
}
signaling_header->num_packets--;
break;
default:
btstack_assert(false);
break;
}
signaling_header->signal_identifier = (avdtp_signal_identifier_t)(packet[pos++] & 0x3f);
return pos;

12
src/classic/avrcp_controller.c
View File

@ -68,8 +68,10 @@ static uint16_t avrcp_get_max_payload_size_for_packet_type(avrcp_packet_type_t p
case AVRCP_CONTINUE_PACKET:
case AVRCP_END_PACKET:
return AVRCP_CMD_BUFFER_SIZE - 1;
default:
btstack_assert(false);
return 0;
}
return 0;
}
static int avrcp_controller_supports_browsing(uint16_t controller_supported_features){
@ -863,6 +865,10 @@ static void avrcp_handle_l2cap_data_packet_for_signaling_connection(avrcp_connec
event[offset++] = 0;
(*avrcp_controller_context.avrcp_callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
break;
default:
btstack_assert(false);
break;
}
break;
}
@ -919,6 +925,10 @@ static void avrcp_handle_l2cap_data_packet_for_signaling_connection(avrcp_connec
avrcp_parser_reset(connection);
}
break;
default:
// TODO check
btstack_assert(false);
break;
}
}
default:

3
src/classic/btstack_sbc_encoder_bluedroid.c
View File

@ -117,6 +117,9 @@ void btstack_sbc_encoder_init(btstack_sbc_encoder_state_t * state, btstack_sbc_m
bd_encoder_state.context.mSBCEnabled = 1;
bd_encoder_state.context.s16SamplingFreq = SBC_sf16000;
break;
default:
btstack_assert(false);
break;
}
bd_encoder_state.context.pu8Packet = bd_encoder_state.sbc_packet;

4
src/classic/goep_client.c
View File

@ -339,6 +339,10 @@ static void goep_client_handle_sdp_query_event(uint8_t packet_type, uint16_t cha
#endif
log_info("Remote GOEP RFCOMM Server Channel: %u", context->rfcomm_port);
rfcomm_create_channel(&goep_client_packet_handler, context->bd_addr, context->rfcomm_port, &context->bearer_cid);
break;
default:
break;
}
}

6
src/classic/hfp_ag.c
View File

@ -1129,6 +1129,8 @@ static void hfp_ag_call_sm(hfp_ag_call_event_t event, hfp_connection_t * hfp_con
break;
}
break;
default:
break;
}
break;
case HFP_AG_INCOMING_CALL_ACCEPTED_BY_AG:
@ -1160,6 +1162,8 @@ static void hfp_ag_call_sm(hfp_ag_call_event_t event, hfp_connection_t * hfp_con
break;
}
break;
default:
break;
}
break;
@ -1306,6 +1310,8 @@ static void hfp_ag_call_sm(hfp_ag_call_event_t event, hfp_connection_t * hfp_con
hfp_connection->call_state = HFP_CALL_IDLE;
log_info("AG terminate call");
break;
default:
break;
}
hfp_emit_simple_event(hfp_connection, HFP_SUBEVENT_CALL_TERMINATED);
break;

2
src/classic/hfp_gsm_model.c
View File

@ -492,6 +492,8 @@ static void hfp_gsm_handler(hfp_ag_call_event_t event, uint8_t index, uint8_t ty
case HFP_CALL_STATUS_ACTIVE_OR_HELD_CALL_IS_PRESENT:
delete_call(current_call_index);
break;
default:
break;
}
break;

9
src/classic/hid_device.c
View File

@ -488,6 +488,9 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t * pack
}
device->report_id = packet[pos++];
break;
default:
btstack_assert(false);
break;
}
if (device->report_status != HID_HANDSHAKE_PARAM_TYPE_SUCCESSFUL){
l2cap_request_can_send_now_event(device->control_cid);
@ -546,6 +549,9 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t * pack
(*hci_device_set_report)(device->cid, device->report_type, 1, payload);
}
break;
default:
btstack_assert(false);
break;
}
device->report_type = (hid_report_type_t)(packet[0] & 0x03);
l2cap_request_can_send_now_event(device->control_cid);
@ -582,6 +588,9 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t * pack
case HID_PROTOCOL_MODE_REPORT:
// printf("Set protocol mode to REPORT\n");
break;
default:
btstack_assert(false);
break;
}
device->report_status = HID_HANDSHAKE_PARAM_TYPE_SUCCESSFUL;
l2cap_request_can_send_now_event(device->control_cid);

2
src/classic/hsp_hs.c
View File

@ -664,6 +664,8 @@ static void handle_query_rfcomm_event(uint8_t packet_type, uint16_t channel, uin
emit_event(HSP_SUBEVENT_AUDIO_CONNECTION_COMPLETE, SDP_SERVICE_NOT_FOUND);
}
break;
default:
break;
}
}

3
src/classic/obex_iterator.c
View File

@ -178,6 +178,9 @@ void obex_dump_packet(uint8_t request_opcode, uint8_t * packet, uint16_t size){
case 3:
printf("%08x\n", (int) obex_iterator_get_data_32(&it));
break;
default:
btstack_assert(false);
break;
}
}

14
src/classic/pbap_client.c
View File

@ -482,10 +482,8 @@ static void pbap_handle_can_send_now(void){
}
static void pbap_parse_authentication_challenge(pbap_client_t * context, const uint8_t * challenge_data, uint16_t challenge_len){
// printf("Challenge: ");
// printf_hexdump(challenge_data, challenge_len);
int i;
// uint8_t charset_code = 0;
for (i=0 ; i<challenge_len ; ){
int tag = challenge_data[i];
int len = challenge_data[i + 1];
@ -496,19 +494,17 @@ static void pbap_parse_authentication_challenge(pbap_client_t * context, const u
log_error("Invalid OBEX digest len %u", len);
return;
}
(void)memcpy(context->authentication_nonce,
&challenge_data[i], 16);
// printf("Nonce: ");
// printf_hexdump(context->authentication_nonce, 16);
(void)memcpy(context->authentication_nonce, &challenge_data[i], 16);
break;
case 1:
context->authentication_options = challenge_data[i];
// printf("Options %u\n", context->authentication_options);
break;
case 2:
// TODO: handle charset
// charset_code = challenge_data[i];
break;
default:
break;
}
i += len;
}
@ -672,6 +668,8 @@ static void pbap_packet_handler_hci(uint8_t *packet, uint16_t size){
case GOEP_SUBEVENT_CAN_SEND_NOW:
pbap_handle_can_send_now();
break;
default:
break;
}
break;
default:

19
src/classic/sdp_client_rfcomm.c
View File

@ -107,14 +107,11 @@ static void sdp_client_query_rfcomm_handle_protocol_descriptor_list_data(uint32_
pdl_state = GET_PROTOCOL_LIST_LENGTH;
}
// log_info("sdp_client_query_rfcomm_handle_protocol_descriptor_list_data (%u,%u) %02x", attribute_value_length, data_offset, data);
switch(pdl_state){
case GET_PROTOCOL_LIST_LENGTH:
if (!de_state_size(data, &de_header_state)) break;
// log_info(" query: PD List payload is %d bytes.", de_header_state.de_size);
// log_info(" query: PD List offset %u, list size %u", de_header_state.de_offset, de_header_state.de_size);
pdl_state = GET_PROTOCOL_LENGTH;
break;
@ -122,7 +119,6 @@ static void sdp_client_query_rfcomm_handle_protocol_descriptor_list_data(uint32_
case GET_PROTOCOL_LENGTH:
// check size
if (!de_state_size(data, &de_header_state)) break;
// log_info(" query: PD Record payload is %d bytes.", de_header_state.de_size);
// cache protocol info
protocol_offset = de_header_state.de_offset;
@ -137,7 +133,6 @@ static void sdp_client_query_rfcomm_handle_protocol_descriptor_list_data(uint32_
protocol_id = 0;
protocol_id_bytes_to_read = de_header_state.de_size;
// log_info(" query: ID data is stored in %d bytes.", protocol_id_bytes_to_read);
pdl_state = GET_PROTOCOL_ID;
break;
@ -149,11 +144,9 @@ static void sdp_client_query_rfcomm_handle_protocol_descriptor_list_data(uint32_
protocol_id_bytes_to_read--;
if (protocol_id_bytes_to_read > 0) break;
// log_info(" query: Protocol ID: %04x.", protocol_id);
if (protocol_offset >= protocol_size){
pdl_state = GET_PROTOCOL_LENGTH;
// log_info(" query: Get next protocol");
break;
}
@ -174,8 +167,6 @@ static void sdp_client_query_rfcomm_handle_protocol_descriptor_list_data(uint32_
case GET_PROTOCOL_VALUE:
protocol_offset++;
protocol_value_bytes_received++;
// log_info(" query: protocol_value_bytes_received %u, protocol_value_size %u", protocol_value_bytes_received, protocol_value_size);
if (protocol_value_bytes_received < protocol_value_size) break;
@ -184,16 +175,12 @@ static void sdp_client_query_rfcomm_handle_protocol_descriptor_list_data(uint32_
sdp_rfcomm_channel_nr = data;
}
// log_info(" query: protocol done");
// log_info(" query: Protocol offset %u, protocol size %u", protocol_offset, protocol_size);
if (protocol_offset >= protocol_size) {
pdl_state = GET_PROTOCOL_LENGTH;
break;
}
pdl_state = GET_PROTOCOL_ID_HEADER_LENGTH;
// log_info(" query: Get next protocol");
break;
default:
break;
@ -258,9 +245,6 @@ static void sdp_client_query_rfcomm_handle_sdp_parser_event(uint8_t packet_type,
sdp_service_name[0] = 0;
break;
case SDP_EVENT_QUERY_ATTRIBUTE_VALUE:
// log_info("sdp_client_query_rfcomm_handle_sdp_parser_event [ AID, ALen, DOff, Data] : [%x, %u, %u] BYTE %02x",
// ve->attribute_id, sdp_event_query_attribute_byte_get_attribute_length(packet),
// sdp_event_query_attribute_byte_get_data_offset(packet), sdp_event_query_attribute_byte_get_data(packet));
switch (sdp_event_query_attribute_byte_get_attribute_id(packet)){
case BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST:
// find rfcomm channel
@ -286,8 +270,9 @@ static void sdp_client_query_rfcomm_handle_sdp_parser_event(uint8_t packet_type,
}
(*sdp_app_callback)(HCI_EVENT_PACKET, 0, packet, size);
break;
default:
break;
}
// insert higher level code HERE
}
void sdp_client_query_rfcomm_init(void){

24
src/hci.c
View File

@ -3343,6 +3343,9 @@ int hci_power_control(HCI_POWER_MODE power_mode){
case HCI_POWER_SLEEP:
// do nothing (with SLEEP == OFF)
break;
default:
btstack_assert(false);
break;
}
break;
@ -3359,6 +3362,9 @@ int hci_power_control(HCI_POWER_MODE power_mode){
// no connections yet, just turn it off
hci_power_control_sleep();
break;
default:
btstack_assert(false);
break;
}
break;
@ -3377,6 +3383,9 @@ int hci_power_control(HCI_POWER_MODE power_mode){
hci_stack->state = HCI_STATE_FALLING_ASLEEP;
hci_stack->substate = HCI_FALLING_ASLEEP_DISCONNECT;
break;
default:
btstack_assert(false);
break;
}
break;
@ -3393,6 +3402,9 @@ int hci_power_control(HCI_POWER_MODE power_mode){
hci_stack->state = HCI_STATE_FALLING_ASLEEP;
hci_stack->substate = HCI_FALLING_ASLEEP_DISCONNECT;
break;
default:
btstack_assert(false);
break;
}
break;
@ -3418,6 +3430,9 @@ int hci_power_control(HCI_POWER_MODE power_mode){
case HCI_POWER_SLEEP:
// do nothing
break;
default:
btstack_assert(false);
break;
}
break;
@ -3445,8 +3460,15 @@ int hci_power_control(HCI_POWER_MODE power_mode){
case HCI_POWER_SLEEP:
// do nothing
break;
default:
btstack_assert(false);
break;
}
break;
default:
btstack_assert(false);
break;
}
// create internal event
@ -4761,6 +4783,8 @@ static void gap_inquiry_explode(uint8_t *packet, uint16_t size) {
event_size += len;
}
break;
default:
return;
}
event[1] = event_size - 2;
hci_emit_event(event, event_size, 1);

3
src/hci_transport_h4.c
View File

@ -297,6 +297,9 @@ static void hci_transport_h4_block_read(void){
case H4_OFF:
bytes_to_read = 0;
break;
default:
btstack_assert(false);
break;
}
#ifdef ENABLE_BAUDRATE_CHANGE_FLOWCONTROL_BUG_WORKAROUND

14
src/l2cap.c
View File

@ -830,6 +830,9 @@ static void l2cap_ertm_handle_in_sequence_sdu(l2cap_channel_t * l2cap_channel, l
l2cap_dispatch_to_channel(l2cap_channel, L2CAP_DATA_PACKET, l2cap_channel->reassembly_buffer, l2cap_channel->reassembly_pos);
l2cap_channel->reassembly_pos = 0;
break;
default:
btstack_assert(false);
break;
}
}
@ -2229,10 +2232,12 @@ static int l2cap_send_open_failed_on_hci_disconnect(l2cap_channel_t * channel){
case L2CAP_STATE_INVALID:
case L2CAP_STATE_WAIT_INCOMING_SECURITY_LEVEL_UPDATE:
return 0;
// no default here, to get a warning about new states
default:
// get a "warning" about new states
btstack_assert(false);
return 0;
}
// still, the compiler insists on a return value
return 0;
}
#endif
@ -3459,6 +3464,9 @@ static void l2cap_acl_classic_handler_for_channel(l2cap_channel_t * l2cap_channe
case L2CAP_SEGMENTATION_AND_REASSEMBLY_END_OF_L2CAP_SDU:
max_payload_size = l2cap_channel->local_mps;
break;
default:
btstack_assert(false);
break;
}
if (payload_len > max_payload_size){
log_info("payload len %u > max payload %u -> drop packet", payload_len, max_payload_size);

4
src/mesh/gatt_bearer.c
View File

@ -269,6 +269,10 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
default:
break;
}
break;
default:
break;
}
break;
default:

54
src/mesh/mesh.c
View File

@ -300,39 +300,37 @@ static void mesh_provisioning_message_handler (uint8_t packet_type, uint16_t cha
static void hci_packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
UNUSED(channel);
UNUSED(size);
if (packet_type != HCI_EVENT_PACKET) return;
switch (packet_type) {
case HCI_EVENT_PACKET:
switch (hci_event_packet_get_type(packet)) {
case BTSTACK_EVENT_STATE:
if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) break;
// get TLV instance
btstack_tlv_get_instance(&btstack_tlv_singleton_impl, &btstack_tlv_singleton_context);
switch (hci_event_packet_get_type(packet)) {
case BTSTACK_EVENT_STATE:
if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) break;
// get TLV instance
btstack_tlv_get_instance(&btstack_tlv_singleton_impl, &btstack_tlv_singleton_context);
// startup from static provisioning data stored in TLV
provisioned = mesh_node_startup_from_tlv();
break;
// startup from static provisioning data stored in TLV
provisioned = mesh_node_startup_from_tlv();
break;
#ifdef ENABLE_MESH_PROXY_SERVER
case HCI_EVENT_DISCONNECTION_COMPLETE:
// enable PB_GATT
if (provisioned == 0){
mesh_proxy_start_advertising_unprovisioned_device();
} else {
mesh_proxy_start_advertising_with_network_id();
}
break;
case HCI_EVENT_LE_META:
if (hci_event_le_meta_get_subevent_code(packet) != HCI_SUBEVENT_LE_CONNECTION_COMPLETE) break;
// disable PB_GATT
mesh_proxy_stop_advertising_unprovisioned_device();
break;
#endif
default:
break;
case HCI_EVENT_DISCONNECTION_COMPLETE:
// enable PB_GATT
if (provisioned == 0){
mesh_proxy_start_advertising_unprovisioned_device();
} else {
mesh_proxy_start_advertising_with_network_id();
}
break;
case HCI_EVENT_LE_META:
if (hci_event_le_meta_get_subevent_code(packet) != HCI_SUBEVENT_LE_CONNECTION_COMPLETE) break;
// disable PB_GATT
mesh_proxy_stop_advertising_unprovisioned_device();
break;
#endif
default:
break;
}
}

50
src/mesh/mesh_network.c
View File

@ -866,44 +866,42 @@ static void mesh_adv_bearer_handle_network_event(uint8_t packet_type, uint16_t c
break;
case HCI_EVENT_PACKET:
switch(packet[0]){
case HCI_EVENT_MESH_META:
switch(packet[2]){
case MESH_SUBEVENT_CAN_SEND_NOW:
if (adv_bearer_network_pdu == NULL) break;
if (hci_event_packet_get_type(packet) != HCI_EVENT_MESH_META) break;
// Get Transmission config depending on relay flag
if (adv_bearer_network_pdu->flags & MESH_NETWORK_PDU_FLAGS_RELAY){
transmit_config = mesh_foundation_relay_get();
} else {
transmit_config = mesh_foundation_network_transmit_get();
}
transmission_count = (transmit_config & 0x07) + 1;
transmission_interval = (transmit_config >> 3) * 10;
switch(hci_event_mesh_meta_get_subevent_code(packet)){
case MESH_SUBEVENT_CAN_SEND_NOW:
if (adv_bearer_network_pdu == NULL) break;
// Get Transmission config depending on relay flag
if (adv_bearer_network_pdu->flags & MESH_NETWORK_PDU_FLAGS_RELAY){
transmit_config = mesh_foundation_relay_get();
} else {
transmit_config = mesh_foundation_network_transmit_get();
}
transmission_count = (transmit_config & 0x07) + 1;
transmission_interval = (transmit_config >> 3) * 10;
#ifdef LOG_NETWORK
printf("TX-E-NetworkPDU (%p) count %u, interval %u ms: ", adv_bearer_network_pdu, transmission_count, transmission_interval);
printf_hexdump(adv_bearer_network_pdu->data, adv_bearer_network_pdu->len);
printf("TX-E-NetworkPDU (%p) count %u, interval %u ms: ", adv_bearer_network_pdu, transmission_count, transmission_interval);
printf_hexdump(adv_bearer_network_pdu->data, adv_bearer_network_pdu->len);
#endif
adv_bearer_send_network_pdu(adv_bearer_network_pdu->data, adv_bearer_network_pdu->len, transmission_count, transmission_interval);
network_pdu = adv_bearer_network_pdu;
adv_bearer_network_pdu = NULL;
adv_bearer_send_network_pdu(adv_bearer_network_pdu->data, adv_bearer_network_pdu->len, transmission_count, transmission_interval);
network_pdu = adv_bearer_network_pdu;
adv_bearer_network_pdu = NULL;
// notify upper layer
mesh_network_send_complete(network_pdu);
// notify upper layer
mesh_network_send_complete(network_pdu);
// check if more to send
mesh_network_run();
break;
default:
break;
}
// check if more to send
mesh_network_run();
break;
default:
break;
}
break;
default:
break;
}
}
#endif

7
src/mesh/mesh_proxy.c
View File

@ -358,11 +358,15 @@ static void proxy_configuration_message_handler(mesh_network_callback_type_t cal
opcode = network_pdu_data[0];
switch (opcode){
case MESH_PROXY_CONFIGURATION_MESSAGE_OPCODE_SET_FILTER_TYPE:{
switch (network_pdu_data[1]){
switch ((mesh_proxy_configuration_filter_type_t) network_pdu_data[1]){
case MESH_PROXY_CONFIGURATION_FILTER_TYPE_SET_WHITE_LIST:
case MESH_PROXY_CONFIGURATION_FILTER_TYPE_BLACK_LIST:
proxy_configuration_filter_type = network_pdu_data[1];
break;
default:
// invalid filter type, ignore
btstack_memory_mesh_network_pdu_free(received_network_pdu);
return;
}
uint8_t ctl = 1;
@ -389,6 +393,7 @@ static void proxy_configuration_message_handler(mesh_network_callback_type_t cal
}
default:
printf("proxy config not implemented, opcode %d\n", opcode);
btstack_memory_mesh_network_pdu_free(received_network_pdu);
break;
}
break;

3
src/mesh/pb_adv.c
View File

@ -662,6 +662,9 @@ void pb_adv_close_link(uint16_t pb_transport_cid, uint8_t reason){
case LINK_STATE_CLOSING:
// nothing to do
break;
default:
btstack_assert(false);
break;
}
}

78
src/mesh/pb_gatt.c
View File

@ -88,8 +88,8 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
case PROVISIONING_DATA_PACKET:
pos = 0;
// on provisioning PDU call packet handler with PROVISIONG_DATA type
msg_sar_field = packet[pos] >> 6;
msg_type = packet[pos] & 0x3F;
msg_sar_field = (mesh_msg_sar_field_t) (packet[pos] >> 6);
msg_type = (mesh_msg_type_t) (packet[pos] & 0x3F);
pos++;
if (msg_type != MESH_MSG_TYPE_PROVISIONING_PDU) return;
if (!pb_gatt_packet_handler) return;
@ -131,53 +131,59 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
// send to provisioning device
pb_gatt_packet_handler(PROVISIONING_DATA_PACKET, 0, packet+pos, pdu_segment_len);
break;
default:
btstack_assert(false);
break;
}
break;
case HCI_EVENT_PACKET:
switch (hci_event_packet_get_type(packet)) {
case HCI_EVENT_MESH_META:
switch (hci_event_mesh_meta_get_subevent_code(packet)){
case MESH_SUBEVENT_PB_TRANSPORT_LINK_OPEN:
case MESH_SUBEVENT_PB_TRANSPORT_LINK_CLOSED:
// Forward link open/close
pb_gatt_mtu = ATT_DEFAULT_MTU;
pb_gatt_packet_handler(HCI_EVENT_PACKET, 0, packet, size);
break;
case MESH_SUBEVENT_CAN_SEND_NOW:
con_handle = little_endian_read_16(packet, 3);
if (con_handle == HCI_CON_HANDLE_INVALID) return;
if (hci_event_packet_get_type(packet) != HCI_EVENT_MESH_META) break;
switch (hci_event_mesh_meta_get_subevent_code(packet)){
case MESH_SUBEVENT_PB_TRANSPORT_LINK_OPEN:
case MESH_SUBEVENT_PB_TRANSPORT_LINK_CLOSED:
// Forward link open/close
pb_gatt_mtu = ATT_DEFAULT_MTU;
pb_gatt_packet_handler(HCI_EVENT_PACKET, 0, packet, size);
break;
case MESH_SUBEVENT_CAN_SEND_NOW:
con_handle = little_endian_read_16(packet, 3);
if (con_handle == HCI_CON_HANDLE_INVALID) return;
sar_buffer.segmentation_buffer[0] = (segmentation_state << 6) | MESH_MSG_TYPE_PROVISIONING_PDU;
pdu_segment_len = btstack_min(proxy_pdu_size - segmentation_offset, pb_gatt_mtu - 1);
(void)memcpy(&sar_buffer.segmentation_buffer[1],
&proxy_pdu[segmentation_offset],
pdu_segment_len);
segmentation_offset += pdu_segment_len;
sar_buffer.segmentation_buffer[0] = (segmentation_state << 6) | MESH_MSG_TYPE_PROVISIONING_PDU;
pdu_segment_len = btstack_min(proxy_pdu_size - segmentation_offset, pb_gatt_mtu - 1);
(void)memcpy(&sar_buffer.segmentation_buffer[1],
&proxy_pdu[segmentation_offset],
pdu_segment_len);
segmentation_offset += pdu_segment_len;
mesh_provisioning_service_server_send_proxy_pdu(con_handle, sar_buffer.segmentation_buffer, pdu_segment_len + 1);
switch (segmentation_state){
case MESH_MSG_SAR_FIELD_COMPLETE_MSG:
case MESH_MSG_SAR_FIELD_LAST_SEGMENT:
pb_gatt_emit_pdu_sent(0);
break;
case MESH_MSG_SAR_FIELD_CONTINUE:
case MESH_MSG_SAR_FIELD_FIRST_SEGMENT:
if ((proxy_pdu_size - segmentation_offset) > (pb_gatt_mtu - 1)){
segmentation_state = MESH_MSG_SAR_FIELD_CONTINUE;
} else {
segmentation_state = MESH_MSG_SAR_FIELD_LAST_SEGMENT;
}
mesh_provisioning_service_server_request_can_send_now(con_handle);
break;
mesh_provisioning_service_server_send_proxy_pdu(con_handle, sar_buffer.segmentation_buffer, pdu_segment_len + 1);
switch (segmentation_state){
case MESH_MSG_SAR_FIELD_COMPLETE_MSG:
case MESH_MSG_SAR_FIELD_LAST_SEGMENT:
pb_gatt_emit_pdu_sent(0);
break;
case MESH_MSG_SAR_FIELD_CONTINUE:
case MESH_MSG_SAR_FIELD_FIRST_SEGMENT:
if ((proxy_pdu_size - segmentation_offset) > (pb_gatt_mtu - 1)){
segmentation_state = MESH_MSG_SAR_FIELD_CONTINUE;
} else {
segmentation_state = MESH_MSG_SAR_FIELD_LAST_SEGMENT;
}
mesh_provisioning_service_server_request_can_send_now(con_handle);
break;
default:
btstack_assert(false);
break;
}
break;
default:
break;
}
break;
default:
break;
}

11
src/mesh/provisioning_device.c
View File

@ -494,6 +494,9 @@ static void provisioning_handle_start(uint8_t * packet, uint16_t size){
break;
}
break;
default:
// TODO check
break;
}
if (!ok){
printf("PROV_START arguments incorrect\n");
@ -758,8 +761,10 @@ static void provisioning_handle_pdu(uint8_t packet_type, uint16_t channel, uint8
switch (packet_type){
case HCI_EVENT_PACKET:
if (packet[0] != HCI_EVENT_MESH_META) break;
switch (packet[2]){
if (hci_event_packet_get_type(packet) != HCI_EVENT_MESH_META) break;
switch (hci_event_mesh_meta_get_subevent_code(packet)){
case MESH_SUBEVENT_PB_TRANSPORT_LINK_OPEN:
pb_transport_cid = mesh_subevent_pb_transport_link_open_get_pb_transport_cid(packet);
pb_type = mesh_subevent_pb_transport_link_open_get_pb_type(packet);
@ -779,6 +784,8 @@ static void provisioning_handle_pdu(uint8_t packet_type, uint16_t channel, uint8
pb_transport_cid = MESH_PB_TRANSPORT_INVALID_CID;
provisioning_done();
break;
default:
break;
}
break;
case PROVISIONING_DATA_PACKET:

7
src/mesh/provisioning_provisioner.c
View File

@ -644,8 +644,9 @@ static void provisioning_handle_pdu(uint8_t packet_type, uint16_t channel, uint8
switch (packet_type){
case HCI_EVENT_PACKET:
if (packet[0] != HCI_EVENT_MESH_META) break;
switch (packet[2]){
if (hci_event_packet_get_type(packet) != HCI_EVENT_MESH_META) break;
switch (hci_event_mesh_meta_get_subevent_code(packet)){
case MESH_SUBEVENT_PB_TRANSPORT_LINK_OPEN:
if (provisioner_state != PROVISIONER_W4_LINK_OPENED) break;
switch (mesh_subevent_pb_transport_link_open_get_status(packet)) {
@ -667,6 +668,8 @@ static void provisioning_handle_pdu(uint8_t packet_type, uint16_t channel, uint8
printf("Link close, reset state\n");
provisioning_done();
break;
default:
break;
}
break;
case PROVISIONING_DATA_PACKET: