diff --git a/components/bt/bluedroid/bta/dm/bta_dm_api.c b/components/bt/bluedroid/bta/dm/bta_dm_api.c index 959c975855..5dd94b6ac3 100755 --- a/components/bt/bluedroid/bta/dm/bta_dm_api.c +++ b/components/bt/bluedroid/bta/dm/bta_dm_api.c @@ -983,7 +983,7 @@ void BTA_DmSetBleAdvParams (UINT16 adv_int_min, UINT16 adv_int_max, #if BLE_INCLUDED == TRUE tBTA_DM_API_BLE_ADV_PARAMS *p_msg; - APPL_TRACE_API ("BTA_DmSetBleAdvParam: %d, %d", adv_int_min, adv_int_max); + APPL_TRACE_API ("BTA_DmSetBleAdvParam: %d, %d\n", adv_int_min, adv_int_max); if ((p_msg = (tBTA_DM_API_BLE_ADV_PARAMS *) GKI_getbuf(sizeof(tBTA_DM_API_BLE_ADV_PARAMS))) != NULL) { diff --git a/components/bt/bluedroid/bta/dm/bta_dm_pm.c b/components/bt/bluedroid/bta/dm/bta_dm_pm.c index 87061eb9b0..2ebcb46d1f 100755 --- a/components/bt/bluedroid/bta/dm/bta_dm_pm.c +++ b/components/bt/bluedroid/bta/dm/bta_dm_pm.c @@ -636,7 +636,6 @@ static void bta_dm_pm_set_mode(BD_ADDR peer_addr, tBTA_DM_PM_ACTION pm_request, remaining_ticks = bta_dm_pm_get_remaining_ticks(&bta_dm_cb.pm_timer[i].timer[timer_idx]); if (remaining_ticks < timeout) { - ets_printf("remain 00\n"); /* Cancel and restart the timer */ /* * TODO: The value of pm_action[timer_idx] is diff --git a/components/bt/bluedroid/bta/gatt/bta_gatts_act.c b/components/bt/bluedroid/bta/gatt/bta_gatts_act.c index 1c0edfd770..6e1e46fa9e 100755 --- a/components/bt/bluedroid/bta/gatt/bta_gatts_act.c +++ b/components/bt/bluedroid/bta/gatt/bta_gatts_act.c @@ -620,7 +620,7 @@ void bta_gatts_send_rsp (tBTA_GATTS_CB *p_cb, tBTA_GATTS_DATA * p_msg) p_msg->api_rsp.status, (tGATTS_RSP *)p_msg->api_rsp.p_rsp) != GATT_SUCCESS) { - APPL_TRACE_ERROR("Sending response failed"); + APPL_TRACE_ERROR("Sending response failed\n"); } } diff --git a/components/bt/bluedroid/bta/sys/bta_sys_main.c b/components/bt/bluedroid/bta/sys/bta_sys_main.c index c5a94648c3..36901e39dc 100755 --- a/components/bt/bluedroid/bta/sys/bta_sys_main.c +++ b/components/bt/bluedroid/bta/sys/bta_sys_main.c @@ -224,7 +224,7 @@ BOOLEAN bta_sys_sm_execute(BT_HDR *p_msg) UINT8 action; int i; - APPL_TRACE_EVENT("bta_sys_sm_execute state:%d, event:0x%x", bta_sys_cb.state, p_msg->event); + APPL_TRACE_EVENT("bta_sys_sm_execute state:%d, event:0x%x\n", bta_sys_cb.state, p_msg->event); /* look up the state table for the current state */ state_table = bta_sys_st_tbl[bta_sys_cb.state]; @@ -512,7 +512,7 @@ void bta_sys_event(BT_HDR *p_msg) UINT8 id; BOOLEAN freebuf = TRUE; - APPL_TRACE_EVENT("BTA got event 0x%x", p_msg->event); + APPL_TRACE_EVENT("BTA got event 0x%x\n", p_msg->event); /* get subsystem id from event */ id = (UINT8) (p_msg->event >> 8); @@ -524,7 +524,7 @@ void bta_sys_event(BT_HDR *p_msg) } else { - APPL_TRACE_WARNING("BTA got unregistered event id %d", id); + APPL_TRACE_WARNING("BTA got unregistered event id %d\n", id); } if (freebuf) diff --git a/components/bt/bluedroid/device/controller.c b/components/bt/bluedroid/device/controller.c index 2d928b3057..f8c268665c 100755 --- a/components/bt/bluedroid/device/controller.c +++ b/components/bt/bluedroid/device/controller.c @@ -1,461 +1,461 @@ -/****************************************************************************** - * - * Copyright (C) 2014 Google, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - ******************************************************************************/ -#include -#include "bt_trace.h" -#include "bdaddr.h" -#include "bt_types.h" -#include "controller.h" -#include "event_mask.h" -#include "hcimsgs.h" -#include "hci_layer.h" -#include "hci_packet_factory.h" -#include "hci_packet_parser.h" -#include "btm_ble_api.h" -#include "version.h" -#include "future.h" - -const bt_event_mask_t BLE_EVENT_MASK = { "\x00\x00\x00\x00\x00\x00\x06\x7f" }; - -#if (BLE_INCLUDED) -const bt_event_mask_t CLASSIC_EVENT_MASK = { HCI_DUMO_EVENT_MASK_EXT }; -#else -const bt_event_mask_t CLASSIC_EVENT_MASK = { HCI_LISBON_EVENT_MASK_EXT }; -#endif - -// TODO(zachoverflow): factor out into common module -const uint8_t SCO_HOST_BUFFER_SIZE = 0xff; - -#define HCI_SUPPORTED_COMMANDS_ARRAY_SIZE 64 -#define MAX_FEATURES_CLASSIC_PAGE_COUNT 3 -#define BLE_SUPPORTED_STATES_SIZE 8 -#define BLE_SUPPORTED_FEATURES_SIZE 8 - -static const hci_t *hci; -static const hci_packet_factory_t *packet_factory; -static const hci_packet_parser_t *packet_parser; - -static bt_bdaddr_t address; -static bt_version_t bt_version; - -static uint8_t supported_commands[HCI_SUPPORTED_COMMANDS_ARRAY_SIZE]; -static bt_device_features_t features_classic[MAX_FEATURES_CLASSIC_PAGE_COUNT]; -static uint8_t last_features_classic_page_index; - -static uint16_t acl_data_size_classic; -static uint16_t acl_data_size_ble; -static uint16_t acl_buffer_count_classic; -static uint8_t acl_buffer_count_ble; - -static uint8_t ble_white_list_size; -static uint8_t ble_resolving_list_max_size; -static uint8_t ble_supported_states[BLE_SUPPORTED_STATES_SIZE]; -static bt_device_features_t features_ble; -static uint16_t ble_suggested_default_data_length; - -static bool readable; -static bool ble_supported; -static bool simple_pairing_supported; -static bool secure_connections_supported; - -#define AWAIT_COMMAND(command) future_await(hci->transmit_command_futured(command)) - -// Module lifecycle functions - -static void start_up(void) { - BT_HDR *response; - - // Send the initial reset command - response = AWAIT_COMMAND(packet_factory->make_reset()); - packet_parser->parse_generic_command_complete(response); - - // Request the classic buffer size next - response = AWAIT_COMMAND(packet_factory->make_read_buffer_size()); - packet_parser->parse_read_buffer_size_response( - response, &acl_data_size_classic, &acl_buffer_count_classic); - - // Tell the controller about our buffer sizes and buffer counts next - // TODO(zachoverflow): factor this out. eww l2cap contamination. And why just a hardcoded 10? - response = AWAIT_COMMAND( - packet_factory->make_host_buffer_size( - L2CAP_MTU_SIZE, - SCO_HOST_BUFFER_SIZE, - L2CAP_HOST_FC_ACL_BUFS, - 10 - ) - ); - - packet_parser->parse_generic_command_complete(response); - - // Read the local version info off the controller next, including - // information such as manufacturer and supported HCI version - response = AWAIT_COMMAND(packet_factory->make_read_local_version_info()); - packet_parser->parse_read_local_version_info_response(response, &bt_version); - - // Read the bluetooth address off the controller next - response = AWAIT_COMMAND(packet_factory->make_read_bd_addr()); - packet_parser->parse_read_bd_addr_response(response, &address); - - // Request the controller's supported commands next - response = AWAIT_COMMAND(packet_factory->make_read_local_supported_commands()); - packet_parser->parse_read_local_supported_commands_response( - response, - supported_commands, - HCI_SUPPORTED_COMMANDS_ARRAY_SIZE - ); - - // Read page 0 of the controller features next - uint8_t page_number = 0; - response = AWAIT_COMMAND(packet_factory->make_read_local_extended_features(page_number)); - packet_parser->parse_read_local_extended_features_response( - response, - &page_number, - &last_features_classic_page_index, - features_classic, - MAX_FEATURES_CLASSIC_PAGE_COUNT - ); - - assert(page_number == 0); - page_number++; - - // Inform the controller what page 0 features we support, based on what - // it told us it supports. We need to do this first before we request the - // next page, because the controller's response for page 1 may be - // dependent on what we configure from page 0 - simple_pairing_supported = HCI_SIMPLE_PAIRING_SUPPORTED(features_classic[0].as_array); - if (simple_pairing_supported) { - response = AWAIT_COMMAND(packet_factory->make_write_simple_pairing_mode(HCI_SP_MODE_ENABLED)); - packet_parser->parse_generic_command_complete(response); - } - -#if (BLE_INCLUDED == TRUE) - if (HCI_LE_SPT_SUPPORTED(features_classic[0].as_array)) { - uint8_t simultaneous_le_host = HCI_SIMUL_LE_BREDR_SUPPORTED(features_classic[0].as_array) ? BTM_BLE_SIMULTANEOUS_HOST : 0; - response = AWAIT_COMMAND( - packet_factory->make_ble_write_host_support(BTM_BLE_HOST_SUPPORT, simultaneous_le_host) - ); - - packet_parser->parse_generic_command_complete(response); - } -#endif - - // Done telling the controller about what page 0 features we support - // Request the remaining feature pages - while (page_number <= last_features_classic_page_index && - page_number < MAX_FEATURES_CLASSIC_PAGE_COUNT) { - response = AWAIT_COMMAND(packet_factory->make_read_local_extended_features(page_number)); - packet_parser->parse_read_local_extended_features_response( - response, - &page_number, - &last_features_classic_page_index, - features_classic, - MAX_FEATURES_CLASSIC_PAGE_COUNT - ); - - page_number++; - } - -#if (SC_MODE_INCLUDED == TRUE) - secure_connections_supported = HCI_SC_CTRLR_SUPPORTED(features_classic[2].as_array); - if (secure_connections_supported) { - response = AWAIT_COMMAND(packet_factory->make_write_secure_connections_host_support(HCI_SC_MODE_ENABLED)); - packet_parser->parse_generic_command_complete(response); - } -#endif - -#if (BLE_INCLUDED == TRUE) - ble_supported = last_features_classic_page_index >= 1 && HCI_LE_HOST_SUPPORTED(features_classic[1].as_array); - if (ble_supported) { - // Request the ble white list size next - response = AWAIT_COMMAND(packet_factory->make_ble_read_white_list_size()); - packet_parser->parse_ble_read_white_list_size_response(response, &ble_white_list_size); - - // Request the ble buffer size next - response = AWAIT_COMMAND(packet_factory->make_ble_read_buffer_size()); - packet_parser->parse_ble_read_buffer_size_response( - response, - &acl_data_size_ble, - &acl_buffer_count_ble - ); - - // Response of 0 indicates ble has the same buffer size as classic - if (acl_data_size_ble == 0) - acl_data_size_ble = acl_data_size_classic; - - // Request the ble supported states next - response = AWAIT_COMMAND(packet_factory->make_ble_read_supported_states()); - packet_parser->parse_ble_read_supported_states_response( - response, - ble_supported_states, - sizeof(ble_supported_states) - ); - - // Request the ble supported features next - response = AWAIT_COMMAND(packet_factory->make_ble_read_local_supported_features()); - packet_parser->parse_ble_read_local_supported_features_response( - response, - &features_ble - ); - - if (HCI_LE_ENHANCED_PRIVACY_SUPPORTED(features_ble.as_array)) { - response = AWAIT_COMMAND(packet_factory->make_ble_read_resolving_list_size()); - packet_parser->parse_ble_read_resolving_list_size_response( - response, - &ble_resolving_list_max_size); - } - - if (HCI_LE_DATA_LEN_EXT_SUPPORTED(features_ble.as_array)) { - response = AWAIT_COMMAND(packet_factory->make_ble_read_suggested_default_data_length()); - packet_parser->parse_ble_read_suggested_default_data_length_response( - response, - &ble_suggested_default_data_length); - } - - // Set the ble event mask next - response = AWAIT_COMMAND(packet_factory->make_ble_set_event_mask(&BLE_EVENT_MASK)); - packet_parser->parse_generic_command_complete(response); - } -#endif - - if (simple_pairing_supported) { - response = AWAIT_COMMAND(packet_factory->make_set_event_mask(&CLASSIC_EVENT_MASK)); - packet_parser->parse_generic_command_complete(response); - } - - readable = true; - // return future_new_immediate(FUTURE_SUCCESS); - return; -} - -static void shut_down(void) { - readable = false; -} - -static bool get_is_ready(void) { - return readable; -} - -static const bt_bdaddr_t *get_address(void) { - assert(readable); - return &address; -} - -static const bt_version_t *get_bt_version(void) { - assert(readable); - return &bt_version; -} - -// TODO(zachoverflow): hide inside, move decoder inside too -static const bt_device_features_t *get_features_classic(int index) { - assert(readable); - assert(index < MAX_FEATURES_CLASSIC_PAGE_COUNT); - return &features_classic[index]; -} - -static uint8_t get_last_features_classic_index(void) { - assert(readable); - return last_features_classic_page_index; -} - -static const bt_device_features_t *get_features_ble(void) { - assert(readable); - assert(ble_supported); - return &features_ble; -} - -static const uint8_t *get_ble_supported_states(void) { - assert(readable); - assert(ble_supported); - return ble_supported_states; -} - -static bool supports_simple_pairing(void) { - assert(readable); - return simple_pairing_supported; -} - -static bool supports_secure_connections(void) { - assert(readable); - return secure_connections_supported; -} - -static bool supports_simultaneous_le_bredr(void) { - assert(readable); - return HCI_SIMUL_LE_BREDR_SUPPORTED(features_classic[0].as_array); -} - -static bool supports_reading_remote_extended_features(void) { - assert(readable); - return HCI_READ_REMOTE_EXT_FEATURES_SUPPORTED(supported_commands); -} - -static bool supports_interlaced_inquiry_scan(void) { - assert(readable); - return HCI_LMP_INTERLACED_INQ_SCAN_SUPPORTED(features_classic[0].as_array); -} - -static bool supports_rssi_with_inquiry_results(void) { - assert(readable); - return HCI_LMP_INQ_RSSI_SUPPORTED(features_classic[0].as_array); -} - -static bool supports_extended_inquiry_response(void) { - assert(readable); - return HCI_EXT_INQ_RSP_SUPPORTED(features_classic[0].as_array); -} - -static bool supports_master_slave_role_switch(void) { - assert(readable); - return HCI_SWITCH_SUPPORTED(features_classic[0].as_array); -} - -static bool supports_ble(void) { - assert(readable); - return ble_supported; -} - -static bool supports_ble_privacy(void) { - assert(readable); - assert(ble_supported); - return HCI_LE_ENHANCED_PRIVACY_SUPPORTED(features_ble.as_array); -} - -static bool supports_ble_packet_extension(void) { - assert(readable); - assert(ble_supported); - return HCI_LE_DATA_LEN_EXT_SUPPORTED(features_ble.as_array); -} - -static bool supports_ble_connection_parameters_request(void) { - assert(readable); - assert(ble_supported); - return HCI_LE_CONN_PARAM_REQ_SUPPORTED(features_ble.as_array); -} - -static uint16_t get_acl_data_size_classic(void) { - assert(readable); - return acl_data_size_classic; -} - -static uint16_t get_acl_data_size_ble(void) { - assert(readable); - assert(ble_supported); - return acl_data_size_ble; -} - -static uint16_t get_acl_packet_size_classic(void) { - assert(readable); - return acl_data_size_classic + HCI_DATA_PREAMBLE_SIZE; -} - -static uint16_t get_acl_packet_size_ble(void) { - assert(readable); - return acl_data_size_ble + HCI_DATA_PREAMBLE_SIZE; -} - -static uint16_t get_ble_suggested_default_data_length(void) { - assert(readable); - assert(ble_supported); - return ble_suggested_default_data_length; -} - -static uint16_t get_acl_buffer_count_classic(void) { - assert(readable); - return acl_buffer_count_classic; -} - -static uint8_t get_acl_buffer_count_ble(void) { - assert(readable); - assert(ble_supported); - return acl_buffer_count_ble; -} - -static uint8_t get_ble_white_list_size(void) { - assert(readable); - assert(ble_supported); - return ble_white_list_size; -} - -static uint8_t get_ble_resolving_list_max_size(void) { - assert(readable); - assert(ble_supported); - return ble_resolving_list_max_size; -} - -static void set_ble_resolving_list_max_size(int resolving_list_max_size) { - assert(readable); - assert(ble_supported); - ble_resolving_list_max_size = resolving_list_max_size; -} - -static const controller_t interface = { - start_up, - shut_down, - get_is_ready, - - get_address, - get_bt_version, - - get_features_classic, - get_last_features_classic_index, - - get_features_ble, - get_ble_supported_states, - - supports_simple_pairing, - supports_secure_connections, - supports_simultaneous_le_bredr, - supports_reading_remote_extended_features, - supports_interlaced_inquiry_scan, - supports_rssi_with_inquiry_results, - supports_extended_inquiry_response, - supports_master_slave_role_switch, - - supports_ble, - supports_ble_packet_extension, - supports_ble_connection_parameters_request, - supports_ble_privacy, - - get_acl_data_size_classic, - get_acl_data_size_ble, - - get_acl_packet_size_classic, - get_acl_packet_size_ble, - get_ble_suggested_default_data_length, - - get_acl_buffer_count_classic, - get_acl_buffer_count_ble, - - get_ble_white_list_size, - - get_ble_resolving_list_max_size, - set_ble_resolving_list_max_size -}; - -const controller_t *controller_get_interface() { - static bool loaded = false; - if (!loaded) { - loaded = true; - - hci = hci_layer_get_interface(); - packet_factory = hci_packet_factory_get_interface(); - packet_parser = hci_packet_parser_get_interface(); - } - - return &interface; -} - +/****************************************************************************** + * + * Copyright (C) 2014 Google, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ******************************************************************************/ +#include +#include "bt_trace.h" +#include "bdaddr.h" +#include "bt_types.h" +#include "controller.h" +#include "event_mask.h" +#include "hcimsgs.h" +#include "hci_layer.h" +#include "hci_packet_factory.h" +#include "hci_packet_parser.h" +#include "btm_ble_api.h" +#include "version.h" +#include "future.h" + +const bt_event_mask_t BLE_EVENT_MASK = { "\x00\x00\x00\x00\x00\x00\x06\x7f" }; + +#if (BLE_INCLUDED) +const bt_event_mask_t CLASSIC_EVENT_MASK = { HCI_DUMO_EVENT_MASK_EXT }; +#else +const bt_event_mask_t CLASSIC_EVENT_MASK = { HCI_LISBON_EVENT_MASK_EXT }; +#endif + +// TODO(zachoverflow): factor out into common module +const uint8_t SCO_HOST_BUFFER_SIZE = 0xff; + +#define HCI_SUPPORTED_COMMANDS_ARRAY_SIZE 64 +#define MAX_FEATURES_CLASSIC_PAGE_COUNT 3 +#define BLE_SUPPORTED_STATES_SIZE 8 +#define BLE_SUPPORTED_FEATURES_SIZE 8 + +static const hci_t *hci; +static const hci_packet_factory_t *packet_factory; +static const hci_packet_parser_t *packet_parser; + +static bt_bdaddr_t address; +static bt_version_t bt_version; + +static uint8_t supported_commands[HCI_SUPPORTED_COMMANDS_ARRAY_SIZE]; +static bt_device_features_t features_classic[MAX_FEATURES_CLASSIC_PAGE_COUNT]; +static uint8_t last_features_classic_page_index; + +static uint16_t acl_data_size_classic; +static uint16_t acl_data_size_ble; +static uint16_t acl_buffer_count_classic; +static uint8_t acl_buffer_count_ble; + +static uint8_t ble_white_list_size; +static uint8_t ble_resolving_list_max_size; +static uint8_t ble_supported_states[BLE_SUPPORTED_STATES_SIZE]; +static bt_device_features_t features_ble; +static uint16_t ble_suggested_default_data_length; + +static bool readable; +static bool ble_supported; +static bool simple_pairing_supported; +static bool secure_connections_supported; + +#define AWAIT_COMMAND(command) future_await(hci->transmit_command_futured(command)) + +// Module lifecycle functions + +static void start_up(void) { + BT_HDR *response; + + // Send the initial reset command + response = AWAIT_COMMAND(packet_factory->make_reset()); + packet_parser->parse_generic_command_complete(response); + + // Request the classic buffer size next + response = AWAIT_COMMAND(packet_factory->make_read_buffer_size()); + packet_parser->parse_read_buffer_size_response( + response, &acl_data_size_classic, &acl_buffer_count_classic); + + // Tell the controller about our buffer sizes and buffer counts next + // TODO(zachoverflow): factor this out. eww l2cap contamination. And why just a hardcoded 10? + response = AWAIT_COMMAND( + packet_factory->make_host_buffer_size( + L2CAP_MTU_SIZE, + SCO_HOST_BUFFER_SIZE, + L2CAP_HOST_FC_ACL_BUFS, + 10 + ) + ); + + packet_parser->parse_generic_command_complete(response); + + // Read the local version info off the controller next, including + // information such as manufacturer and supported HCI version + response = AWAIT_COMMAND(packet_factory->make_read_local_version_info()); + packet_parser->parse_read_local_version_info_response(response, &bt_version); + + // Read the bluetooth address off the controller next + response = AWAIT_COMMAND(packet_factory->make_read_bd_addr()); + packet_parser->parse_read_bd_addr_response(response, &address); + + // Request the controller's supported commands next + response = AWAIT_COMMAND(packet_factory->make_read_local_supported_commands()); + packet_parser->parse_read_local_supported_commands_response( + response, + supported_commands, + HCI_SUPPORTED_COMMANDS_ARRAY_SIZE + ); + + // Read page 0 of the controller features next + uint8_t page_number = 0; + response = AWAIT_COMMAND(packet_factory->make_read_local_extended_features(page_number)); + packet_parser->parse_read_local_extended_features_response( + response, + &page_number, + &last_features_classic_page_index, + features_classic, + MAX_FEATURES_CLASSIC_PAGE_COUNT + ); + + assert(page_number == 0); + page_number++; + + // Inform the controller what page 0 features we support, based on what + // it told us it supports. We need to do this first before we request the + // next page, because the controller's response for page 1 may be + // dependent on what we configure from page 0 + simple_pairing_supported = HCI_SIMPLE_PAIRING_SUPPORTED(features_classic[0].as_array); + if (simple_pairing_supported) { + response = AWAIT_COMMAND(packet_factory->make_write_simple_pairing_mode(HCI_SP_MODE_ENABLED)); + packet_parser->parse_generic_command_complete(response); + } + +#if (BLE_INCLUDED == TRUE) + if (HCI_LE_SPT_SUPPORTED(features_classic[0].as_array)) { + uint8_t simultaneous_le_host = HCI_SIMUL_LE_BREDR_SUPPORTED(features_classic[0].as_array) ? BTM_BLE_SIMULTANEOUS_HOST : 0; + response = AWAIT_COMMAND( + packet_factory->make_ble_write_host_support(BTM_BLE_HOST_SUPPORT, simultaneous_le_host) + ); + + packet_parser->parse_generic_command_complete(response); + } +#endif + + // Done telling the controller about what page 0 features we support + // Request the remaining feature pages + while (page_number <= last_features_classic_page_index && + page_number < MAX_FEATURES_CLASSIC_PAGE_COUNT) { + response = AWAIT_COMMAND(packet_factory->make_read_local_extended_features(page_number)); + packet_parser->parse_read_local_extended_features_response( + response, + &page_number, + &last_features_classic_page_index, + features_classic, + MAX_FEATURES_CLASSIC_PAGE_COUNT + ); + + page_number++; + } + +#if (SC_MODE_INCLUDED == TRUE) + secure_connections_supported = HCI_SC_CTRLR_SUPPORTED(features_classic[2].as_array); + if (secure_connections_supported) { + response = AWAIT_COMMAND(packet_factory->make_write_secure_connections_host_support(HCI_SC_MODE_ENABLED)); + packet_parser->parse_generic_command_complete(response); + } +#endif + +#if (BLE_INCLUDED == TRUE) + ble_supported = last_features_classic_page_index >= 1 && HCI_LE_HOST_SUPPORTED(features_classic[1].as_array); + if (ble_supported) { + // Request the ble white list size next + response = AWAIT_COMMAND(packet_factory->make_ble_read_white_list_size()); + packet_parser->parse_ble_read_white_list_size_response(response, &ble_white_list_size); + + // Request the ble buffer size next + response = AWAIT_COMMAND(packet_factory->make_ble_read_buffer_size()); + packet_parser->parse_ble_read_buffer_size_response( + response, + &acl_data_size_ble, + &acl_buffer_count_ble + ); + + // Response of 0 indicates ble has the same buffer size as classic + if (acl_data_size_ble == 0) + acl_data_size_ble = acl_data_size_classic; + + // Request the ble supported states next + response = AWAIT_COMMAND(packet_factory->make_ble_read_supported_states()); + packet_parser->parse_ble_read_supported_states_response( + response, + ble_supported_states, + sizeof(ble_supported_states) + ); + + // Request the ble supported features next + response = AWAIT_COMMAND(packet_factory->make_ble_read_local_supported_features()); + packet_parser->parse_ble_read_local_supported_features_response( + response, + &features_ble + ); + + if (HCI_LE_ENHANCED_PRIVACY_SUPPORTED(features_ble.as_array)) { + response = AWAIT_COMMAND(packet_factory->make_ble_read_resolving_list_size()); + packet_parser->parse_ble_read_resolving_list_size_response( + response, + &ble_resolving_list_max_size); + } + + if (HCI_LE_DATA_LEN_EXT_SUPPORTED(features_ble.as_array)) { + response = AWAIT_COMMAND(packet_factory->make_ble_read_suggested_default_data_length()); + packet_parser->parse_ble_read_suggested_default_data_length_response( + response, + &ble_suggested_default_data_length); + } + + // Set the ble event mask next + response = AWAIT_COMMAND(packet_factory->make_ble_set_event_mask(&BLE_EVENT_MASK)); + packet_parser->parse_generic_command_complete(response); + } +#endif + + if (simple_pairing_supported) { + response = AWAIT_COMMAND(packet_factory->make_set_event_mask(&CLASSIC_EVENT_MASK)); + packet_parser->parse_generic_command_complete(response); + } + + readable = true; + // return future_new_immediate(FUTURE_SUCCESS); + return; +} + +static void shut_down(void) { + readable = false; +} + +static bool get_is_ready(void) { + return readable; +} + +static const bt_bdaddr_t *get_address(void) { + assert(readable); + return &address; +} + +static const bt_version_t *get_bt_version(void) { + assert(readable); + return &bt_version; +} + +// TODO(zachoverflow): hide inside, move decoder inside too +static const bt_device_features_t *get_features_classic(int index) { + assert(readable); + assert(index < MAX_FEATURES_CLASSIC_PAGE_COUNT); + return &features_classic[index]; +} + +static uint8_t get_last_features_classic_index(void) { + assert(readable); + return last_features_classic_page_index; +} + +static const bt_device_features_t *get_features_ble(void) { + assert(readable); + assert(ble_supported); + return &features_ble; +} + +static const uint8_t *get_ble_supported_states(void) { + assert(readable); + assert(ble_supported); + return ble_supported_states; +} + +static bool supports_simple_pairing(void) { + assert(readable); + return simple_pairing_supported; +} + +static bool supports_secure_connections(void) { + assert(readable); + return secure_connections_supported; +} + +static bool supports_simultaneous_le_bredr(void) { + assert(readable); + return HCI_SIMUL_LE_BREDR_SUPPORTED(features_classic[0].as_array); +} + +static bool supports_reading_remote_extended_features(void) { + assert(readable); + return HCI_READ_REMOTE_EXT_FEATURES_SUPPORTED(supported_commands); +} + +static bool supports_interlaced_inquiry_scan(void) { + assert(readable); + return HCI_LMP_INTERLACED_INQ_SCAN_SUPPORTED(features_classic[0].as_array); +} + +static bool supports_rssi_with_inquiry_results(void) { + assert(readable); + return HCI_LMP_INQ_RSSI_SUPPORTED(features_classic[0].as_array); +} + +static bool supports_extended_inquiry_response(void) { + assert(readable); + return HCI_EXT_INQ_RSP_SUPPORTED(features_classic[0].as_array); +} + +static bool supports_master_slave_role_switch(void) { + assert(readable); + return HCI_SWITCH_SUPPORTED(features_classic[0].as_array); +} + +static bool supports_ble(void) { + assert(readable); + return ble_supported; +} + +static bool supports_ble_privacy(void) { + assert(readable); + assert(ble_supported); + return HCI_LE_ENHANCED_PRIVACY_SUPPORTED(features_ble.as_array); +} + +static bool supports_ble_packet_extension(void) { + assert(readable); + assert(ble_supported); + return HCI_LE_DATA_LEN_EXT_SUPPORTED(features_ble.as_array); +} + +static bool supports_ble_connection_parameters_request(void) { + assert(readable); + assert(ble_supported); + return HCI_LE_CONN_PARAM_REQ_SUPPORTED(features_ble.as_array); +} + +static uint16_t get_acl_data_size_classic(void) { + assert(readable); + return acl_data_size_classic; +} + +static uint16_t get_acl_data_size_ble(void) { + assert(readable); + assert(ble_supported); + return acl_data_size_ble; +} + +static uint16_t get_acl_packet_size_classic(void) { + assert(readable); + return acl_data_size_classic + HCI_DATA_PREAMBLE_SIZE; +} + +static uint16_t get_acl_packet_size_ble(void) { + assert(readable); + return acl_data_size_ble + HCI_DATA_PREAMBLE_SIZE; +} + +static uint16_t get_ble_suggested_default_data_length(void) { + assert(readable); + assert(ble_supported); + return ble_suggested_default_data_length; +} + +static uint16_t get_acl_buffer_count_classic(void) { + assert(readable); + return acl_buffer_count_classic; +} + +static uint8_t get_acl_buffer_count_ble(void) { + assert(readable); + assert(ble_supported); + return acl_buffer_count_ble; +} + +static uint8_t get_ble_white_list_size(void) { + assert(readable); + assert(ble_supported); + return ble_white_list_size; +} + +static uint8_t get_ble_resolving_list_max_size(void) { + assert(readable); + assert(ble_supported); + return ble_resolving_list_max_size; +} + +static void set_ble_resolving_list_max_size(int resolving_list_max_size) { + assert(readable); + assert(ble_supported); + ble_resolving_list_max_size = resolving_list_max_size; +} + +static const controller_t interface = { + start_up, + shut_down, + get_is_ready, + + get_address, + get_bt_version, + + get_features_classic, + get_last_features_classic_index, + + get_features_ble, + get_ble_supported_states, + + supports_simple_pairing, + supports_secure_connections, + supports_simultaneous_le_bredr, + supports_reading_remote_extended_features, + supports_interlaced_inquiry_scan, + supports_rssi_with_inquiry_results, + supports_extended_inquiry_response, + supports_master_slave_role_switch, + + supports_ble, + supports_ble_packet_extension, + supports_ble_connection_parameters_request, + supports_ble_privacy, + + get_acl_data_size_classic, + get_acl_data_size_ble, + + get_acl_packet_size_classic, + get_acl_packet_size_ble, + get_ble_suggested_default_data_length, + + get_acl_buffer_count_classic, + get_acl_buffer_count_ble, + + get_ble_white_list_size, + + get_ble_resolving_list_max_size, + set_ble_resolving_list_max_size +}; + +const controller_t *controller_get_interface() { + static bool loaded = false; + if (!loaded) { + loaded = true; + + hci = hci_layer_get_interface(); + packet_factory = hci_packet_factory_get_interface(); + packet_parser = hci_packet_parser_get_interface(); + } + + return &interface; +} + diff --git a/components/bt/bluedroid/hci/hci_hal_h4.c b/components/bt/bluedroid/hci/hci_hal_h4.c index 19e5a4ba5b..968e23b1a0 100755 --- a/components/bt/bluedroid/hci/hci_hal_h4.c +++ b/components/bt/bluedroid/hci/hci_hal_h4.c @@ -82,7 +82,7 @@ static void hci_hal_env_init( if (hci_hal_env.rx_q) fixed_queue_register_dequeue(hci_hal_env.rx_q, event_uart_has_bytes); else - LOG_ERROR("%s unable to create rx queue.", __func__); + LOG_ERROR("%s unable to create rx queue.\n", __func__); return; } @@ -97,7 +97,7 @@ static bool hal_open(const hci_hal_callbacks_t *upper_callbacks) { hci_hal_env_init(HCI_HAL_SERIAL_BUFFER_SIZE, SIZE_MAX); - xHciH4Queue = xQueueCreate(3, sizeof(void *)); + xHciH4Queue = xQueueCreate(60, sizeof(void *)); xTaskCreate(hci_hal_h4_rx_handler, "HciH4T", 4096+2048, NULL, configMAX_PRIORITIES - 3, &xHciH4TaskHandle); //register vhci host cb diff --git a/components/bt/bluedroid/hci/hci_layer.c b/components/bt/bluedroid/hci/hci_layer.c index 8aa4ed1637..0fee3ed24e 100755 --- a/components/bt/bluedroid/hci/hci_layer.c +++ b/components/bt/bluedroid/hci/hci_layer.c @@ -111,7 +111,7 @@ int hci_start_up(void) { if (hci_layer_init_env()) goto error; - xHciHostQueue = xQueueCreate(3, sizeof(void *)); + xHciHostQueue = xQueueCreate(60, sizeof(void *)); xTaskCreate(hci_host_thread_handler, "HciHostT", (4096+2048), NULL, configMAX_PRIORITIES - 3, &xHciHostTaskHandle); packet_fragmenter->init(&packet_fragmenter_callbacks); diff --git a/components/bt/bluedroid/include/bt_defs.h b/components/bt/bluedroid/include/bt_defs.h index 556123632b..96071af100 100755 --- a/components/bt/bluedroid/include/bt_defs.h +++ b/components/bt/bluedroid/include/bt_defs.h @@ -14,7 +14,7 @@ #define UNUSED(x) (void)(x) #ifndef SIZE_MAX -#define SIZE_MAX 128 +#define SIZE_MAX 254 #endif /*Timer Related Defination*/ diff --git a/components/bt/bluedroid/osi/future.c b/components/bt/bluedroid/osi/future.c index 7c816f9e4d..79f64974b2 100644 --- a/components/bt/bluedroid/osi/future.c +++ b/components/bt/bluedroid/osi/future.c @@ -1,100 +1,100 @@ -/****************************************************************************** - * - * Copyright (C) 2014 Google, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - ******************************************************************************/ - -// #define LOG_TAG "bt_osi_future" -// #include -#include "bt_trace.h" - -#include "allocator.h" -#include "future.h" -#include "osi.h" -//#include "osi/include/log.h" -#include "osi_arch.h" - -struct future_t { - bool ready_can_be_called; - osi_sem_t semaphore; // NULL semaphore means immediate future - void *result; -}; - -static void future_free(future_t *future); - -future_t *future_new(void) { - future_t *ret = osi_calloc(sizeof(future_t)); - if (!ret) { - LOG_ERROR("%s unable to allocate memory for return value.", __func__); - goto error; - } - - if (osi_sem_new(&ret->semaphore, 1, 0)!=0) { - LOG_ERROR("%s unable to allocate memory for the semaphore.", __func__); - goto error; - } - - ret->ready_can_be_called = true; - return ret; -error:; - future_free(ret); - return NULL; -} - -future_t *future_new_immediate(void *value) { - future_t *ret = osi_calloc(sizeof(future_t)); - if (!ret) { - LOG_ERROR("%s unable to allocate memory for return value.", __func__); - goto error; - } - - ret->result = value; - ret->ready_can_be_called = false; - return ret; -error:; - future_free(ret); - return NULL; -} - -void future_ready(future_t *future, void *value) { - assert(future != NULL); - assert(future->ready_can_be_called); - - future->ready_can_be_called = false; - future->result = value; - osi_sem_signal(&future->semaphore); -} - -void *future_await(future_t *future) { - assert(future != NULL); - - // If the future is immediate, it will not have a semaphore - if (future->semaphore) - osi_sem_wait(&future->semaphore, 0); - - void *result = future->result; - future_free(future); - return result; -} - -static void future_free(future_t *future) { - if (!future) - return; - - if (!future->semaphore) - osi_sem_free(&future->semaphore); - - osi_free(future); -} +/****************************************************************************** + * + * Copyright (C) 2014 Google, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ******************************************************************************/ + +// #define LOG_TAG "bt_osi_future" +// #include +#include "bt_trace.h" + +#include "allocator.h" +#include "future.h" +#include "osi.h" +//#include "osi/include/log.h" +#include "osi_arch.h" + +struct future_t { + bool ready_can_be_called; + osi_sem_t semaphore; // NULL semaphore means immediate future + void *result; +}; + +static void future_free(future_t *future); + +future_t *future_new(void) { + future_t *ret = osi_calloc(sizeof(future_t)); + if (!ret) { + LOG_ERROR("%s unable to allocate memory for return value.", __func__); + goto error; + } + + if (osi_sem_new(&ret->semaphore, 1, 0)!=0) { + LOG_ERROR("%s unable to allocate memory for the semaphore.", __func__); + goto error; + } + + ret->ready_can_be_called = true; + return ret; +error:; + future_free(ret); + return NULL; +} + +future_t *future_new_immediate(void *value) { + future_t *ret = osi_calloc(sizeof(future_t)); + if (!ret) { + LOG_ERROR("%s unable to allocate memory for return value.", __func__); + goto error; + } + + ret->result = value; + ret->ready_can_be_called = false; + return ret; +error:; + future_free(ret); + return NULL; +} + +void future_ready(future_t *future, void *value) { + assert(future != NULL); + assert(future->ready_can_be_called); + + future->ready_can_be_called = false; + future->result = value; + osi_sem_signal(&future->semaphore); +} + +void *future_await(future_t *future) { + assert(future != NULL); + + // If the future is immediate, it will not have a semaphore + if (future->semaphore) + osi_sem_wait(&future->semaphore, 0); + + void *result = future->result; + future_free(future); + return result; +} + +static void future_free(future_t *future) { + if (!future) + return; + + if (!future->semaphore) + osi_sem_free(&future->semaphore); + + osi_free(future); +} diff --git a/components/bt/bluedroid/osi/include/future.h b/components/bt/bluedroid/osi/include/future.h index d4601a93f1..f2d6a1cc27 100644 --- a/components/bt/bluedroid/osi/include/future.h +++ b/components/bt/bluedroid/osi/include/future.h @@ -1,45 +1,45 @@ -/****************************************************************************** - * - * Copyright (C) 2014 Google, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - ******************************************************************************/ - -#ifndef __FUTURE_H__ -#define __FUTURE_H__ -// #pragma once - -typedef struct future_t future_t; - -#define FUTURE_SUCCESS ((void *)1) -#define FUTURE_FAIL ((void *)0) - -// Constructs a new future_t object. Returns NULL on failure. -future_t *future_new(void); - -// Constructs a new future_t object with an immediate |value|. No waiting will -// occur in the call to |future_await| because the value is already present. -// Returns NULL on failure. -future_t *future_new_immediate(void *value); - -// Signals that the |future| is ready, passing |value| back to the context -// waiting for the result. Must only be called once for every future. -// |future| may not be NULL. -void future_ready(future_t *future, void *value); - -// Waits for the |future| to be ready. Returns the value set in |future_ready|. -// Frees the future before return. |future| may not be NULL. -void *future_await(future_t *async_result); - -#endif /* __FUTURE_H__ */ +/****************************************************************************** + * + * Copyright (C) 2014 Google, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ******************************************************************************/ + +#ifndef __FUTURE_H__ +#define __FUTURE_H__ +// #pragma once + +typedef struct future_t future_t; + +#define FUTURE_SUCCESS ((void *)1) +#define FUTURE_FAIL ((void *)0) + +// Constructs a new future_t object. Returns NULL on failure. +future_t *future_new(void); + +// Constructs a new future_t object with an immediate |value|. No waiting will +// occur in the call to |future_await| because the value is already present. +// Returns NULL on failure. +future_t *future_new_immediate(void *value); + +// Signals that the |future| is ready, passing |value| back to the context +// waiting for the result. Must only be called once for every future. +// |future| may not be NULL. +void future_ready(future_t *future, void *value); + +// Waits for the |future| to be ready. Returns the value set in |future_ready|. +// Frees the future before return. |future| may not be NULL. +void *future_await(future_t *async_result); + +#endif /* __FUTURE_H__ */ diff --git a/components/bt/bluedroid/osi/include/thread.h b/components/bt/bluedroid/osi/include/thread.h index e2c932367c..dcdc2b44ef 100644 --- a/components/bt/bluedroid/osi/include/thread.h +++ b/components/bt/bluedroid/osi/include/thread.h @@ -16,6 +16,8 @@ struct task_evt { typedef struct task_evt TaskEvt_t; enum { + SIG_PRF_START_UP = 0xfc, + SIG_PRF_WORK = 0xfd, SIG_BTU_START_UP = 0xfe, SIG_BTU_WORK = 0xff }; diff --git a/components/bt/bluedroid/profiles/core/bt_prf_sys_main.c b/components/bt/bluedroid/profiles/core/bt_prf_sys_main.c new file mode 100644 index 0000000000..d2eb922d7b --- /dev/null +++ b/components/bt/bluedroid/profiles/core/bt_prf_sys_main.c @@ -0,0 +1,154 @@ +/** + **************************************************************************************** + * + * @file bt_prf_sys_main.c + * + * @brief Application entry point + * + * Copyright (C) Espressif 2016 + * Created by Yulong at 2016/10/13 + * + * + **************************************************************************************** + */ + +#include "thread.h" +#include "bt_prf_sys.h" +#include "fixed_queue.h" +#include "bt_prf_task.h" +#include "gki.h" + +#include + + +tBT_PRF_SYS_CB bt_prf_sys_cb; +fixed_queue_t *bt_profile_msg_queue; + + +static const tBT_PRF_SYS_REG bt_prf_sys_reg = +{ + NULL, + NULL +}; + + +void bt_prf_sys_init(void) +{ + memset(&bt_prf_sys_cb,0,sizeof(tBT_PRF_SYS_CB)); +} + + +/******************************************************************************* +** +** Function bt_prf_sys_event +** +** Description profile task event handler; called from task event handler. +** +** +** Returns void +** +*******************************************************************************/ +void bt_prf_sys_event(BT_HDR *p_msg) +{ + UINT8 id; + BOOLEAN freebuf = TRUE; + + APPL_TRACE_EVENT("profile task got event 0x%x\n", p_msg->event); + + /* get subsystem id from event */ + id = (UINT8) (p_msg->event >> 8); + + /* verify id and call subsystem event handler */ + if ((id < PRF_ID_MAX) && (bt_prf_sys_cb.reg[id] != NULL)) + { + freebuf = (*bt_prf_sys_cb.reg[id]->evt_hdlr)(p_msg); + } + else + { + APPL_TRACE_WARNING("profile task got unregistered event id %d\n", id); + } + + if (freebuf) + { + GKI_freebuf(p_msg); + } + +} + + +/******************************************************************************* +** +** Function bt_prf_sys_register +** +** Description Called by other profile subsystems to register their event +** handler. +** +** Parameters id:the Identifiers index of the profile +** p_reg:the callback event which has been register to the profile task +** Returns void +** +*******************************************************************************/ +void bt_prf_sys_register(UINT8 id, const tBT_PRF_SYS_REG *p_reg) +{ + bt_prf_sys_cb.reg[id] = (tBT_PRF_SYS_REG *) p_reg; + bt_prf_sys_cb.is_reg[id] = TRUE; +} + +/******************************************************************************* +** +** Function bt_prf_sys_deregister +** +** Description Called by other profile subsystems to de-register +** handler. +** +** Parameters id:Identifiers index of the profile +** Returns void +** +*******************************************************************************/ +void bt_prf_sys_deregister(UINT8 id) +{ + bt_prf_sys_cb.is_reg[id] = FALSE; +} + +/******************************************************************************* +** +** Function bt_prf_sys_is_register +** +** Description Called by other profile subsystems to get registeration +** status. +** +** +** Returns void +** +*******************************************************************************/ +BOOLEAN bt_prf_sys_is_register(UINT8 id) +{ + return bt_prf_sys_cb.is_reg[id]; +} + +/******************************************************************************* +** +** Function bt_prf_sys_sendmsg +** +** Description Send a GKI message to the profile task. +** +** +** Returns void +** +*******************************************************************************/ +void bt_prf_sys_sendmsg(void *p_msg) +{ + // There is a race condition that occurs if the stack is shut down while + // there is a procedure in progress that can schedule a task via this + // message queue. This causes |btu_bta_msg_queue| to get cleaned up before + // it gets used here; hence we check for NULL before using it. + if (bt_profile_msg_queue) { + fixed_queue_enqueue(bt_profile_msg_queue, p_msg); + + bt_prf_task_post(SIG_PRF_WORK); + } +} + + + + diff --git a/components/bt/bluedroid/profiles/core/bt_prf_task.c b/components/bt/bluedroid/profiles/core/bt_prf_task.c new file mode 100644 index 0000000000..035c8d4eb7 --- /dev/null +++ b/components/bt/bluedroid/profiles/core/bt_prf_task.c @@ -0,0 +1,133 @@ +/** + **************************************************************************************** + * + * @file bt_prf_task.c + * + * @brief Application entry point + * + * Copyright (C) Espressif 2016 + * Created by Yulong at 2016/10/11 + * + * + **************************************************************************************** + */ + +#include "bt_prf_task.h" +#include "bt_prf_sys.h" +#include "allocator.h" +#include "thread.h" +#include "gki.h" + + //thread_t *bt_workqueue_thread; + //static const char *BT_WORKQUEUE_NAME = "bt_workqueue"; + xTaskHandle xProfileTaskHandle = NULL; + xQueueHandle xProfileQueue = 0; + + // Communication queue between bt_proflie_task and app. + extern fixed_queue_t *bt_profile_msg_queue; + + + /***************************************************************************** + ** + ** Function bt_prf_task_thread_handler + ** + ** Description Process profile Task Thread. + ******************************************************************************/ + void bt_prf_task_thread_handler(void *arg) + { + //ke_event_clear(KE_EVENT_BTU_TASK_THREAD); + + TaskEvt_t *e; + for (;;) { + if (pdTRUE == xQueueReceive(xProfileQueue, &e, (portTickType)portMAX_DELAY)) { + + if (e->sig == SIG_BTU_WORK) { + fixed_queue_process(bt_profile_msg_queue); + + } + else if (e->sig == SIG_BTU_START_UP) { + bt_prf_task_start_up(); + } + osi_free(e); + } + } + } + + void bt_prf_task_post(uint32_t sig) +{ + TaskEvt_t *evt = (TaskEvt_t *)osi_malloc(sizeof(TaskEvt_t)); + if (evt == NULL) + return; + + evt->sig = sig; + evt->par = 0; + + if (xQueueSend(xProfileQueue, &evt, 10/portTICK_RATE_MS) != pdTRUE) { + ets_printf("xProfileQueue failed\n"); + } +} + +void bt_profile_msg_ready(fixed_queue_t *queue) { + BT_HDR *p_msg; + + while (!fixed_queue_is_empty(queue)) { + p_msg = (BT_HDR *)fixed_queue_dequeue(queue); + if(p_msg != NULL) + { + bt_prf_sys_event(p_msg); + } + } +} + + +void bt_prf_task_start_up(void) +{ + fixed_queue_register_dequeue(bt_profile_msg_queue, bt_profile_msg_ready); +} + +void bt_prf_task_shut_down(void) +{ + fixed_queue_unregister_dequeue(bt_profile_msg_queue); + + bt_prf_free_core(); +} + + +void bt_prf_StartUp(void) +{ + bt_profile_msg_queue = fixed_queue_new(SIZE_MAX); + if (bt_profile_msg_queue == NULL) + goto error_exit; + + return; + +error_exit:; + LOG_ERROR("%s Unable to allocate resources for bt_workqueue\n", __func__); + bt_prf_ShutDown(); + +} + +void bt_prf_ShutDown(void) +{ + + bt_prf_task_shut_down(); + + //thread_free(bt_workqueue_thread); + vTaskDelete(xProfileTaskHandle); + vQueueDelete(xProfileQueue); + + bt_profile_msg_queue = NULL; + + // bt_workqueue_thread = NULL; + xProfileTaskHandle = NULL; + xProfileQueue = 0; +} + + +void bt_prf_free_core(void) +{ + +} + + + diff --git a/components/bt/bluedroid/profiles/core/bt_profile_act.c b/components/bt/bluedroid/profiles/core/bt_profile_act.c new file mode 100644 index 0000000000..df75d780fd --- /dev/null +++ b/components/bt/bluedroid/profiles/core/bt_profile_act.c @@ -0,0 +1,17 @@ +/** + **************************************************************************************** + * + * @file bt_profile_act.c + * + * @brief Application entry point + * + * Copyright (C) Espressif 2016 + * Created by Yulong at 2016/10/13 + * + * + **************************************************************************************** + */ + + + + diff --git a/components/bt/bluedroid/profiles/core/include/bt_prf_evt.h b/components/bt/bluedroid/profiles/core/include/bt_prf_evt.h new file mode 100644 index 0000000000..03bef46b1d --- /dev/null +++ b/components/bt/bluedroid/profiles/core/include/bt_prf_evt.h @@ -0,0 +1,134 @@ +/** + **************************************************************************************** + * + * @file bt_prf_task.h + * + * @brief Application entry point + * + * Copyright (C) Espressif 2016 + * Created by Yulong at 2016/10/12 + * + * + **************************************************************************************** + */ + +#include + +enum +{ + API_BLE_DEVICE_READY_IND, + API_BLE_DM_CMP_EVT, + API_BLE_CONN_CMP_EVT, + API_BLE_CONN_REQ_IND, + API_BLE_DISCONN_IND, + API_BLE_MODULE_INIT_CMP_EVT, + API_BLE_ADV_REPORT_IND, + +#if (BLE_SEC) + API_BLE_BOND_REQ_IND, + API_BLE_BOND_REQ_IND, + API_BLE_ENCRYPT_REQ_IND, + API_BLE_ENCRYPT_IND, +#endif ///BLE_SEC + +#if (BLE_DISS_SERVER) + API_BLE_CREATE_DB_CFM, + API_BLE_DISABLE_IND, +#endif ///BLE_DISS_SERVER + +#if (BLE_PROX_REPORTER) + API_BLE_PROXR_ALERT_IND, + API_BLE_PXP_TIMER, + API_BLE_PROXR_CREATE_DB_CFM, + API_BLE_PROXR_DISABLE_IND, +#endif ///BLE_PROX_REPORTER + +#if (BLE_BUT_SERVER) + API_BLE_BUT_VAL_RECEIVCE, + API_BLE_CREATE_DB_CFM, + API_BLE_VAL_SEND_CFM, +#endif ///BLE_BUT_SERVER + +#if (BLE_APP_KEYBOARD) + API_BLE_HIDD_CREATE_DB_CFM, + API_BLE_DISABLE_IND, + API_BLE_NTF_SENT_CFM, + API_BLE_HIDD_TIMER, + API_BLE_GREEN_LED_TIMER, + API_BLE_RED_LED_TIMER, +#ifndef MITM_ON + API_BLE_HIDD_ENC_TIMER, +#endif ///MITM_ON + API_BLE_UPDATED_PRIVACY_IND, + API_BLE_UPDATED_RECON_ADDR_IND, + API_BLE_HID_MSG, +#endif ///BLE_APP_KEYBOARD + +#if (BLE_BATT_SERVER) + API_BLE_BATT_CREATE_DB_CFM, + API_BLE_BATT_LEVEL_UPD_CFM, + API_BLE_BATT_LEVEL_NTF_CFG_IND, + API_BLE_BATT_TIMER, + APP_BLE_ALERT_TIMER, +#endif ///BLE_BATT_SERVER + +#if (BLE_FINDME_TARGET) + API_BLE_FINDT_ALERT_IND, +#endif ///BLE_FINDME_TARGET + +#if (BLE_FINDME_LOCATOR) + API_BLE_FINDL_ENABLE_CFM, +#endif ///BLE_FINDME_LOCATOR + +#if (HAS_MULTI_BOND) + API_BLE_PAIR_TIMER, +#endif ///HAS_MULTI_BOND + +#if (BLE_SPOTA_RECEIVER) + API_BLE_SPOTAR_PATCH_MEM_DEV_IND, + API_BLE_SPOTAR_GPIO_MAP_IND, + API_BLE_SPOTAR_PATCH_LEN_IND, + API_BLE_SPOTAR_PATCH_DATA_IND, + API_BLE_SPOTAR_CREATE_DB_CFM, +#endif ///BLE_SPOTA_RECEIVER + +#if (BLE_APP_SMARTTAG) + API_BLE_ADV_TIMER, + API_BLE_ADV_BLINK_TIMER, + API_BLE_WAKEUP_MSG, +#endif ///BLE_APP_SMARTTAG + +#if (BLE_APP_PROXR) + API_BLE_ADV_TIMER, + API_BLE_WAKEUP_MSG, +#endif ///BLE_APP_PROXR + +#if (BLE_INTEGRATED_HOST_GTL_CENTRAL) + API_BLE_EXT_TEST_REQ, + API_BLE_EXT_SCAN_CMD, + API_BLE_EXT_CONNECT_CMD, + API_BLE_EXT_DISCONNECT_CMD, + API_BLE_EXT_TRANSMIT_CMD, +#endif ///BLE_INTEGRATED_HOST_GTL + +#if (BLE_APP_THROUGHPUT_PERIPHERAL) + API_BLE_EXT_TEST_REQ, + API_BLE_EXT_DISCONNECT_CMD, + API_BLE_EXT_TRANSMIT_CMD, +#endif ///BLE_APP_THROUGHPUT_PERIPHERAL + +#if (BLE_STREAMDATA_HOST) + API_BLE_STREAMDATAH_ENABLE_CFM, + API_BLE_STREAMDATAH_RCV_DATA_PACKET_IND, +#endif ///BLE_STREAMDATA_HOST + +#if (BLE_STREAMDATA_DEVICE) + API_BLE_STREAMDATAD_CREATE_DB_CFM, + API_BLE_STREAMDATAD_RCV_DATA_PACKET_IND, +#endif ///BLE_STREAMDATA_DEVICE + + + +}; + + diff --git a/components/bt/bluedroid/profiles/core/include/bt_prf_sys.h b/components/bt/bluedroid/profiles/core/include/bt_prf_sys.h new file mode 100644 index 0000000000..9043e8e823 --- /dev/null +++ b/components/bt/bluedroid/profiles/core/include/bt_prf_sys.h @@ -0,0 +1,86 @@ +/** + **************************************************************************************** + * + * @file bt_prf_sys.h + * + * @brief Application entry point + * + * Copyright (C) Espressif 2016 + * Created by Yulong at 2016/10/12 + * + * + **************************************************************************************** + */ + +#ifndef _PROFILE_SYS_H__ +#define _PROFILE_SYS_H__ + +#include "bt_types.h" + +enum +{ + PRF_ID_SYS, + PRF_ID_CONN, + PRF_ID_HIDD_LE, + PRF_ID_HIDH_LE, + PRF_ID_DISS_LE, + PRF_ID_DISC_LE, + PRF_ID_AIRSYNC_LE, + PRF_ID_ANCC_LE, + PRF_ID_BUT_LE, + + PRF_ID_MAX +}; + +typedef UINT8 tBT_PRF_SYS_CONN_STATUS; + + +/* disable function type */ +typedef void (tBT_PRF_SYS_DISABLE)(void); +/* event handler function type */ +typedef BOOLEAN (tBT_PRF_SYS_EVT_HDLR)(BT_HDR *p_msg); + +/* conn callback for role / low power manager*/ +typedef void (tBT_PRF_SYS_CONN_CBACK)(tBT_PRF_SYS_CONN_STATUS status, + UINT8 id, UINT8 app_id, BD_ADDR peer_addr); + +/* Calculate start of event enumeration; id is top 8 bits of event */ +#define BT_PRF_SYS_EVT_START(id) ((id) << 8) + + + +/* registration structure */ +typedef struct +{ + tBT_PRF_SYS_EVT_HDLR *evt_hdlr; + tBT_PRF_SYS_DISABLE *disable; +} tBT_PRF_SYS_REG; + +/* system manager control block */ +typedef struct +{ + tBT_PRF_SYS_REG *reg[PRF_ID_MAX]; /* registration structures */ + BOOLEAN is_reg[PRF_ID_MAX]; /* registration structures */ + tBT_PRF_SYS_CONN_CBACK *prm_cb; /* role management callback registered by DM */ + tBT_PRF_SYS_CONN_CBACK *ppm_cb; /* low power management callback registered by DM */ + tBT_PRF_SYS_CONN_CBACK *p_policy_cb; /* link policy change callback registered by DM */ + +} tBT_PRF_SYS_CB; + + +extern tBT_PRF_SYS_CB bt_prf_sys_cb; + + +extern void bt_prf_sys_init(void); +extern void bt_prf_sys_free(void); +extern void bt_prf_sys_event(BT_HDR *p_msg); + +extern void bt_prf_sys_register(UINT8 id, const tBT_PRF_SYS_REG *p_reg); +extern void bt_prf_sys_deregister(UINT8 id); +extern BOOLEAN bt_prf_sys_is_register(UINT8 id); + +extern void bt_prf_sys_idle(UINT8 id, UINT8 app_id, BD_ADDR peer_addr); +extern void bt_prf_sys_busy(UINT8 id, UINT8 app_id, BD_ADDR peer_addr); + + +#endif ///_PROFILE_SYS_H__ diff --git a/components/bt/bluedroid/profiles/core/include/bt_prf_task.h b/components/bt/bluedroid/profiles/core/include/bt_prf_task.h new file mode 100644 index 0000000000..4077987698 --- /dev/null +++ b/components/bt/bluedroid/profiles/core/include/bt_prf_task.h @@ -0,0 +1,50 @@ +/** + **************************************************************************************** + * + * @file bt_prf_task.h + * + * @brief Application entry point + * + * Copyright (C) Espressif 2016 + * Created by Yulong at 2016/10/11 + * + * + **************************************************************************************** + */ + +#include +#include "bt_defs.h" +#include "fixed_queue.h" + +#ifndef BT_PRF_TASK_H__ +#define BT_PRF_TASK_H__ + +/* Functions provided by btu_core.c +************************************ +*/ + + +void bt_prf_task_thread_handler(void *arg); + +void bt_prf_init_core(void); +void bt_prf_free_core(void); + +void bt_prf_task_post(uint32_t sig); + + +void bt_prf_StartUp(void); +void bt_prf_ShutDown(void); + +void bt_prf_task_start_up(void); +void bt_prf_task_shut_down(void); + +void bt_profile_msg_ready(fixed_queue_t *queue); + + + + + + + + +#endif /// BT_PRF_TASK_H__ diff --git a/components/bt/bluedroid/profiles/esp/ble_button/button_pro.c b/components/bt/bluedroid/profiles/esp/ble_button/button_pro.c index b7c16fb9af..a4cbfe4623 100644 --- a/components/bt/bluedroid/profiles/esp/ble_button/button_pro.c +++ b/components/bt/bluedroid/profiles/esp/ble_button/button_pro.c @@ -26,9 +26,13 @@ #include "bta_api.h" #include "bta_gatt_api.h" #include "bta_gatts_int.h" - #include "button_pro.h" +#include "prf_defs.h" + +#if (BUT_PROFILE_CFG) + + #define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0])) tBUTTON_CB_ENV button_cb_env; @@ -66,7 +70,7 @@ static void button_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data) LOG_ERROR("button profile cb event = %x\n",event); switch(event) { - case BTA_GATTS_REG_EVT: + case BTA_GATTS_REG_EVT: LOG_ERROR("p_data->reg_oper.status = %x\n",p_data->reg_oper.status); LOG_ERROR("(p_data->reg_oper.uuid.uu.uuid16=%x\n",p_data->reg_oper.uuid.uu.uuid16); @@ -104,7 +108,8 @@ static void button_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data) p_rec_data = &p_data->req_data.p_data->write_req.value[0]; // button_msg_notify(len,p_rec_data); (*p_inst->p_cback)(button_cb_env.button_inst.app_id,net_event,len,p_rec_data); - } + + } break; case BTA_GATTS_CONF_EVT: @@ -193,7 +198,7 @@ void Button_CreateService(void) { tBTA_GATTS_IF server_if ; tBT_UUID uuid = {LEN_UUID_16, {ATT_SVC_BUTTON}}; - UINT16 num_handle = KEY_IDX_NB; + UINT16 num_handle = KEY_IDX_NB; UINT8 inst = 0x00; server_if = button_cb_env.gatt_if; button_cb_env.inst_id = inst; @@ -201,7 +206,7 @@ void Button_CreateService(void) //{ // LOG_ERROR("button service added error."); //} - BTA_GATTS_CreateService(server_if,&uuid,inst,num_handle,true); + BTA_GATTS_CreateService(server_if,&uuid,inst,num_handle,true); } @@ -321,7 +326,7 @@ tGATT_STATUS button_init (tBU_CBACK *call_back) } - /* register the button profile to the BTA_GATTS module*/ + /* register the button profile to the BTA_GATTS module*/ BTA_GATTS_AppRegister(&app_uuid,button_profile_cb); button_cb_env.enabled = TRUE; @@ -345,3 +350,5 @@ void button_msg_notify(UINT8 len, UINT8 *button_msg) BTA_GATTS_HandleValueIndication (conn_id, attr_id, len, button_msg, rsp); } + +#endif ///BUT_PROFILE_CFG diff --git a/components/bt/bluedroid/profiles/esp/include/button_pro.h b/components/bt/bluedroid/profiles/esp/include/button_pro.h index 954e4acb46..d9028830b2 100644 --- a/components/bt/bluedroid/profiles/esp/include/button_pro.h +++ b/components/bt/bluedroid/profiles/esp/include/button_pro.h @@ -11,7 +11,9 @@ * **************************************************************************************** */ +#include "prf_defs.h" +#if (BUT_PROFILE_CFG) #include "bt_target.h" #include "gatt_api.h" #include "gattdefs.h" @@ -117,3 +119,4 @@ void button_msg_notify(UINT8 len, UINT8 *button_msg); extern tBUTTON_CB_ENV button_cb_env; +#endif ///BUT_PROFILE_CFG \ No newline at end of file diff --git a/components/bt/bluedroid/profiles/esp/include/wx_airsync_prf.h b/components/bt/bluedroid/profiles/esp/include/wx_airsync_prf.h new file mode 100644 index 0000000000..1883b839c0 --- /dev/null +++ b/components/bt/bluedroid/profiles/esp/include/wx_airsync_prf.h @@ -0,0 +1,115 @@ +/** + **************************************************************************************** + * + * @file wx_airsync_prf.h + * + * @brief Application entry point + * + * Copyright (C) Espressif 2016 + * Created by Yulong at 2016/9/29 + * + * + **************************************************************************************** + */ + +#include "prf_defs.h" + +#if (WX_AIRSYNC_CFG) + +#include "bt_target.h" +#include "gatt_api.h" +#include "gattdefs.h" + + +/// Maximum Transmission Unit +#define ATT_DEFAULT_MTU (23) + +#define BLE_WECHAT_MAX_DATA_LEN (ATT_DEFAULT_MTU - 3) + + + //define the key serivce uuid +#define ATT_SVC_AIRSYNC 0xFEE7 + //define the airsync Char uuid +#define ATT_CHAR_AIRSYNC_WIT 0xFEC7 +#define ATT_CHAR_AIRSYBC_NTF 0xFEC8 +#define ATT_CHAR_AIRSYNC_READ 0xFEC9 + + +typedef void (tAIRSYNC_CBACK)(UINT8 app_id, UINT8 event, UINT8 len, UINT8 *data); + + + /// WX AirSync Service Attributes Indexes + enum + { + WX_IDX_SVC, + WX_IDX_AIRSYNC_WIT_CHAR, + WX_IDX_AIRSYNC_WIT_VAL, + WX_IDX_AIRSYNC_NTF_CHAR, + WX_IDX_AIRSYNC_NTF_VAL, + WX_IDX_AIRSYNC_READ_CHAR, + WX_IDX_AIRSYNC_READ_VAL, + WX_IDX_AIRSYNC_NTF_CFG, + + KEY_IDX_NB, + }; + + typedef struct + { + BD_ADDR remote_bda; + BOOLEAN need_rsp; + UINT16 clt_cfg; + }tAirSync_WRITE_DATA; + + typedef struct + { + BOOLEAN in_use; + BOOLEAN congest; + UINT16 conn_id; + BOOLEAN connected; + BD_ADDR remote_bda; + UINT32 trans_id; + UINT8 cur_srvc_id; + + }tAirSync_CLCB; + + + typedef struct + { + UINT8 app_id; + UINT16 airsync_wirt_hdl; + UINT16 airsync_ntf_hdl; + UINT16 airsync_read_hdl; + UINT16 airsync_cfg_hdl; + + tAIRSYNC_CBACK *p_cback; + + }tAirSync_INST; + + + /* service engine control block */ + typedef struct + { + tAirSync_CLCB clcb; /* connection link*/ + tGATT_IF gatt_if; + BOOLEAN enabled; + BOOLEAN is_primery; + tAirSync_INST airsync_inst; + UINT8 inst_id; + }tAIRSYNC_CB_ENV; + + void AirSync_CreateService(void); + + tAirSync_CLCB *airsync_env_clcb_alloc (UINT16 conn_id, BD_ADDR remote_bda); + + UINT16 AirSync_env_find_conn_id_by_bd_adddr(BD_ADDR bda); + + BOOLEAN AirSync_env_clcb_dealloc(UINT16 conn_id); + + tGATT_STATUS AirSync_Init(tAIRSYNC_CBACK *call_back); + + void AirSync_msg_notify(UINT8 len, UINT8 *button_msg); + + extern tAIRSYNC_CB_ENV airsync_cb_env; + + #endif ///WX_AIRSYNC_CFG + diff --git a/components/bt/bluedroid/profiles/esp/wechat_AirSync/wx_airsync_prf.c b/components/bt/bluedroid/profiles/esp/wechat_AirSync/wx_airsync_prf.c new file mode 100644 index 0000000000..821195d444 --- /dev/null +++ b/components/bt/bluedroid/profiles/esp/wechat_AirSync/wx_airsync_prf.c @@ -0,0 +1,286 @@ +/** + **************************************************************************************** + * + * @file wx_airsync_prf.c + * + * @brief Application entry point + * + * Copyright (C) Espressif 2016 + * Created by Yulong at 2016/9/29 + * + * + **************************************************************************************** + */ +#include "wx_airsync_prf.h" + +#if (WX_AIRSYNC_CFG) + +#include + +#include +#include +#include + +#include "bt_target.h" +#include "bt_trace.h" +#include "bt_types.h" +#include "gatt_api.h" +#include "bta_api.h" +#include "bta_gatt_api.h" +#include "bta_gatts_int.h" + + + +tAIRSYNC_CB_ENV airsync_cb_env; + + +/***************************************************************************** +** Constants +*****************************************************************************/ +static void airsync_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data); + + +/******************************************************************************* +** +** Function airsync_profile_cb +** +** Description the callback function after the profile has been register to the BTA manager module +** +** Returns NULL +** +*******************************************************************************/ +static void airsync_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data) +{ + tBTA_GATTS_RSP rsp; + tBT_UUID uuid = {LEN_UUID_16, {ATT_SVC_AIRSYNC}}; + tAirSync_INST *p_inst = &airsync_cb_env.airsync_inst; + + + LOG_ERROR("airsync profile cb event = %x\n",event); + switch(event) + { + case BTA_GATTS_REG_EVT: + + if(p_data->reg_oper.status != BTA_GATT_OK) + { + LOG_ERROR("button profile register failed\n"); + } + airsync_cb_env.gatt_if = p_data->reg_oper.server_if; + airsync_cb_env.enabled = true; + + if(p_data->reg_oper.uuid.uu.uuid16 == ATT_SVC_AIRSYNC) + { + AirSync_CreateService(); + } + break; + case BTA_GATTS_READ_EVT: + + if(airsync_cb_env.clcb.connected && airsync_cb_env.enabled){ + //tBTA_GATTS_RSP rsp; + memset(&rsp,0,sizeof(tBTA_GATTS_API_RSP)); + rsp.attr_value.handle = p_data->req_data.p_data->read_req.handle; + rsp.attr_value.len = 2; + BTA_GATTS_SendRsp(p_data->req_data.conn_id,p_data->req_data.trans_id, + p_data->req_data.status,&rsp); + } + break; + case BTA_GATTS_WRITE_EVT: + if(airsync_cb_env.clcb.connected && airsync_cb_env.enabled){ + BTA_GATTS_SendRsp(p_data->req_data.conn_id,p_data->req_data.trans_id, + p_data->req_data.status,NULL); + + } + break; + case BTA_GATTS_CONF_EVT: + + break; + case BTA_GATTS_CREATE_EVT: + uuid.uu.uuid16 = ATT_CHAR_AIRSYNC_WIT; + + airsync_cb_env.clcb.cur_srvc_id= p_data->create.service_id; + airsync_cb_env.is_primery = p_data->create.is_primary; + //start the airsync service after created + BTA_GATTS_StartService(p_data->create.service_id,BTA_GATT_TRANSPORT_LE); + //add the frist airsync characteristic --> write characteristic + BTA_GATTS_AddCharacteristic(airsync_cb_env.clcb.cur_srvc_id,&uuid, + (GATT_PERM_WRITE|GATT_PERM_READ), + (GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_WRITE)); + break; + + case BTA_GATTS_ADD_CHAR_EVT: + if(p_data->add_result.char_uuid.uu.uuid16 == ATT_CHAR_AIRSYNC_WIT) + { + uuid.uu.uuid16 = ATT_CHAR_AIRSYBC_NTF; + //tBTA_GATT_PERM perm = GATT_PERM_READ; + //tBTA_GATT_CHAR_PROP prop = (GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_NOTIFY); + //save the att handle to the env + airsync_cb_env.airsync_inst.airsync_wirt_hdl = p_data->add_result.attr_id; + //add the second airsync characteristic --> Notify characteristic + BTA_GATTS_AddCharacteristic(airsync_cb_env.clcb.cur_srvc_id,&uuid, + GATT_PERM_READ,(GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_INDICATE)); + }else if(p_data->add_result.char_uuid.uu.uuid16 == ATT_CHAR_AIRSYBC_NTF){ + //tBTA_GATT_PERM perm = (GATT_PERM_WRITE|GATT_PERM_WRITE); + uuid.uu.uuid16 = GATT_UUID_CHAR_CLIENT_CONFIG; + airsync_cb_env.airsync_inst.airsync_ntf_hdl = p_data->add_result.attr_id; + BTA_GATTS_AddCharDescriptor (airsync_cb_env.clcb.cur_srvc_id, + (GATT_PERM_WRITE|GATT_PERM_WRITE), + &uuid); + + uuid.uu.uuid16 = ATT_CHAR_AIRSYNC_READ; + //add the third airsync characteristic --> Read characteristic + BTA_GATTS_AddCharacteristic(airsync_cb_env.clcb.cur_srvc_id,&uuid, + GATT_PERM_READ, + GATT_CHAR_PROP_BIT_READ); + }else if(p_data->add_result.char_uuid.uu.uuid16 == ATT_CHAR_AIRSYNC_READ){ + airsync_cb_env.airsync_inst.airsync_read_hdl = p_data->add_result.attr_id; + } + + break; + case BTA_GATTS_ADD_CHAR_DESCR_EVT: + if(p_data->add_result.char_uuid.uu.uuid16 == GATT_UUID_CHAR_CLIENT_CONFIG) + { + airsync_cb_env.airsync_inst.airsync_cfg_hdl = p_data->add_result.attr_id; + } + break; + case BTA_GATTS_CONNECT_EVT: + //set the connection flag to true + airsync_env_clcb_alloc(p_data->conn.conn_id, p_data->conn.remote_bda); + break; + case BTA_GATTS_DISCONNECT_EVT: + //set the connection flag to true + airsync_cb_env.clcb.connected = false; + break; + case BTA_GATTS_OPEN_EVT: + break; + case BTA_GATTS_CLOSE_EVT: + if(airsync_cb_env.clcb.connected && (airsync_cb_env.clcb.conn_id == p_data->conn.conn_id)) + { + //set the connection channal congested flag to true + airsync_cb_env.clcb.congest = p_data->congest.congested; + } + break; + case BTA_GATTS_LISTEN_EVT: + break; + case BTA_GATTS_CONGEST_EVT: + //set the congest flag + airsync_cb_env.clcb.congest = p_data->congest.congested; + break; + default: + break; + } +} + + +/******************************************************************************* +** +** Function AirSync_CreateService +** +** Description Create a Service for the airsync profile +** +** Returns NULL +** +*******************************************************************************/ +void AirSync_CreateService(void) +{ + tBTA_GATTS_IF server_if ; + tBT_UUID uuid = {LEN_UUID_16, {ATT_SVC_AIRSYNC}}; + UINT16 num_handle = KEY_IDX_NB; + UINT8 inst = 0x00; + server_if = airsync_cb_env.gatt_if; + airsync_cb_env.inst_id = inst; + + BTA_GATTS_CreateService(server_if,&uuid,inst,num_handle,true); + +} + +/******************************************************************************* +** +** Function airsync_env_clcb_alloc +** +** Description The function allocates a GATT profile connection link control block +** +** Returns NULL if not found. Otherwise pointer to the connection link block. +** +*******************************************************************************/ +tAirSync_CLCB *airsync_env_clcb_alloc (UINT16 conn_id, BD_ADDR remote_bda) +{ + tAirSync_CLCB *p_clcb = NULL; + p_clcb = &airsync_cb_env.clcb; + + if(!p_clcb->in_use) + { + p_clcb->in_use = TRUE; + p_clcb->conn_id = conn_id; + LOG_ERROR("p_clcb->conn_id = %x\n",conn_id); + p_clcb->connected = TRUE; + memcpy(p_clcb->remote_bda,remote_bda,BD_ADDR_LEN); + } + + return p_clcb; +} + +/******************************************************************************* +** +** Function airsync_env_find_conn_id_by_bd_adddr +** +** Description The function searches all LCB with macthing bd address +** +** Returns total number of clcb found. +** +*******************************************************************************/ +UINT16 airsync_env_find_conn_id_by_bd_adddr(BD_ADDR remote_bda) +{ + UINT8 i_clcb; + tAirSync_CLCB *p_clcb = NULL; + + for(i_clcb = 0, p_clcb = &airsync_cb_env.clcb; i_clcb < 1; i_clcb++, p_clcb++) + { + if(p_clcb->in_use && p_clcb->connected &&memcmp(p_clcb->remote_bda,remote_bda,BD_ADDR_LEN)) + { + return p_clcb->conn_id; + } + } + + return GATT_INVALID_CONN_ID; +} + + +/******************************************************************************* +** +** Function airsync_init +** +** Description Initializa the GATT Service for airsync profiles. +** +*******************************************************************************/ +tGATT_STATUS AirSync_Init(tAIRSYNC_CBACK *call_back) +{ + tBT_UUID app_uuid = {LEN_UUID_16,{ATT_SVC_AIRSYNC}}; + + + if(airsync_cb_env.enabled) + { + LOG_ERROR("airsync svc already initaliezd\n"); + return GATT_ERROR; + } + else + { + memset(&airsync_cb_env,0,sizeof(tAIRSYNC_CB_ENV)); + } + + + if(call_back != NULL) + { + airsync_cb_env.airsync_inst.p_cback = call_back; + } + + + /* register the airsync profile to the BTA_GATTS module*/ + BTA_GATTS_AppRegister(&app_uuid,airsync_profile_cb); + + airsync_cb_env.enabled = TRUE; + + return GATT_SUCCESS; +} + +#endif ///WX_AIRSYNC_CFG + diff --git a/components/bt/bluedroid/profiles/std/hid_le/hid_le_prf.c b/components/bt/bluedroid/profiles/std/hid_le/hid_le_prf.c index 98ae546b9d..61037ae5ef 100644 --- a/components/bt/bluedroid/profiles/std/hid_le/hid_le_prf.c +++ b/components/bt/bluedroid/profiles/std/hid_le/hid_le_prf.c @@ -14,13 +14,173 @@ #include #include "hid_le_prf.h" #include "prf_defs.h" -#include "bta_gatt_api.h" +#if (HIDD_LE_PROFILE_CFG) tHIDD_LE_ENV hidd_le_env; +#define HI_UINT16(a) (((a) >> 8) & 0xFF) +#define LO_UINT16(a) ((a) & 0xFF) + + +// HID Information characteristic value +static const UINT8 hidInfo[HID_INFORMATION_LEN] = +{ + LO_UINT16(0x0111), HI_UINT16(0x0111), // bcdHID (USB HID version) + 0x00, // bCountryCode + HID_KBD_FLAGS // Flags +}; + +// HID Report Map characteristic value +// Keyboard report descriptor (using format for Boot interface descriptor) +static const UINT8 hidReportMap[] = +{ + 0x05, 0x01, // Usage Page (Generic Desktop) + 0x09, 0x02, // Usage (Mouse) + 0xA1, 0x01, // Collection (Application) + 0x85, 0x01, // Report Id (1) + 0x09, 0x01, // Usage (Pointer) + 0xA1, 0x00, // Collection (Physical) + 0x05, 0x09, // Usage Page (Buttons) + 0x19, 0x01, // Usage Minimum (01) - Button 1 + 0x29, 0x03, // Usage Maximum (03) - Button 3 + 0x15, 0x00, // Logical Minimum (0) + 0x25, 0x01, // Logical Maximum (1) + 0x75, 0x01, // Report Size (1) + 0x95, 0x03, // Report Count (3) + 0x81, 0x02, // Input (Data, Variable, Absolute) - Button states + 0x75, 0x05, // Report Size (5) + 0x95, 0x01, // Report Count (1) + 0x81, 0x01, // Input (Constant) - Padding or Reserved bits + 0x05, 0x01, // Usage Page (Generic Desktop) + 0x09, 0x30, // Usage (X) + 0x09, 0x31, // Usage (Y) + 0x09, 0x38, // Usage (Wheel) + 0x15, 0x81, // Logical Minimum (-127) + 0x25, 0x7F, // Logical Maximum (127) + 0x75, 0x08, // Report Size (8) + 0x95, 0x03, // Report Count (3) + 0x81, 0x06, // Input (Data, Variable, Relative) - X & Y coordinate + 0xC0, // End Collection + 0xC0, // End Collection + + 0x05, 0x01, // Usage Pg (Generic Desktop) + 0x09, 0x06, // Usage (Keyboard) + 0xA1, 0x01, // Collection: (Application) + 0x85, 0x02, // Report Id (2) + // + 0x05, 0x07, // Usage Pg (Key Codes) + 0x19, 0xE0, // Usage Min (224) + 0x29, 0xE7, // Usage Max (231) + 0x15, 0x00, // Log Min (0) + 0x25, 0x01, // Log Max (1) + // + // Modifier byte + 0x75, 0x01, // Report Size (1) + 0x95, 0x08, // Report Count (8) + 0x81, 0x02, // Input: (Data, Variable, Absolute) + // + // Reserved byte + 0x95, 0x01, // Report Count (1) + 0x75, 0x08, // Report Size (8) + 0x81, 0x01, // Input: (Constant) + // + // LED report + 0x95, 0x05, // Report Count (5) + 0x75, 0x01, // Report Size (1) + 0x05, 0x08, // Usage Pg (LEDs) + 0x19, 0x01, // Usage Min (1) + 0x29, 0x05, // Usage Max (5) + 0x91, 0x02, // Output: (Data, Variable, Absolute) + // + // LED report padding + 0x95, 0x01, // Report Count (1) + 0x75, 0x03, // Report Size (3) + 0x91, 0x01, // Output: (Constant) + // + // Key arrays (6 bytes) + 0x95, 0x06, // Report Count (6) + 0x75, 0x08, // Report Size (8) + 0x15, 0x00, // Log Min (0) + 0x25, 0x65, // Log Max (101) + 0x05, 0x07, // Usage Pg (Key Codes) + 0x19, 0x00, // Usage Min (0) + 0x29, 0x65, // Usage Max (101) + 0x81, 0x00, // Input: (Data, Array) + // + 0xC0, // End Collection + // + 0x05, 0x0C, // Usage Pg (Consumer Devices) + 0x09, 0x01, // Usage (Consumer Control) + 0xA1, 0x01, // Collection (Application) + 0x85, 0x03, // Report Id (3) + 0x09, 0x02, // Usage (Numeric Key Pad) + 0xA1, 0x02, // Collection (Logical) + 0x05, 0x09, // Usage Pg (Button) + 0x19, 0x01, // Usage Min (Button 1) + 0x29, 0x0A, // Usage Max (Button 10) + 0x15, 0x01, // Logical Min (1) + 0x25, 0x0A, // Logical Max (10) + 0x75, 0x04, // Report Size (4) + 0x95, 0x01, // Report Count (1) + 0x81, 0x00, // Input (Data, Ary, Abs) + 0xC0, // End Collection + 0x05, 0x0C, // Usage Pg (Consumer Devices) + 0x09, 0x86, // Usage (Channel) + 0x15, 0xFF, // Logical Min (-1) + 0x25, 0x01, // Logical Max (1) + 0x75, 0x02, // Report Size (2) + 0x95, 0x01, // Report Count (1) + 0x81, 0x46, // Input (Data, Var, Rel, Null) + 0x09, 0xE9, // Usage (Volume Up) + 0x09, 0xEA, // Usage (Volume Down) + 0x15, 0x00, // Logical Min (0) + 0x75, 0x01, // Report Size (1) + 0x95, 0x02, // Report Count (2) + 0x81, 0x02, // Input (Data, Var, Abs) + 0x09, 0xE2, // Usage (Mute) + 0x09, 0x30, // Usage (Power) + 0x09, 0x83, // Usage (Recall Last) + 0x09, 0x81, // Usage (Assign Selection) + 0x09, 0xB0, // Usage (Play) + 0x09, 0xB1, // Usage (Pause) + 0x09, 0xB2, // Usage (Record) + 0x09, 0xB3, // Usage (Fast Forward) + 0x09, 0xB4, // Usage (Rewind) + 0x09, 0xB5, // Usage (Scan Next) + 0x09, 0xB6, // Usage (Scan Prev) + 0x09, 0xB7, // Usage (Stop) + 0x15, 0x01, // Logical Min (1) + 0x25, 0x0C, // Logical Max (12) + 0x75, 0x04, // Report Size (4) + 0x95, 0x01, // Report Count (1) + 0x81, 0x00, // Input (Data, Ary, Abs) + 0x09, 0x80, // Usage (Selection) + 0xA1, 0x02, // Collection (Logical) + 0x05, 0x09, // Usage Pg (Button) + 0x19, 0x01, // Usage Min (Button 1) + 0x29, 0x03, // Usage Max (Button 3) + 0x15, 0x01, // Logical Min (1) + 0x25, 0x03, // Logical Max (3) + 0x75, 0x02, // Report Size (2) + 0x81, 0x00, // Input (Data, Ary, Abs) + 0xC0, // End Collection + 0x81, 0x03, // Input (Const, Var, Abs) + 0xC0 // End Collection +}; + +// HID report map length +UINT8 hidReportMapLen = sizeof(hidReportMap); + +UINT8 hidProtocolMode = HID_PROTOCOL_MODE_REPORT; + +// HID report mapping table +static hidRptMap_t hidRptMap[HID_NUM_REPORTS]; + + tBT_UUID char_info_uuid = {LEN_UUID_16, {CHAR_HID_INFO_UUID}}; tBT_UUID char_ctnl_pt_uuid = {LEN_UUID_16, {CHAR_HID_CTNL_PT_UUID}}; tBT_UUID char_report_map_uuid = {LEN_UUID_16, {CHAR_REPORT_MAP_UUID}}; +tBT_UUID char_report_uuid = {LEN_UUID_16, {CHAR_REPORT_UUID}}; tBT_UUID char_proto_mode_uuid = {LEN_UUID_16, {CHAR_PROTOCOL_MODE_UUID}}; tBT_UUID char_kb_in_report_uuid = {LEN_UUID_16, {CHAR_BOOT_KB_IN_REPORT_UUID}}; tBT_UUID char_kb_out_report_uuid = {LEN_UUID_16,{CHAR_BOOT_KB_OUT_REPORT_UUID}}; @@ -31,88 +191,90 @@ tBT_UUID char_mouse_in_report_uuid = {LEN_UUID_16,{CHAR_BOOT_MOUSE_IN_REPORT_UUI /// Full HID device Database Description - Used to add attributes into the database const tCHAR_DESC hids_char_db[HIDD_LE_CHAR_MAX] = { - // HID Information Characteristic Value - [HIDD_LE_INFO_CHAR] = { - &char_info_uuid, - GATT_PERM_READ, - GATT_CHAR_PROP_BIT_READ - }, + // HID Information Characteristic Value + [HIDD_LE_INFO_CHAR] = { + &char_info_uuid, + GATT_PERM_READ, + GATT_CHAR_PROP_BIT_READ + }, - // HID Control Point Characteristic Value - [HIDD_LE_CTNL_PT_CHAR] = { - &char_ctnl_pt_uuid, - GATT_PERM_WRITE, - GATT_CHAR_PROP_BIT_WRITE_NR - }, + // HID Control Point Characteristic Value + [HIDD_LE_CTNL_PT_CHAR] = { + &char_ctnl_pt_uuid, + GATT_PERM_WRITE, + GATT_CHAR_PROP_BIT_WRITE_NR + }, - // Report Map Characteristic Value - [HIDD_LE_REPORT_MAP_CHAR] = { - &char_report_map_uuid, - GATT_PERM_READ, - GATT_CHAR_PROP_BIT_READ - }, + // Report Map Characteristic Value + [HIDD_LE_REPORT_MAP_CHAR] = { + &char_report_map_uuid, + GATT_PERM_READ, + GATT_CHAR_PROP_BIT_READ + }, + // Report Characteristic Value + [HIDD_LE_REPORT_CHAR] = { + &char_report_uuid, + (GATT_PERM_READ|GATT_PERM_WRITE), + (GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_WRITE|GATT_CHAR_PROP_BIT_WRITE_NR) + }, + // Protocol Mode Characteristic Declaration + [HIDD_LE_PROTO_MODE_CHAR] = { + &char_proto_mode_uuid, + GATT_PERM_READ, + GATT_CHAR_PROP_BIT_READ, + }, + + // Boot Keyboard Input Report Characteristic Value + [HIDD_LE_BOOT_KB_IN_REPORT_CHAR] = { + &char_kb_in_report_uuid, + GATT_PERM_READ, + (GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_NOTIFY), + + }, + + // Boot Keyboard Output Report Characteristic Value + [HIDD_LE_BOOT_KB_OUT_REPORT_CHAR] = { + &char_kb_out_report_uuid, + GATT_PERM_READ, + (GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_WRITE|GATT_CHAR_PROP_BIT_WRITE_NR) + }, - // Protocol Mode Characteristic Declaration - [HIDD_LE_PROTO_MODE_CHAR] = { - &char_proto_mode_uuid, - GATT_PERM_READ, - GATT_CHAR_PROP_BIT_READ, - }, - - // Boot Keyboard Input Report Characteristic Value - [HIDD_LE_BOOT_KB_IN_REPORT_CHAR] = { - &char_kb_in_report_uuid, - GATT_PERM_READ, - (GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_NOTIFY), - - }, - - // Boot Keyboard Output Report Characteristic Value - [HIDD_LE_BOOT_KB_OUT_REPORT_CHAR] = { - &char_kb_out_report_uuid, - GATT_PERM_READ, - (GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_WRITE|GATT_CHAR_PROP_BIT_WRITE_NR) - }, - - // Boot Mouse Input Report Characteristic Value - [HIDD_LE_BOOT_MOUSE_IN_REPORT_CHAR] = { - &char_mouse_in_report_uuid, - GATT_PERM_READ, - (GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_NOTIFY), - }, + // Boot Mouse Input Report Characteristic Value + [HIDD_LE_BOOT_MOUSE_IN_REPORT_CHAR] = { + &char_mouse_in_report_uuid, + GATT_PERM_READ, + (GATT_CHAR_PROP_BIT_READ|GATT_CHAR_PROP_BIT_NOTIFY), + }, }; - -//tBT_UUID hid_uuid = {LEN_UUID_16, {ATT_SVC_BUTTON}}; - static void HID_AddCharacteristic(const tCHAR_DESC *char_desc); /***************************************************************************** - ** Constants - *****************************************************************************/ +** Constants +*****************************************************************************/ static void hidd_le_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data); /******************************************************************************* - ** - ** Function hidd_le_profile_cb - ** - ** Description the callback function after the hid device profile has been register to the BTA manager module - ** - ** Returns NULL - ** - *******************************************************************************/ +** +** Function hidd_le_profile_cb +** +** Description the callback function after the hid device profile has been register to the BTA manager module +** +** Returns NULL +** +*******************************************************************************/ static void HID_AddCharacteristic(const tCHAR_DESC *char_desc) { UINT16 service_id; if(char_desc == NULL) { - LOG_ERROR("Invalid hid characteristic"); + LOG_ERROR("Invalid hid characteristic\n"); return; } //check the hid device serivce has been register to the data base or not if(!hidd_le_env.enabled) { - LOG_ERROR("The hid device didn't register yet"); + LOG_ERROR("The hid device didn't register yet\n"); return; } //get the service id from the env whitch has been register @@ -121,36 +283,39 @@ static void HID_AddCharacteristic(const tCHAR_DESC *char_desc) { // start added the charact to the data base BTA_GATTS_AddCharacteristic(service_id, - char_desc->char_uuid, - char_desc->perm, - char_desc->prop); + char_desc->char_uuid, + char_desc->perm, + char_desc->prop); } } /******************************************************************************* - ** - ** Function hidd_le_profile_cb - ** - ** Description the callback function after the hid device profile has been register to the BTA manager module - ** - ** Returns NULL - ** - *******************************************************************************/ +** +** Function hidd_le_profile_cb +** +** Description the callback function after the hid device profile has been register to the BTA manager module +** +** Returns NULL +** +*******************************************************************************/ static void hidd_le_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data) { tBTA_GATTS_RSP rsp; tBT_UUID uuid = {LEN_UUID_16, {ATT_SVC_HID}}; static UINT8 hid_char_idx; tHIDD_CLCB *p_clcb = NULL; + UINT8 app_id = 0xff; + switch(event) { case BTA_GATTS_REG_EVT: //check the register of the hid device profile has been succeess or not if(p_data->reg_oper.status != BTA_GATT_OK) { - LOG_ERROR("button profile register failed\n"); + LOG_ERROR("hidd profile register failed\n"); } + hidd_le_env.hidd_inst.app_id = app_id; //save the gatt interface in the hid device ENV hidd_le_env.gatt_if = p_data->reg_oper.server_if; //set the env flag to enable @@ -158,9 +323,9 @@ static void hidd_le_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data) //create the hid device service to the service data base. if(p_data->reg_oper.uuid.uu.uuid16 == ATT_SVC_HID) { - hidd_le_CreateService(true); + hidd_le_CreateService(true); } - break; + break; case BTA_GATTS_CREATE_EVT: if(p_data->create.uuid.uu.uuid16 == ATT_SVC_HID) { @@ -173,39 +338,78 @@ static void hidd_le_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data) HID_AddCharacteristic(&hids_char_db[hid_char_idx]); hid_char_idx++; } - + break; case BTA_GATTS_ADD_INCL_SRVC_EVT: - + break; case BTA_GATTS_ADD_CHAR_EVT: - if(hid_char_idx < HIDD_LE_CHAR_MAX) //added the characteristic until the index overflow + //save the charateristic handle to the env + hidd_le_env.hidd_inst.att_tbl[hid_char_idx-1] = p_data->add_result.attr_id; + LOG_ERROR("hanlder = %x, p_data->add_result.char_uuid.uu.uuid16 = %x\n",p_data->add_result.attr_id, + p_data->add_result.char_uuid.uu.uuid16); + LOG_ERROR("hid_char_idx=%x\n",hid_char_idx); + if(hid_char_idx <= HIDD_LE_CHAR_MAX) //added the characteristic until the index overflow { - HID_AddCharacteristic(&hids_char_db[hid_char_idx]); + if((p_data->add_result.char_uuid.uu.uuid16 == CHAR_BOOT_KB_IN_REPORT_UUID) || - (p_data->add_result.char_uuid.uu.uuid16 == CHAR_BOOT_MOUSE_IN_REPORT_UUID)) + (p_data->add_result.char_uuid.uu.uuid16 == CHAR_BOOT_MOUSE_IN_REPORT_UUID)) { // add the gattc config descriptor to the notify charateristic //tBTA_GATT_PERM perm = (GATT_PERM_WRITE|GATT_PERM_WRITE); uuid.uu.uuid16 = GATT_UUID_CHAR_CLIENT_CONFIG; - + LOG_ERROR("p_data->add_result.char_uuid.uu.uuid16 = %x\n", + p_data->add_result.char_uuid.uu.uuid16); BTA_GATTS_AddCharDescriptor (hidd_le_env.hidd_clcb.cur_srvc_id, - GATT_PERM_WRITE, - &uuid); + GATT_PERM_WRITE, + &uuid); + + + break; } + HID_AddCharacteristic(&hids_char_db[hid_char_idx]); } hid_char_idx++; break; case BTA_GATTS_ADD_CHAR_DESCR_EVT: - + if(p_data->add_result.char_uuid.uu.uuid16 == GATT_UUID_CHAR_CLIENT_CONFIG) + { + uuid.uu.uuid16 = GATT_UUID_RPT_REF_DESCR; + BTA_GATTS_AddCharDescriptor (hidd_le_env.hidd_clcb.cur_srvc_id, + GATT_PERM_READ, + &uuid); + LOG_ERROR("p_data->add_result.char_uuid.uu.uuid16 = %x\n", + p_data->add_result.char_uuid.uu.uuid16); + } + if(p_data->add_result.char_uuid.uu.uuid16 == GATT_UUID_RPT_REF_DESCR) + { + if(hid_char_idx < HIDD_LE_CHAR_MAX) + { + HID_AddCharacteristic(&hids_char_db[hid_char_idx]); + hid_char_idx++; + } + } + break; + case BTA_GATTS_READ_EVT: + { + LOG_ERROR("Hidd profile BTA_GATTS_READ_EVT\n"); + UINT32 trans_id = p_data->req_data.trans_id; + UINT16 conn_id = p_data->req_data.conn_id; + UINT16 handle = p_data->req_data.p_data->read_req.handle; + bool is_long = p_data->req_data.p_data->read_req.is_long; + LOG_ERROR("read request:event=0x%x,handle=0x%x,trans_id=0x%x,conn_id=0x%x\n", + event, handle, trans_id, conn_id); + + hidd_read_attr_value(p_data->req_data.p_data,trans_id); + } break; case BTA_GATTS_WRITE_EVT: BTA_GATTS_SendRsp(p_data->req_data.conn_id,p_data->req_data.trans_id, - p_data->req_data.status,NULL); + p_data->req_data.status,NULL); break; case BTA_GATTS_CONNECT_EVT: p_clcb = &hidd_le_env.hidd_clcb; - + if(!p_clcb->in_use) { p_clcb->in_use = TRUE; @@ -237,41 +441,195 @@ static void hidd_le_profile_cb(tBTA_GATTS_EVT event, tBTA_GATTS *p_data) } /******************************************************************************* - ** - ** Function hidd_le_CreateService - ** - ** Description Create a Service for the hid device profile - ** - ** Parameters is_primary: this service is the primary service or not,true is the primary service - ** false is not the primary service - ** p_service_uuid: service UUID. - ** - ** Returns NULL - ** - *******************************************************************************/ +** +** Function hidd_le_CreateService +** +** Description Create a Service for the hid device profile +** +** Parameters is_primary: this service is the primary service or not,true is the primary service +** false is not the primary service +** p_service_uuid: service UUID. +** +** Returns NULL +** +*******************************************************************************/ void hidd_le_CreateService(BOOLEAN is_primary) { tBTA_GATTS_IF server_if ; tBT_UUID uuid = {LEN_UUID_16, {ATT_SVC_HID}}; //the number of the hid device attributes in the hid service. - UINT16 num_handle = HIDD_LE_IDX_NB; - UINT8 inst = 0x00; + UINT16 num_handle = HIDD_LE_IDX_NB+5; + UINT8 inst = 0x00; server_if = hidd_le_env.gatt_if; hidd_le_env.inst_id = inst; //start create the hid device service - BTA_GATTS_CreateService(server_if,&uuid,inst,num_handle,is_primary); + BTA_GATTS_CreateService(server_if,&uuid,inst,num_handle,is_primary); } +/***************************************************************************** +** Function hidd_read_attr_value +** +** Description it will be called when client sends a read request +******************************************************************************/ +void hidd_read_attr_value(tGATTS_DATA *p_data, UINT32 trans_id) +{ + tHIDD_INST *p_inst = &hidd_le_env.hidd_inst; + UINT8 i; + UINT8 status = GATT_SUCCESS; + UINT8 app_id = hidd_le_env.hidd_inst.app_id; + + tGATT_STATUS st = GATT_NOT_FOUND; + UINT16 handle = p_data->read_req.handle; + UINT16 conn_id = hidd_le_env.hidd_clcb.conn_id; + + if (handle == p_inst->att_tbl[HIDD_LE_INFO_CHAR]) + { + //read hid device info evt + p_inst->pending_evt = HIDD_LE_READ_INFO_EVT; + + }else if(handle == p_inst->att_tbl[HIDD_LE_CTNL_PT_CHAR]){ + //read hid device contol point evt + p_inst->pending_evt = HIDD_LE_READ_CTNL_PT_EVT; + }else if(handle == p_inst->att_tbl[HIDD_LE_REPORT_MAP_CHAR]){ + //read hid device report map value evt + p_inst->pending_evt = HIDD_LE_READ_REPORT_MAP_EVT; + }else if(handle == p_inst->att_tbl[HIDD_LE_REPORT_CHAR]){ + //read hid device report evt + p_inst->pending_evt = HIDD_LE_READ_REPORT_EVT; + }else if(handle == p_inst->att_tbl[HIDD_LE_PROTO_MODE_CHAR]){ + //read hid device mode evt + p_inst->pending_evt = HIDD_LE_READ_PROTO_MODE_EVT; + }else if(handle == p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR]){ + //read hid boot keyboard in report evt + p_inst->pending_evt = HIDD_LE_BOOT_KB_IN_REPORT_EVT; + }else if(handle == p_inst->att_tbl[HIDD_LE_BOOT_KB_OUT_REPORT_CHAR]){ + //read hid boot keyboard out report evt + p_inst->pending_evt = HIDD_LE_BOOT_KB_OUT_REPORT_EVT; + }else if(handle == p_inst->att_tbl[HIDD_LE_BOOT_MOUSE_IN_REPORT_CHAR]){ + //read hid device boot mouse in report evt + p_inst->pending_evt = HIDD_LE_BOOT_MOUSE_IN_REPORT_EVT; + } + + //start build the rsp message + Hidd_Rsp(trans_id,conn_id,app_id,status, p_inst->pending_evt,p_data); +} + +/******************************************************************************* +** +** Function Hidd_Rsp +** +** Description Respond to a hid device service request +** +*******************************************************************************/ +void Hidd_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id, + tGATT_STATUS status, UINT8 event, tGATTS_DATA *p_rsp) +{ + tHIDD_INST *p_inst = &hidd_le_env.hidd_inst; + tGATTS_RSP rsp; + UINT8 *pp; + LOG_ERROR("conn_id = %x, trans_id = %x, event = %x\n", + conn_id,trans_id,event); + + if (p_inst->app_id == app_id) + return ; + + memset(&rsp, 0, sizeof(tGATTS_RSP)); + + if (p_inst->pending_evt == event) + { + switch (event) + { + case HIDD_LE_READ_INFO_EVT: + LOG_ERROR(" p_inst->att_tbl[HIDD_LE_INFO_CHAR] = %x\n", + p_inst->att_tbl[HIDD_LE_INFO_CHAR]); + rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_INFO_CHAR]; + rsp.attr_value.len = HID_INFORMATION_LEN; + //copy the infomation value to the att value to sent to the peer device + memcpy(rsp.attr_value.value,hidInfo,HID_INFORMATION_LEN); + //start send the rsp to the peer device + BTA_GATTS_SendRsp(conn_id, trans_id, status, &rsp); + break; + + case HIDD_LE_READ_CTNL_PT_EVT: + LOG_ERROR(" p_inst->att_tbl[HIDD_LE_CTNL_PT_CHAR] = %x\n", + p_inst->att_tbl[HIDD_LE_CTNL_PT_CHAR]); + rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_CTNL_PT_CHAR]; + rsp.attr_value.len = 0; + //start send the rsp to the peer device + BTA_GATTS_SendRsp(conn_id, trans_id, status, &rsp); + break; + + case HIDD_LE_READ_REPORT_MAP_EVT: + LOG_ERROR("p_inst->att_tbl[HIDD_LE_REPORT_MAP_CHAR] = %x\n", + p_inst->att_tbl[HIDD_LE_REPORT_MAP_CHAR]); + rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_REPORT_MAP_CHAR]; + rsp.attr_value.len = hidReportMapLen; + //copy the infomation value to the att value to sent to the peer device + memcpy(rsp.attr_value.value,hidReportMap,hidReportMapLen); + //start send the rsp to the peer device + BTA_GATTS_SendRsp(conn_id, trans_id, status, &rsp); + break; + case HIDD_LE_READ_REPORT_EVT: + LOG_ERROR("p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR] = %x\n", + p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR]); + rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR]; + rsp.attr_value.len = 0; + + BTA_GATTS_SendRsp(conn_id, trans_id, status, &rsp); + break; + case HIDD_LE_READ_PROTO_MODE_EVT: + LOG_ERROR("p_inst->att_tbl[HIDD_LE_PROTO_MODE_CHAR] = %x\n", + p_inst->att_tbl[HIDD_LE_PROTO_MODE_CHAR]); + rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_PROTO_MODE_CHAR]; + rsp.attr_value.len = 1; + pp = rsp.attr_value.value; + //copy the infomation value to the att value to sent to the peer device + memcpy(rsp.attr_value.value,&hidProtocolMode,rsp.attr_value.len); + BTA_GATTS_SendRsp(conn_id, trans_id, status, &rsp); + break; + case HIDD_LE_BOOT_KB_IN_REPORT_EVT: + LOG_ERROR("p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR] = %x\n", + p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR]); + rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR]; + rsp.attr_value.len = 0; + + BTA_GATTS_SendRsp(conn_id, trans_id, status, &rsp); + break; + case HIDD_LE_BOOT_KB_OUT_REPORT_EVT: + LOG_ERROR("p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR] = %x\n", + p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR]); + rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR]; + rsp.attr_value.len = 0; + + BTA_GATTS_SendRsp(conn_id, trans_id, status, &rsp); + break; + case HIDD_LE_BOOT_MOUSE_IN_REPORT_EVT: + LOG_ERROR("p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR] = %x\n", + p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR]); + rsp.attr_value.handle = p_inst->att_tbl[HIDD_LE_BOOT_KB_IN_REPORT_CHAR]; + rsp.attr_value.len = 0; + + BTA_GATTS_SendRsp(conn_id, trans_id, status, &rsp); + break; + default: + break; + } + // p_inst->pending_clcb_idx = 0; + p_inst->pending_evt = 0; + p_inst->pending_hal = 0; + } + return; +} /******************************************************************************* - ** - ** Function hidd_le_init - ** - ** Description Initializa the GATT Service for button profiles. - ** Returns NULL - *******************************************************************************/ +** +** Function hidd_le_init +** +** Description Initializa the GATT Service for button profiles. +** Returns NULL +*******************************************************************************/ tGATT_STATUS hidd_le_init (void) { tBT_UUID app_uuid = {LEN_UUID_16,{ATT_SVC_HID}}; @@ -285,10 +643,11 @@ tGATT_STATUS hidd_le_init (void) { memset(&hidd_le_env,0,sizeof(tHIDD_LE_ENV)); } - - - /* register the hid deivce profile to the BTA_GATTS module*/ - BTA_GATTS_AppRegister(&app_uuid,hidd_le_profile_cb); + + + /* + register the hid deivce profile to the BTA_GATTS module*/ + BTA_GATTS_AppRegister(&app_uuid,hidd_le_profile_cb); hidd_le_env.enabled = TRUE; @@ -296,5 +655,6 @@ tGATT_STATUS hidd_le_init (void) } +#endif ///HIDD_LE_PROFILE_CFG diff --git a/components/bt/bluedroid/profiles/std/include/hid_le_prf.h b/components/bt/bluedroid/profiles/std/include/hid_le_prf.h index ecdf105e2f..c38af02084 100644 --- a/components/bt/bluedroid/profiles/std/include/hid_le_prf.h +++ b/components/bt/bluedroid/profiles/std/include/hid_le_prf.h @@ -12,9 +12,11 @@ **************************************************************************************** */ +#include "prf_defs.h" +#if (HIDD_LE_PROFILE_CFG) #include "bta_gatts_int.h" - +#include "bt_types.h" #include "bta_api.h" #include "gatt_api.h" @@ -25,6 +27,10 @@ #define HIDD_LE_NB_HIDS_INST_MAX (1) #endif +// Number of HID reports defined in the service +#define HID_NUM_REPORTS 9 + + #define ATT_SVC_HID 0x1812 /// Maximal number of Report Char. that can be added in the DB for one HIDS - Up to 11 @@ -46,7 +52,26 @@ #define HIDD_LE_REPORT_NTF_CFG_MASK (0x20) +/* HID information flags */ +#define HID_FLAGS_REMOTE_WAKE 0x01 // RemoteWake +#define HID_FLAGS_NORMALLY_CONNECTABLE 0x02 // NormallyConnectable +/* Control point commands */ +#define HID_CMD_SUSPEND 0x00 // Suspend +#define HID_CMD_EXIT_SUSPEND 0x01 // Exit Suspend + +/* HID protocol mode values */ +#define HID_PROTOCOL_MODE_BOOT 0x00 // Boot Protocol Mode +#define HID_PROTOCOL_MODE_REPORT 0x01 // Report Protocol Mode + +/* Attribute value lengths */ +#define HID_PROTOCOL_MODE_LEN 1 // HID Protocol Mode +#define HID_INFORMATION_LEN 4 // HID Information +#define HID_REPORT_REF_LEN 2 // HID Report Reference Descriptor +#define HID_EXT_REPORT_REF_LEN 2 // External Report Reference Descriptor + +// HID feature flags +#define HID_KBD_FLAGS HID_FLAGS_REMOTE_WAKE /// HID Service Attributes Indexes @@ -104,15 +129,29 @@ enum HIDD_LE_INFO_CHAR, HIDD_LE_CTNL_PT_CHAR, HIDD_LE_REPORT_MAP_CHAR, + HIDD_LE_REPORT_CHAR, HIDD_LE_PROTO_MODE_CHAR, HIDD_LE_BOOT_KB_IN_REPORT_CHAR, HIDD_LE_BOOT_KB_OUT_REPORT_CHAR, HIDD_LE_BOOT_MOUSE_IN_REPORT_CHAR, - HIDD_LE_REPORT_CHAR, - HIDD_LE_CHAR_MAX //= HIDD_LE_REPORT_CHAR + HIDD_LE_NB_REPORT_INST_MAX, }; +///att read event table Indexs +enum +{ + HIDD_LE_READ_INFO_EVT, + HIDD_LE_READ_CTNL_PT_EVT, + HIDD_LE_READ_REPORT_MAP_EVT, + HIDD_LE_READ_REPORT_EVT, + HIDD_LE_READ_PROTO_MODE_EVT, + HIDD_LE_BOOT_KB_IN_REPORT_EVT, + HIDD_LE_BOOT_KB_OUT_REPORT_EVT, + HIDD_LE_BOOT_MOUSE_IN_REPORT_EVT, + + HID_LE_EVT_MAX +}; + /// Client Characteristic Configuration Codes enum { @@ -176,22 +215,33 @@ enum }tHIDD_CLCB; + // HID report mapping table +typedef struct +{ + UINT16 handle; // Handle of report characteristic + UINT16 cccdHandle; // Handle of CCCD for report characteristic + UINT8 id; // Report ID + UINT8 type; // Report type + UINT8 mode; // Protocol mode (report or boot) +} hidRptMap_t; + typedef struct { /// hidd profile id - UINT8 app_id; + UINT8 app_id; /// Notified handle - uint16_t ntf_handle; - ///Attribute Table - uint8_t att_tbl[HIDD_LE_NB_HIDS_INST_MAX][HIDD_LE_CHAR_MAX]; + UINT16 ntf_handle; + ///Attribute handle Table + UINT16 att_tbl[HIDD_LE_CHAR_MAX]; /// Supported Features tHIDD_FEATURE hidd_feature[HIDD_LE_NB_HIDS_INST_MAX]; /// Current Protocol Mode UINT8 proto_mode[HIDD_LE_NB_HIDS_INST_MAX]; /// Number of HIDS added in the database UINT8 hids_nb; - + UINT8 pending_evt; + UINT16 pending_hal; }tHIDD_INST; @@ -211,8 +261,15 @@ enum void hidd_le_CreateService(BOOLEAN is_primary); + void Hidd_Rsp (UINT32 trans_id, UINT16 conn_id, UINT8 app_id, + tGATT_STATUS status, UINT8 event, tGATTS_DATA *p_rsp); + + void hidd_read_attr_value(tGATTS_DATA *p_data, UINT32 trans_id); + tGATT_STATUS hidd_le_init (void); + +#endif ///HIDD_LE_PROFILE_CFG diff --git a/components/bt/bluedroid/profiles/std/include/prf_defs.h b/components/bt/bluedroid/profiles/std/include/prf_defs.h index 8d5c686990..790bfe2c08 100644 --- a/components/bt/bluedroid/profiles/std/include/prf_defs.h +++ b/components/bt/bluedroid/profiles/std/include/prf_defs.h @@ -11,6 +11,8 @@ * **************************************************************************************** */ +#ifndef PRF_DEFS_H_ +#define PRF_DEFS_H_ #include "bta_api.h" #include "bta_gattc_int.h" @@ -24,6 +26,9 @@ #define ATT_UUID_128_LEN 0x0010 #define ATT_UUID_32_LEN 0x0004 +#define WX_AIRSYNC_CFG 0 +#define BUT_PROFILE_CFG 0 +#define HIDD_LE_PROFILE_CFG 1 /* * Type Definition @@ -626,5 +631,5 @@ enum { }; - +#endif ///PRF_DEFS_H_ diff --git a/components/bt/bluedroid/stack/btm/btm_acl.c b/components/bt/bluedroid/stack/btm/btm_acl.c index 0e1d475dd0..575e560a26 100755 --- a/components/bt/bluedroid/stack/btm/btm_acl.c +++ b/components/bt/bluedroid/stack/btm/btm_acl.c @@ -105,7 +105,7 @@ tACL_CONN *btm_bda_to_acl (BD_ADDR bda, tBT_TRANSPORT transport) #endif ) { - BTM_TRACE_DEBUG ("btm_bda_to_acl found"); + BTM_TRACE_DEBUG ("btm_bda_to_acl found\n"); return(p); } } diff --git a/components/bt/bluedroid/stack/btm/btm_ble_cont_energy.c b/components/bt/bluedroid/stack/btm/btm_ble_cont_energy.c index 7116582b42..286127b5b7 100755 --- a/components/bt/bluedroid/stack/btm/btm_ble_cont_energy.c +++ b/components/bt/bluedroid/stack/btm/btm_ble_cont_energy.c @@ -88,11 +88,11 @@ tBTM_STATUS BTM_BleGetEnergyInfo(tBTM_BLE_ENERGY_INFO_CBACK *p_ener_cback) BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb); - BTM_TRACE_EVENT("BTM_BleGetEnergyInfo"); + BTM_TRACE_EVENT("BTM_BleGetEnergyInfo\n"); if (0 == cmn_ble_vsc_cb.energy_support) { - BTM_TRACE_ERROR("Controller does not support get energy info"); + BTM_TRACE_ERROR("Controller does not support get energy info\n"); return BTM_ERR_PROCESSING; } diff --git a/components/bt/bluedroid/stack/btu/btu_init.c b/components/bt/bluedroid/stack/btu/btu_init.c index c9d21dd758..cd0af18ad8 100755 --- a/components/bt/bluedroid/stack/btu/btu_init.c +++ b/components/bt/bluedroid/stack/btu/btu_init.c @@ -56,19 +56,19 @@ extern fixed_queue_t *btu_hci_msg_queue; fixed_queue_t *btu_general_alarm_queue; hash_map_t *btu_general_alarm_hash_map; pthread_mutex_t btu_general_alarm_lock; -static const size_t BTU_GENERAL_ALARM_HASH_MAP_SIZE = 17; +static const size_t BTU_GENERAL_ALARM_HASH_MAP_SIZE = 34; // Oneshot timer queue. fixed_queue_t *btu_oneshot_alarm_queue; hash_map_t *btu_oneshot_alarm_hash_map; pthread_mutex_t btu_oneshot_alarm_lock; -static const size_t BTU_ONESHOT_ALARM_HASH_MAP_SIZE = 17; +static const size_t BTU_ONESHOT_ALARM_HASH_MAP_SIZE = 34; // l2cap timer queue. fixed_queue_t *btu_l2cap_alarm_queue; hash_map_t *btu_l2cap_alarm_hash_map; pthread_mutex_t btu_l2cap_alarm_lock; -static const size_t BTU_L2CAP_ALARM_HASH_MAP_SIZE = 17; +static const size_t BTU_L2CAP_ALARM_HASH_MAP_SIZE = 34; //thread_t *bt_workqueue_thread; //static const char *BT_WORKQUEUE_NAME = "bt_workqueue"; @@ -193,7 +193,7 @@ void BTU_StartUp(void) if (btu_l2cap_alarm_queue == NULL) goto error_exit; - xBtuQueue = xQueueCreate(30, sizeof(void *)); + xBtuQueue = xQueueCreate(60, sizeof(void *)); xTaskCreate(btu_task_thread_handler, "BtuT", 8192, NULL, configMAX_PRIORITIES - 1, &xBtuTaskHandle); btu_task_post(SIG_BTU_START_UP); /* diff --git a/components/bt/bluedroid/stack/l2cap/l2c_main.c b/components/bt/bluedroid/stack/l2cap/l2c_main.c index 7181fe1c04..4e5d8a21fa 100755 --- a/components/bt/bluedroid/stack/l2cap/l2c_main.c +++ b/components/bt/bluedroid/stack/l2cap/l2c_main.c @@ -192,7 +192,7 @@ void l2c_rcv_acl_data (BT_HDR *p_msg) /* only process fixed channel data as channel open indication when link is not in disconnecting mode */ l2cble_notify_le_connection(p_lcb->remote_bd_addr); #endif - + L2CAP_TRACE_WARNING ("L2CAP - rcv_cid CID: 0x%04x\n", rcv_cid); /* Find the CCB for this CID */ if (rcv_cid >= L2CAP_BASE_APPL_CID) { diff --git a/components/bt/bluedroid/stack/smp/smp_act.c b/components/bt/bluedroid/stack/smp/smp_act.c index a17b1c5a08..f7b7ce24c1 100755 --- a/components/bt/bluedroid/stack/smp/smp_act.c +++ b/components/bt/bluedroid/stack/smp/smp_act.c @@ -69,7 +69,7 @@ static bool lmp_version_below(BD_ADDR bda, uint8_t version) *******************************************************************************/ static void smp_update_key_mask (tSMP_CB *p_cb, UINT8 key_type, BOOLEAN recv) { - SMP_TRACE_DEBUG("%s before update role=%d recv=%d local_i_key = %02x, local_r_key = %02x", + SMP_TRACE_DEBUG("%s before update role=%d recv=%d local_i_key = %02x, local_r_key = %02x\n", __func__, p_cb->role, recv, p_cb->local_i_key, p_cb->local_r_key); if (((p_cb->le_secure_connections_mode_is_used) || @@ -97,7 +97,7 @@ static void smp_update_key_mask (tSMP_CB *p_cb, UINT8 key_type, BOOLEAN recv) p_cb->local_i_key &= ~key_type; } - SMP_TRACE_DEBUG("updated local_i_key = %02x, local_r_key = %02x", p_cb->local_i_key, + SMP_TRACE_DEBUG("updated local_i_key = %02x, local_r_key = %02x\n", p_cb->local_i_key, p_cb->local_r_key); } @@ -109,7 +109,7 @@ void smp_send_app_cback(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { tSMP_EVT_DATA cb_data; tSMP_STATUS callback_rc; - SMP_TRACE_DEBUG("%s p_cb->cb_evt=%d", __func__, p_cb->cb_evt); + SMP_TRACE_DEBUG("%s p_cb->cb_evt=%d\n", __func__, p_cb->cb_evt); if (p_cb->p_callback && p_cb->cb_evt != 0) { switch (p_cb->cb_evt) @@ -149,7 +149,7 @@ void smp_send_app_cback(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) callback_rc = (*p_cb->p_callback)(p_cb->cb_evt, p_cb->pairing_bda, &cb_data); - SMP_TRACE_DEBUG("callback_rc=%d p_cb->cb_evt=%d",callback_rc, p_cb->cb_evt ); + SMP_TRACE_DEBUG("callback_rc=%d p_cb->cb_evt=%d\n",callback_rc, p_cb->cb_evt ); if (callback_rc == SMP_SUCCESS) { @@ -172,7 +172,7 @@ void smp_send_app_cback(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) SMP_TRACE_WARNING ( "rcvd auth_req: 0x%02x, io_cap: %d \ loc_oob_flag: %d loc_enc_size: %d," - "local_i_key: 0x%02x, local_r_key: 0x%02x", + "local_i_key: 0x%02x, local_r_key: 0x%02x\n", p_cb->loc_auth_req, p_cb->local_io_capability, p_cb->loc_oob_flag, p_cb->loc_enc_size, p_cb->local_i_key, p_cb->local_r_key); @@ -194,7 +194,7 @@ void smp_send_app_cback(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) p_cb->local_r_key &= ~SMP_SEC_KEY_TYPE_LK; } - SMP_TRACE_WARNING("set auth_req: 0x%02x, local_i_key: 0x%02x, local_r_key: 0x%02x", + SMP_TRACE_WARNING("set auth_req: 0x%02x, local_i_key: 0x%02x, local_r_key: 0x%02x\n", p_cb->loc_auth_req, p_cb->local_i_key, p_cb->local_r_key); smp_sm_event(p_cb, SMP_IO_RSP_EVT, NULL); @@ -209,7 +209,7 @@ void smp_send_app_cback(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) p_cb->local_r_key &= ~SMP_SEC_KEY_TYPE_LK; SMP_TRACE_WARNING ( "for SMP over BR max_key_size: 0x%02x,\ - local_i_key: 0x%02x, local_r_key: 0x%02x", + local_i_key: 0x%02x, local_r_key: 0x%02x\n", p_cb->loc_enc_size, p_cb->local_i_key, p_cb->local_r_key); smp_br_state_machine_event(p_cb, SMP_BR_KEYS_RSP_EVT, NULL); @@ -224,7 +224,7 @@ void smp_send_app_cback(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) smp_sm_event(p_cb, SMP_DISCARD_SEC_REQ_EVT, NULL); } - SMP_TRACE_DEBUG("%s return", __func__); + SMP_TRACE_DEBUG("%s return\n", __func__); } /******************************************************************************* @@ -252,7 +252,7 @@ void smp_send_pair_fail(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) void smp_send_pair_req(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev (p_cb->pairing_bda); - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); /* erase all keys when master sends pairing req*/ if (p_dev_rec) @@ -268,7 +268,7 @@ void smp_send_pair_req(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_send_pair_rsp(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); p_cb->local_i_key &= p_cb->peer_i_key; p_cb->local_r_key &= p_cb->peer_r_key; @@ -288,7 +288,7 @@ void smp_send_pair_rsp(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_send_confirm(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); smp_send_cmd(SMP_OPCODE_CONFIRM, p_cb); } @@ -298,7 +298,7 @@ void smp_send_confirm(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_send_init(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); smp_send_cmd(SMP_OPCODE_INIT, p_cb); } @@ -308,7 +308,7 @@ void smp_send_init(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_send_rand(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); smp_send_cmd(SMP_OPCODE_RAND, p_cb); } @@ -318,7 +318,7 @@ void smp_send_rand(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_send_pair_public_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); smp_send_cmd(SMP_OPCODE_PAIR_PUBLIC_KEY, p_cb); } @@ -360,7 +360,7 @@ void smp_send_enc_info(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { tBTM_LE_LENC_KEYS le_key; - SMP_TRACE_DEBUG("%s p_cb->loc_enc_size = %d", __func__, p_cb->loc_enc_size); + SMP_TRACE_DEBUG("%s p_cb->loc_enc_size = %d\n", __func__, p_cb->loc_enc_size); smp_update_key_mask (p_cb, SMP_SEC_KEY_TYPE_ENC, FALSE); smp_send_cmd(SMP_OPCODE_ENCRYPT_INFO, p_cb); @@ -376,7 +376,7 @@ void smp_send_enc_info(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_LENC, (tBTM_LE_KEY_VALUE *)&le_key, TRUE); - SMP_TRACE_WARNING ("%s", __func__); + SMP_TRACE_WARNING ("%s\n", __func__); smp_key_distribution(p_cb, NULL); } @@ -388,7 +388,7 @@ void smp_send_enc_info(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) void smp_send_id_info(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { tBTM_LE_KEY_VALUE le_key; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); smp_update_key_mask (p_cb, SMP_SEC_KEY_TYPE_ID, FALSE); smp_send_cmd(SMP_OPCODE_IDENTITY_INFO, p_cb); @@ -398,7 +398,7 @@ void smp_send_id_info(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_LID, &le_key, TRUE); - SMP_TRACE_WARNING ("%s", __func__); + SMP_TRACE_WARNING ("%s\n", __func__); smp_key_distribution_by_transport(p_cb, NULL); } @@ -409,7 +409,7 @@ void smp_send_id_info(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) void smp_send_csrk_info(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { tBTM_LE_LCSRK_KEYS key; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); smp_update_key_mask (p_cb, SMP_SEC_KEY_TYPE_CSRK, FALSE); if (smp_send_cmd(SMP_OPCODE_SIGN_INFO, p_cb)) @@ -529,7 +529,7 @@ void smp_proc_pair_cmd(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) UINT8 reason = SMP_ENC_KEY_SIZE; tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev (p_cb->pairing_bda); - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); /* erase all keys if it is slave proc pairing req*/ if (p_dev_rec && (p_cb->role == HCI_ROLE_SLAVE)) btm_sec_clear_ble_keys(p_dev_rec); @@ -623,7 +623,7 @@ void smp_proc_confirm(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) UINT8 *p = (UINT8 *)p_data; UINT8 reason = SMP_INVALID_PARAMETERS; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (smp_command_has_invalid_parameters(p_cb)) { @@ -670,7 +670,7 @@ void smp_proc_rand(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) UINT8 *p = (UINT8 *)p_data; UINT8 reason = SMP_INVALID_PARAMETERS; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (smp_command_has_invalid_parameters(p_cb)) { @@ -953,7 +953,7 @@ void smp_proc_enc_info(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { UINT8 *p = (UINT8 *)p_data; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); STREAM_TO_ARRAY(p_cb->ltk, p, BT_OCTET16_LEN); smp_key_distribution(p_cb, NULL); @@ -967,7 +967,8 @@ void smp_proc_master_id(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) UINT8 *p = (UINT8 *)p_data; tBTM_LE_PENC_KEYS le_key; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\np_cb->peer_auth_req = %d,p_cb->loc_auth_req= %d\n", __func__, + p_cb->peer_auth_req,p_cb->loc_auth_req); smp_update_key_mask (p_cb, SMP_SEC_KEY_TYPE_ENC, TRUE); STREAM_TO_UINT16(le_key.ediv, p); @@ -1058,7 +1059,7 @@ void smp_proc_compare(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { UINT8 reason; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (!memcmp(p_cb->rconfirm, p_data->key.p_data, BT_OCTET16_LEN)) { /* compare the max encryption key size, and save the smaller one for the link */ @@ -1092,7 +1093,7 @@ void smp_proc_sl_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { UINT8 key_type = p_data->key.key_type; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (key_type == SMP_KEY_TYPE_TK) { smp_generate_srand_mrand_confirm(p_cb, NULL); @@ -1115,7 +1116,7 @@ void smp_start_enc(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) tBTM_STATUS cmd; UINT8 reason = SMP_ENC_FAIL; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (p_data != NULL) cmd = btm_ble_start_encrypt(p_cb->pairing_bda, TRUE, p_data->key.p_data); else @@ -1131,7 +1132,7 @@ void smp_start_enc(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_proc_discard(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (!(p_cb->flags & SMP_PAIR_FLAGS_WE_STARTED_DD)) smp_reset_control_value(p_cb); } @@ -1145,7 +1146,7 @@ void smp_enc_cmpl(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) UINT8 enc_enable = *(UINT8 *)p_data; UINT8 reason = enc_enable ? SMP_SUCCESS : SMP_ENC_FAIL; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason); } @@ -1159,7 +1160,7 @@ void smp_check_auth_req(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) UINT8 reason = enc_enable ? SMP_SUCCESS : SMP_ENC_FAIL; SMP_TRACE_DEBUG("%s rcvs enc_enable=%d i_keys=0x%x r_keys=0x%x " - "(i-initiator r-responder)", + "(i-initiator r-responder)\n", __func__, enc_enable, p_cb->local_i_key, p_cb->local_r_key); if (enc_enable == 1) { @@ -1192,7 +1193,7 @@ void smp_check_auth_req(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) p_cb->local_r_key &= ~SMP_SEC_KEY_TYPE_LK; } SMP_TRACE_DEBUG("%s rcvs upgrades: i_keys=0x%x r_keys=0x%x " - "(i-initiator r-responder)", + "(i-initiator r-responder)\n", __func__, p_cb->local_i_key, p_cb->local_r_key); if (/*((p_cb->peer_auth_req & SMP_AUTH_BOND) || @@ -1227,14 +1228,14 @@ void smp_key_pick_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) UINT8 key_to_dist = (p_cb->role == HCI_ROLE_SLAVE) ? p_cb->local_r_key : p_cb->local_i_key; UINT8 i = 0; - SMP_TRACE_DEBUG("%s key_to_dist=0x%x", __func__, key_to_dist); + SMP_TRACE_DEBUG("%s key_to_dist=0x%x\n", __func__, key_to_dist); while (i < SMP_KEY_DIST_TYPE_MAX) { - SMP_TRACE_DEBUG("key to send = %02x, i = %d", key_to_dist, i); + SMP_TRACE_DEBUG("key to send = %02x, i = %d\n", key_to_dist, i); if (key_to_dist & (1 << i)) { - SMP_TRACE_DEBUG("smp_distribute_act[%d]", i); + SMP_TRACE_DEBUG("smp_distribute_act[%d]\n", i); (* smp_distribute_act[i])(p_cb, p_data); break; } @@ -1248,7 +1249,7 @@ void smp_key_pick_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) void smp_key_distribution(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { UINT8 reason = SMP_SUCCESS; - SMP_TRACE_DEBUG("%s role=%d (0-master) r_keys=0x%x i_keys=0x%x", + SMP_TRACE_DEBUG("\n%s role=%d (0-master) r_keys=0x%x i_keys=0x%x\n", __func__, p_cb->role, p_cb->local_r_key, p_cb->local_i_key); if (p_cb->role == HCI_ROLE_SLAVE || @@ -1289,7 +1290,7 @@ void smp_decide_association_model(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) tSMP_KEY key; tSMP_INT_DATA *p = NULL; - SMP_TRACE_DEBUG("%s Association Model = %d", __func__, p_cb->selected_association_model); + SMP_TRACE_DEBUG("%s Association Model = %d\n", __func__, p_cb->selected_association_model); switch (p_cb->selected_association_model) { @@ -1298,7 +1299,7 @@ void smp_decide_association_model(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) ((p_cb->peer_auth_req & SMP_AUTH_YN_BIT) != 0) && ((p_cb->loc_auth_req & SMP_AUTH_YN_BIT) == 0)) { - SMP_TRACE_ERROR ("IO capability does not meet authentication requirement"); + SMP_TRACE_ERROR ("IO capability does not meet authentication requirement\n"); failure = SMP_PAIR_AUTH_FAIL; p = (tSMP_INT_DATA *)&failure; int_evt = SMP_AUTH_CMPL_EVT; @@ -1306,7 +1307,7 @@ void smp_decide_association_model(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) else { p_cb->sec_level = SMP_SEC_UNAUTHENTICATE; - SMP_TRACE_EVENT ("p_cb->sec_level =%d (SMP_SEC_UNAUTHENTICATE) ", p_cb->sec_level ); + SMP_TRACE_EVENT ("p_cb->sec_level =%d (SMP_SEC_UNAUTHENTICATE) \n", p_cb->sec_level ); key.key_type = SMP_KEY_TYPE_TK; key.p_data = p_cb->tk; @@ -1320,16 +1321,16 @@ void smp_decide_association_model(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) case SMP_MODEL_PASSKEY: p_cb->sec_level = SMP_SEC_AUTHENTICATED; - SMP_TRACE_EVENT ("p_cb->sec_level =%d (SMP_SEC_AUTHENTICATED) ", p_cb->sec_level ); + SMP_TRACE_EVENT ("p_cb->sec_level =%d (SMP_SEC_AUTHENTICATED) \n", p_cb->sec_level ); p_cb->cb_evt = SMP_PASSKEY_REQ_EVT; int_evt = SMP_TK_REQ_EVT; break; case SMP_MODEL_OOB: - SMP_TRACE_ERROR ("Association Model = SMP_MODEL_OOB"); + SMP_TRACE_ERROR ("Association Model = SMP_MODEL_OOB\n"); p_cb->sec_level = SMP_SEC_AUTHENTICATED; - SMP_TRACE_EVENT ("p_cb->sec_level =%d (SMP_SEC_AUTHENTICATED) ", p_cb->sec_level ); + SMP_TRACE_EVENT ("p_cb->sec_level =%d (SMP_SEC_AUTHENTICATED) \n", p_cb->sec_level ); p_cb->cb_evt = SMP_OOB_REQ_EVT; int_evt = SMP_TK_REQ_EVT; @@ -1337,7 +1338,7 @@ void smp_decide_association_model(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) case SMP_MODEL_KEY_NOTIF: p_cb->sec_level = SMP_SEC_AUTHENTICATED; - SMP_TRACE_DEBUG("Need to generate Passkey"); + SMP_TRACE_DEBUG("Need to generate Passkey\n"); /* generate passkey and notify application */ smp_generate_passkey(p_cb, NULL); @@ -1352,19 +1353,19 @@ void smp_decide_association_model(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) break; case SMP_MODEL_OUT_OF_RANGE: - SMP_TRACE_ERROR("Association Model = SMP_MODEL_OUT_OF_RANGE (failed)"); + SMP_TRACE_ERROR("Association Model = SMP_MODEL_OUT_OF_RANGE (failed)\n"); p = (tSMP_INT_DATA *)&failure; int_evt = SMP_AUTH_CMPL_EVT; break; default: - SMP_TRACE_ERROR("Association Model = %d (SOMETHING IS WRONG WITH THE CODE)", + SMP_TRACE_ERROR("Association Model = %d (SOMETHING IS WRONG WITH THE CODE)\n", p_cb->selected_association_model); p = (tSMP_INT_DATA *)&failure; int_evt = SMP_AUTH_CMPL_EVT; } - SMP_TRACE_EVENT ("sec_level=%d ", p_cb->sec_level ); + SMP_TRACE_EVENT ("sec_level=%d \n", p_cb->sec_level ); if (int_evt) smp_sm_event(p_cb, int_evt, p); } @@ -1377,7 +1378,7 @@ void smp_process_io_response(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { uint8_t reason = SMP_PAIR_AUTH_FAIL; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (p_cb->flags & SMP_PAIR_FLAGS_WE_STARTED_DD) { /* pairing started by local (slave) Security Request */ @@ -1394,7 +1395,7 @@ void smp_process_io_response(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_JUSTWORKS))) { SMP_TRACE_ERROR ("Slave requires secure connection only mode \ - but it can't be provided -> Slave fails pairing"); + but it can't be provided -> Slave fails pairing\n"); smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason); return; } @@ -1423,7 +1424,7 @@ void smp_br_process_slave_keys_response(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_br_send_pair_response(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); p_cb->local_i_key &= p_cb->peer_i_key; p_cb->local_r_key &= p_cb->peer_r_key; @@ -1454,7 +1455,7 @@ void smp_pairing_cmpl(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_pair_terminate(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); p_cb->status = SMP_CONN_TOUT; smp_proc_pairing_cmpl(p_cb); } @@ -1468,7 +1469,7 @@ void smp_idle_terminate(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { if (p_cb->flags & SMP_PAIR_FLAGS_WE_STARTED_DD) { - SMP_TRACE_DEBUG("Pairing terminated at IDLE state."); + SMP_TRACE_DEBUG("Pairing terminated at IDLE state.\n"); p_cb->status = SMP_FAIL; smp_proc_pairing_cmpl(p_cb); } @@ -1495,7 +1496,7 @@ void smp_fast_conn_param(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_both_have_public_keys(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s",__func__); + SMP_TRACE_DEBUG("%s\n",__func__); /* invokes DHKey computation */ smp_compute_dhkey(p_cb); @@ -1515,17 +1516,17 @@ void smp_both_have_public_keys(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_start_secure_connection_phase1(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_JUSTWORKS) { p_cb->sec_level = SMP_SEC_UNAUTHENTICATE; - SMP_TRACE_EVENT ("p_cb->sec_level =%d (SMP_SEC_UNAUTHENTICATE) ", p_cb->sec_level ); + SMP_TRACE_EVENT ("p_cb->sec_level =%d (SMP_SEC_UNAUTHENTICATE)\n ", p_cb->sec_level ); } else { p_cb->sec_level = SMP_SEC_AUTHENTICATED; - SMP_TRACE_EVENT ("p_cb->sec_level =%d (SMP_SEC_AUTHENTICATED) ", p_cb->sec_level ); + SMP_TRACE_EVENT ("p_cb->sec_level =%d (SMP_SEC_AUTHENTICATED)\n ", p_cb->sec_level ); } switch(p_cb->selected_association_model) @@ -1542,7 +1543,7 @@ void smp_start_secure_connection_phase1(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) break; case SMP_MODEL_SEC_CONN_PASSKEY_DISP: /* passkey has to be provided to user */ - SMP_TRACE_DEBUG("Need to generate SC Passkey"); + SMP_TRACE_DEBUG("Need to generate SC Passkey\n"); smp_generate_passkey(p_cb, NULL); break; case SMP_MODEL_SEC_CONN_OOB: @@ -1550,7 +1551,7 @@ void smp_start_secure_connection_phase1(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) smp_process_secure_connection_oob_data(p_cb, NULL); break; default: - SMP_TRACE_ERROR ("Association Model = %d is not used in LE SC", + SMP_TRACE_ERROR ("Association Model = %d is not used in LE SC\n", p_cb->selected_association_model); break; } @@ -1564,7 +1565,7 @@ void smp_start_secure_connection_phase1(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_process_local_nonce(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); switch(p_cb->selected_association_model) { @@ -1584,7 +1585,7 @@ void smp_process_local_nonce(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { /* slave commitment is already received, send local nonce, wait for remote nonce*/ SMP_TRACE_DEBUG("master in assoc mode = %d \ - already rcvd slave commitment - race condition", + already rcvd slave commitment - race condition\n", p_cb->selected_association_model); p_cb->flags &= ~SMP_PAIR_FLAG_HAVE_PEER_COMM; smp_send_rand(p_cb, NULL); @@ -1619,7 +1620,7 @@ void smp_process_local_nonce(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) smp_set_state(SMP_STATE_WAIT_NONCE); break; default: - SMP_TRACE_ERROR ("Association Model = %d is not used in LE SC", + SMP_TRACE_ERROR ("Association Model = %d is not used in LE SC\n", p_cb->selected_association_model); break; } @@ -1636,7 +1637,7 @@ void smp_process_peer_nonce(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { UINT8 reason; - SMP_TRACE_DEBUG("%s start ", __func__); + SMP_TRACE_DEBUG("%s start \n", __func__); switch(p_cb->selected_association_model) { @@ -1702,12 +1703,12 @@ void smp_process_peer_nonce(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) smp_sm_event(p_cb, SMP_SC_PHASE1_CMPLT_EVT, NULL); break; default: - SMP_TRACE_ERROR ("Association Model = %d is not used in LE SC", + SMP_TRACE_ERROR ("Association Model = %d is not used in LE SC\n", p_cb->selected_association_model); break; } - SMP_TRACE_DEBUG("%s end ",__FUNCTION__); + SMP_TRACE_DEBUG("%s end\n ",__FUNCTION__); } /******************************************************************************* @@ -1719,17 +1720,17 @@ void smp_match_dhkey_checks(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { UINT8 reason = SMP_DHKEY_CHK_FAIL; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (memcmp(p_data->key.p_data, p_cb->remote_dhkey_check, BT_OCTET16_LEN)) { - SMP_TRACE_WARNING ("dhkey chcks do no match"); + SMP_TRACE_WARNING ("dhkey chcks do no match\n"); p_cb->failure = reason; smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason); return; } - SMP_TRACE_EVENT ("dhkey chcks match"); + SMP_TRACE_EVENT ("dhkey chcks match\n"); /* compare the max encryption key size, and save the smaller one for the link */ if (p_cb->peer_enc_size < p_cb->loc_enc_size) @@ -1757,7 +1758,7 @@ void smp_match_dhkey_checks(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_move_to_secure_connections_phase2(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s",__func__); + SMP_TRACE_DEBUG("%s\n",__func__); smp_sm_event(p_cb, SMP_SC_PHASE1_CMPLT_EVT, NULL); } @@ -1770,7 +1771,7 @@ void smp_move_to_secure_connections_phase2(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_phase_2_dhkey_checks_are_present(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s",__func__); + SMP_TRACE_DEBUG("%s\n",__func__); if (p_cb->flags & SMP_PAIR_FLAG_HAVE_PEER_DHK_CHK) smp_sm_event(p_cb, SMP_SC_2_DHCK_CHKS_PRES_EVT, NULL); @@ -1786,7 +1787,7 @@ void smp_phase_2_dhkey_checks_are_present(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_wait_for_both_public_keys(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s",__func__); + SMP_TRACE_DEBUG("%s\n",__func__); if ((p_cb->flags & SMP_PAIR_FLAG_HAVE_PEER_PUBL_KEY) && (p_cb->flags & SMP_PAIR_FLAG_HAVE_LOCAL_PUBL_KEY)) @@ -1808,7 +1809,7 @@ void smp_start_passkey_verification(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { UINT8 *p = NULL; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); p = p_cb->local_random; UINT32_TO_STREAM(p, p_data->passkey); @@ -1825,7 +1826,7 @@ void smp_start_passkey_verification(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_process_secure_connection_oob_data(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); tSMP_SC_OOB_DATA *p_sc_oob_data = &p_cb->sc_oob_data; if (p_sc_oob_data->loc_oob_data.present) @@ -1835,13 +1836,13 @@ void smp_process_secure_connection_oob_data(tSMP_CB *p_cb, tSMP_INT_DATA *p_data } else { - SMP_TRACE_EVENT ("local OOB randomizer is absent"); + SMP_TRACE_EVENT ("local OOB randomizer is absent\n"); memset(p_cb->local_random, 0, sizeof (p_cb->local_random)); } if (!p_sc_oob_data->peer_oob_data.present) { - SMP_TRACE_EVENT ("peer OOB data is absent"); + SMP_TRACE_EVENT ("peer OOB data is absent\n"); memset(p_cb->peer_random, 0, sizeof (p_cb->peer_random)); } else @@ -1863,7 +1864,7 @@ void smp_process_secure_connection_oob_data(tSMP_CB *p_cb, tSMP_INT_DATA *p_data if (p_cb->peer_oob_flag != SMP_OOB_PRESENT) { /* the peer doesn't have local randomiser */ - SMP_TRACE_EVENT ("peer didn't receive local OOB data, set local randomizer to 0"); + SMP_TRACE_EVENT ("peer didn't receive local OOB data, set local randomizer to 0\n"); memset(p_cb->local_random, 0, sizeof (p_cb->local_random)); } } @@ -1881,7 +1882,7 @@ void smp_process_secure_connection_oob_data(tSMP_CB *p_cb, tSMP_INT_DATA *p_data *******************************************************************************/ void smp_set_local_oob_keys(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); memcpy(p_cb->sc_oob_data.loc_oob_data.private_key_used, p_cb->private_key, BT_OCTET32_LEN); @@ -1896,7 +1897,7 @@ void smp_set_local_oob_keys(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_set_local_oob_random_commitment(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); memcpy(p_cb->sc_oob_data.loc_oob_data.randomizer, p_cb->rand, BT_OCTET16_LEN); @@ -1907,7 +1908,7 @@ void smp_set_local_oob_random_commitment(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) #if SMP_DEBUG == TRUE UINT8 *p_print = NULL; - SMP_TRACE_DEBUG("local SC OOB data set:"); + SMP_TRACE_DEBUG("local SC OOB data set:\n"); p_print = (UINT8*) &p_cb->sc_oob_data.loc_oob_data.addr_sent_to; smp_debug_print_nbyte_little_endian (p_print, (const UINT8 *)"addr_sent_to", sizeof(tBLE_BD_ADDR)); @@ -1952,7 +1953,7 @@ void smp_link_encrypted(BD_ADDR bda, UINT8 encr_enable) { tSMP_CB *p_cb = &smp_cb; - SMP_TRACE_DEBUG("%s encr_enable=%d", __func__, encr_enable); + SMP_TRACE_DEBUG("%s encr_enable=%d\n", __func__, encr_enable); if (memcmp(&smp_cb.pairing_bda[0], bda, BD_ADDR_LEN) == 0) { @@ -1980,7 +1981,7 @@ void smp_link_encrypted(BD_ADDR bda, UINT8 encr_enable) *******************************************************************************/ BOOLEAN smp_proc_ltk_request(BD_ADDR bda) { - SMP_TRACE_DEBUG("%s state = %d", __func__, smp_cb.state); + SMP_TRACE_DEBUG("%s state = %d\n", __func__, smp_cb.state); BOOLEAN match = FALSE; if (!memcmp(bda, smp_cb.pairing_bda, BD_ADDR_LEN)) @@ -2021,7 +2022,7 @@ void smp_process_secure_connection_long_term_key(void) { tSMP_CB *p_cb = &smp_cb; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); smp_save_secure_connections_long_term_key(p_cb); smp_update_key_mask (p_cb, SMP_SEC_KEY_TYPE_ENC, FALSE); @@ -2041,7 +2042,7 @@ void smp_process_secure_connection_long_term_key(void) *******************************************************************************/ void smp_set_derive_link_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG ("%s", __func__); + SMP_TRACE_DEBUG ("%s\n", __func__); p_cb->derive_lk = TRUE; smp_update_key_mask (p_cb, SMP_SEC_KEY_TYPE_LK, FALSE); smp_key_distribution(p_cb, NULL); @@ -2060,10 +2061,10 @@ void smp_derive_link_key_from_long_term_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data { tSMP_STATUS status = SMP_PAIR_FAIL_UNKNOWN; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (!smp_calculate_link_key_from_long_term_key(p_cb)) { - SMP_TRACE_ERROR("%s failed", __FUNCTION__); + SMP_TRACE_ERROR("%s failed\n", __FUNCTION__); smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &status); return; } @@ -2084,15 +2085,15 @@ void smp_br_process_link_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { tSMP_STATUS status = SMP_PAIR_FAIL_UNKNOWN; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (!smp_calculate_long_term_key_from_link_key(p_cb)) { - SMP_TRACE_ERROR ("%s failed",__FUNCTION__); + SMP_TRACE_ERROR ("%s failed\n",__FUNCTION__); smp_sm_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &status); return; } - SMP_TRACE_DEBUG("%s: LTK derivation from LK successfully completed", __FUNCTION__); + SMP_TRACE_DEBUG("%s: LTK derivation from LK successfully completed\n", __FUNCTION__); smp_save_secure_connections_long_term_key(p_cb); smp_update_key_mask (p_cb, SMP_SEC_KEY_TYPE_ENC, FALSE); smp_br_select_next_key(p_cb, NULL); @@ -2105,7 +2106,7 @@ void smp_br_process_link_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_key_distribution_by_transport(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (p_cb->smp_over_br) { smp_br_select_next_key(p_cb, NULL); @@ -2123,7 +2124,7 @@ void smp_key_distribution_by_transport(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_br_pairing_complete(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (p_cb->total_tx_unacked == 0) { diff --git a/components/bt/bluedroid/stack/smp/smp_api.c b/components/bt/bluedroid/stack/smp/smp_api.c index a96e653df3..c4b1e2be8c 100755 --- a/components/bt/bluedroid/stack/smp/smp_api.c +++ b/components/bt/bluedroid/stack/smp/smp_api.c @@ -132,7 +132,7 @@ tSMP_STATUS SMP_Pair (BD_ADDR bd_addr) tSMP_CB *p_cb = &smp_cb; UINT8 status = SMP_PAIR_INTERNAL_ERR; - SMP_TRACE_EVENT ("%s state=%d br_state=%d flag=0x%x ", + SMP_TRACE_EVENT ("%s state=%d br_state=%d flag=0x%x \n", __FUNCTION__, p_cb->state, p_cb->br_state, p_cb->flags); if (p_cb->state != SMP_STATE_IDLE || p_cb->flags & SMP_PAIR_FLAGS_WE_STARTED_DD || p_cb->smp_over_br) @@ -148,7 +148,7 @@ tSMP_STATUS SMP_Pair (BD_ADDR bd_addr) if (!L2CA_ConnectFixedChnl (L2CAP_SMP_CID, bd_addr)) { - SMP_TRACE_ERROR("%s: L2C connect fixed channel failed.", __FUNCTION__); + SMP_TRACE_ERROR("%s: L2C connect fixed channel failed.\n", __FUNCTION__); smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &status); return status; } diff --git a/components/bt/bluedroid/stack/smp/smp_keys.c b/components/bt/bluedroid/stack/smp/smp_keys.c index 4a73392de5..5f93950d9a 100755 --- a/components/bt/bluedroid/stack/smp/smp_keys.c +++ b/components/bt/bluedroid/stack/smp/smp_keys.c @@ -82,7 +82,7 @@ void smp_debug_print_nbyte_little_endian(UINT8 *p, const UINT8 *key_name, UINT8 int row_count; UINT8 p_buf[512]; - SMP_TRACE_WARNING("%s(LSB ~ MSB):", key_name); + SMP_TRACE_WARNING("%s(LSB ~ MSB):\n", key_name); memset(p_buf, 0, sizeof(p_buf)); row_count = len % col_count ? len / col_count + 1: len / col_count; @@ -145,16 +145,16 @@ BOOLEAN smp_encrypt_data (UINT8 *key, UINT8 key_len, UINT8 *p_rev_key = NULL; /* input key in big endilan format */ UINT8 *p_rev_output = NULL; /* encrypted output in big endilan format */ - SMP_TRACE_DEBUG ("%s", __func__); + SMP_TRACE_DEBUG ("%s\n", __func__); if ( (p_out == NULL ) || (key_len != SMP_ENCRYT_KEY_SIZE) ) { - SMP_TRACE_ERROR ("%s failed", __func__); + SMP_TRACE_ERROR ("%s failed\n", __func__); return FALSE; } if ((p_start = (UINT8 *)GKI_getbuf((SMP_ENCRYT_DATA_SIZE*4))) == NULL) { - SMP_TRACE_ERROR ("%s failed unable to allocate buffer", __func__); + SMP_TRACE_ERROR ("%s failed unable to allocate buffer\n", __func__); return FALSE; } @@ -277,7 +277,7 @@ void smp_generate_stk(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) tSMP_ENC output; tSMP_STATUS status = SMP_PAIR_FAIL_UNKNOWN; - SMP_TRACE_DEBUG ("%s", __func__); + SMP_TRACE_DEBUG ("%s\n", __func__); if (p_cb->le_secure_connections_mode_is_used) { @@ -312,7 +312,7 @@ void smp_generate_srand_mrand_confirm(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { UNUSED(p_data); - SMP_TRACE_DEBUG ("%s", __func__); + SMP_TRACE_DEBUG ("%s\n", __func__); p_cb->rand_enc_proc_state = SMP_GEN_SRAND_MRAND; /* generate MRand or SRand */ if (!btsnd_hcic_ble_rand((void *)smp_rand_back)) @@ -333,7 +333,7 @@ void smp_generate_rand_cont(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { UNUSED(p_data); - SMP_TRACE_DEBUG ("%s", __func__); + SMP_TRACE_DEBUG ("%s\n", __func__); p_cb->rand_enc_proc_state = SMP_GEN_SRAND_MRAND_CONT; /* generate 64 MSB of MRand or SRand */ if (!btsnd_hcic_ble_rand((void *)smp_rand_back)) @@ -360,7 +360,7 @@ void smp_generate_ltk(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) UNUSED(p_data); BOOLEAN div_status; - SMP_TRACE_DEBUG ("%s", __FUNCTION__); + SMP_TRACE_DEBUG ("%s\n", __FUNCTION__); if (smp_get_br_state() == SMP_BR_STATE_BOND_PENDING) { smp_br_process_link_key(p_cb, NULL); @@ -380,7 +380,7 @@ void smp_generate_ltk(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) } else { - SMP_TRACE_DEBUG ("Generate DIV for LTK"); + SMP_TRACE_DEBUG ("Generate DIV for LTK\n"); p_cb->rand_enc_proc_state = SMP_GEN_DIV_LTK; /* generate MRand or SRand */ if (!btsnd_hcic_ble_rand((void *)smp_rand_back)) @@ -409,7 +409,7 @@ void smp_compute_csrk(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) tSMP_ENC output; tSMP_STATUS status = SMP_PAIR_FAIL_UNKNOWN; - SMP_TRACE_DEBUG ("smp_compute_csrk div=%x", p_cb->div); + SMP_TRACE_DEBUG ("smp_compute_csrk div=%x\n", p_cb->div); BTM_GetDeviceEncRoot(er); /* CSRK = d1(ER, DIV, 1) */ UINT16_TO_STREAM(p, p_cb->div); @@ -417,7 +417,7 @@ void smp_compute_csrk(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) if (!SMP_Encrypt(er, BT_OCTET16_LEN, buffer, 4, &output)) { - SMP_TRACE_ERROR("smp_generate_csrk failed"); + SMP_TRACE_ERROR("smp_generate_csrk failed\n"); if (p_cb->smp_over_br) { smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &status); @@ -475,7 +475,7 @@ void smp_concatenate_local( tSMP_CB *p_cb, UINT8 **p_data, UINT8 op_code) { UINT8 *p = *p_data; - SMP_TRACE_DEBUG ("%s", __func__); + SMP_TRACE_DEBUG ("%s\n", __func__); UINT8_TO_STREAM(p, op_code); UINT8_TO_STREAM(p, p_cb->local_io_capability); UINT8_TO_STREAM(p, p_cb->loc_oob_flag); @@ -495,7 +495,7 @@ void smp_concatenate_peer( tSMP_CB *p_cb, UINT8 **p_data, UINT8 op_code) { UINT8 *p = *p_data; - SMP_TRACE_DEBUG ("smp_concatenate_peer "); + SMP_TRACE_DEBUG ("smp_concatenate_peer \n"); UINT8_TO_STREAM(p, op_code); UINT8_TO_STREAM(p, p_cb->peer_io_caps); UINT8_TO_STREAM(p, p_cb->peer_oob_flag); @@ -523,11 +523,11 @@ void smp_gen_p1_4_confirm( tSMP_CB *p_cb, BT_OCTET16 p1) tBLE_ADDR_TYPE addr_type = 0; BD_ADDR remote_bda; - SMP_TRACE_DEBUG ("smp_gen_p1_4_confirm"); + SMP_TRACE_DEBUG ("smp_gen_p1_4_confirm\n"); if (!BTM_ReadRemoteConnectionAddr(p_cb->pairing_bda, remote_bda, &addr_type)) { - SMP_TRACE_ERROR("can not generate confirm for unknown device"); + SMP_TRACE_ERROR("can not generate confirm for unknown device\n"); return; } @@ -556,7 +556,7 @@ void smp_gen_p1_4_confirm( tSMP_CB *p_cb, BT_OCTET16 p1) smp_concatenate_local(p_cb, &p, SMP_OPCODE_PAIRING_RSP); } #if SMP_DEBUG == TRUE - SMP_TRACE_DEBUG("p1 = pres || preq || rat' || iat'"); + SMP_TRACE_DEBUG("p1 = pres || preq || rat' || iat'\n"); smp_debug_print_nbyte_little_endian ((UINT8 *)p1, (const UINT8 *)"P1", 16); #endif } @@ -576,14 +576,14 @@ void smp_gen_p2_4_confirm( tSMP_CB *p_cb, BT_OCTET16 p2) UINT8 *p = (UINT8 *)p2; BD_ADDR remote_bda; tBLE_ADDR_TYPE addr_type = 0; - + SMP_TRACE_DEBUG ("smp_gen_p2_4_confirm\n"); if (!BTM_ReadRemoteConnectionAddr(p_cb->pairing_bda, remote_bda, &addr_type)) { - SMP_TRACE_ERROR("can not generate confirm p2 for unknown device"); + SMP_TRACE_ERROR("can not generate confirm p2 for unknown device\n"); return; } - SMP_TRACE_DEBUG ("smp_gen_p2_4_confirm"); + SMP_TRACE_DEBUG ("smp_gen_p2_4_confirm\n"); memset(p, 0, sizeof(BT_OCTET16)); @@ -624,7 +624,7 @@ void smp_calculate_comfirm (tSMP_CB *p_cb, BT_OCTET16 rand, BD_ADDR bda) tSMP_ENC output; tSMP_STATUS status = SMP_PAIR_FAIL_UNKNOWN; - SMP_TRACE_DEBUG ("smp_calculate_comfirm "); + SMP_TRACE_DEBUG ("smp_calculate_comfirm \n"); /* generate p1 = pres || preq || rat' || iat' */ smp_gen_p1_4_confirm(p_cb, p1); @@ -661,9 +661,9 @@ static void smp_calculate_comfirm_cont(tSMP_CB *p_cb, tSMP_ENC *p) tSMP_ENC output; tSMP_STATUS status = SMP_PAIR_FAIL_UNKNOWN; - SMP_TRACE_DEBUG ("smp_calculate_comfirm_cont "); + SMP_TRACE_DEBUG ("smp_calculate_comfirm_cont \n"); #if SMP_DEBUG == TRUE - SMP_TRACE_DEBUG("Confirm step 1 p1' = e(k, r XOR p1) Generated"); + SMP_TRACE_DEBUG("Confirm step 1 p1' = e(k, r XOR p1) Generated\n"); smp_debug_print_nbyte_little_endian (p->param_buf, (const UINT8 *)"C1", 16); #endif @@ -676,11 +676,12 @@ static void smp_calculate_comfirm_cont(tSMP_CB *p_cb, tSMP_ENC *p) /* calculate: Confirm = E(k, p1' XOR p2) */ if (!SMP_Encrypt(p_cb->tk, BT_OCTET16_LEN, p2, BT_OCTET16_LEN, &output)) { - SMP_TRACE_ERROR("smp_calculate_comfirm_cont failed"); + SMP_TRACE_ERROR("smp_calculate_comfirm_cont failed\n"); smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &status); } else { + SMP_TRACE_DEBUG("p_cb->rand_enc_proc_state=%d\n",p_cb->rand_enc_proc_state); switch (p_cb->rand_enc_proc_state) { case SMP_GEN_CONFIRM: @@ -708,7 +709,7 @@ static void smp_generate_confirm(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { UNUSED(p_data); - SMP_TRACE_DEBUG ("%s", __func__); + SMP_TRACE_DEBUG ("%s\n", __func__); p_cb->rand_enc_proc_state = SMP_GEN_CONFIRM; smp_debug_print_nbyte_little_endian ((UINT8 *)p_cb->rand, (const UINT8 *)"local rand", 16); smp_calculate_comfirm(p_cb, p_cb->rand, p_cb->pairing_bda); @@ -729,7 +730,7 @@ void smp_generate_compare (tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { UNUSED(p_data); - SMP_TRACE_DEBUG ("smp_generate_compare "); + SMP_TRACE_DEBUG ("smp_generate_compare \n"); p_cb->rand_enc_proc_state = SMP_GEN_COMPARE; smp_debug_print_nbyte_little_endian ((UINT8 *)p_cb->rrand, (const UINT8 *)"peer rand", 16); smp_calculate_comfirm(p_cb, p_cb->rrand, p_cb->local_bda); @@ -749,7 +750,7 @@ static void smp_process_confirm(tSMP_CB *p_cb, tSMP_ENC *p) { tSMP_KEY key; - SMP_TRACE_DEBUG ("%s", __FUNCTION__); + SMP_TRACE_DEBUG ("%s\n", __FUNCTION__); memcpy(p_cb->confirm, p->param_buf, BT_OCTET16_LEN); #if (SMP_DEBUG == TRUE) @@ -759,7 +760,9 @@ static void smp_process_confirm(tSMP_CB *p_cb, tSMP_ENC *p) key.key_type = SMP_KEY_TYPE_CFM; key.p_data = p->param_buf; + smp_sm_event(p_cb, SMP_KEY_READY_EVT, &key); + } /******************************************************************************* @@ -776,14 +779,14 @@ static void smp_process_compare(tSMP_CB *p_cb, tSMP_ENC *p) { tSMP_KEY key; - SMP_TRACE_DEBUG ("smp_process_compare "); + SMP_TRACE_DEBUG ("smp_process_compare \n"); #if (SMP_DEBUG == TRUE) - SMP_TRACE_DEBUG("Compare Generated"); + SMP_TRACE_DEBUG("Compare Generated\n"); smp_debug_print_nbyte_little_endian (p->param_buf, (const UINT8 *)"Compare", 16); #endif key.key_type = SMP_KEY_TYPE_CMP; key.p_data = p->param_buf; - + //smp_set_state(SMP_STATE_CONFIRM); smp_sm_event(p_cb, SMP_KEY_READY_EVT, &key); } @@ -830,14 +833,14 @@ static void smp_generate_ltk_cont(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) tSMP_ENC output; tSMP_STATUS status = SMP_PAIR_FAIL_UNKNOWN; - SMP_TRACE_DEBUG ("%s", __func__); + SMP_TRACE_DEBUG ("%s\n", __func__); BTM_GetDeviceEncRoot(er); /* LTK = d1(ER, DIV, 0)= e(ER, DIV)*/ if (!SMP_Encrypt(er, BT_OCTET16_LEN, (UINT8 *)&p_cb->div, sizeof(UINT16), &output)) { - SMP_TRACE_ERROR("%s failed", __func__); + SMP_TRACE_ERROR("%s failed\n", __func__); smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &status); } else @@ -867,7 +870,7 @@ static void smp_generate_y(tSMP_CB *p_cb, tSMP_INT_DATA *p) tSMP_STATUS status = SMP_PAIR_FAIL_UNKNOWN; - SMP_TRACE_DEBUG ("smp_generate_y "); + SMP_TRACE_DEBUG ("smp_generate_y \n"); BTM_GetDeviceDHK(dhk); if (!SMP_Encrypt(dhk, BT_OCTET16_LEN, p_cb->enc_rand, @@ -898,7 +901,7 @@ static void smp_generate_rand_vector (tSMP_CB *p_cb, tSMP_INT_DATA *p) /* generate EDIV and rand now */ /* generate random vector */ - SMP_TRACE_DEBUG ("smp_generate_rand_vector "); + SMP_TRACE_DEBUG ("smp_generate_rand_vector\n"); p_cb->rand_enc_proc_state = SMP_GEN_RAND_V; if (!btsnd_hcic_ble_rand((void *)smp_rand_back)) smp_rand_back(NULL); @@ -946,7 +949,7 @@ BOOLEAN smp_calculate_legacy_short_term_key(tSMP_CB *p_cb, tSMP_ENC *output) BT_OCTET16 ptext; UINT8 *p = ptext; - SMP_TRACE_DEBUG ("%s", __func__); + SMP_TRACE_DEBUG ("%s\n", __func__); memset(p, 0, BT_OCTET16_LEN); if (p_cb->role == HCI_ROLE_MASTER) { @@ -964,7 +967,7 @@ BOOLEAN smp_calculate_legacy_short_term_key(tSMP_CB *p_cb, tSMP_ENC *output) encrypted = SMP_Encrypt( p_cb->tk, BT_OCTET16_LEN, ptext, BT_OCTET16_LEN, output); if (!encrypted) { - SMP_TRACE_ERROR("%s failed", __func__); + SMP_TRACE_ERROR("%s failed\n", __func__); } return encrypted; } @@ -1007,19 +1010,19 @@ void smp_create_private_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) *******************************************************************************/ void smp_use_oob_private_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) { - SMP_TRACE_DEBUG ("%s req_oob_type: %d, role: %d", + SMP_TRACE_DEBUG ("%s req_oob_type: %d, role: %d\n", __func__, p_cb->req_oob_type, p_cb->role); switch (p_cb->req_oob_type) { case SMP_OOB_BOTH: case SMP_OOB_LOCAL: - SMP_TRACE_DEBUG("%s restore secret key", __func__) + SMP_TRACE_DEBUG("%s restore secret key\n", __func__); memcpy(p_cb->private_key, p_cb->sc_oob_data.loc_oob_data.private_key_used, BT_OCTET32_LEN); smp_process_private_key(p_cb); break; default: - SMP_TRACE_DEBUG("%s create secret key anew", __func__); + SMP_TRACE_DEBUG("%s create secret key anew\n", __func__); smp_set_state(SMP_STATE_PAIR_REQ_RSP); smp_decide_association_model(p_cb, NULL); break; @@ -1038,7 +1041,7 @@ void smp_use_oob_private_key(tSMP_CB *p_cb, tSMP_INT_DATA *p_data) void smp_continue_private_key_creation (tSMP_CB *p_cb, tBTM_RAND_ENC *p) { UINT8 state = p_cb->rand_enc_proc_state & ~0x80; - SMP_TRACE_DEBUG ("%s state=0x%x", __func__, state); + SMP_TRACE_DEBUG ("%s state=0x%x\n", __func__, state); switch (state) { @@ -1125,7 +1128,7 @@ void smp_compute_dhkey (tSMP_CB *p_cb) Point peer_publ_key, new_publ_key; BT_OCTET32 private_key; - SMP_TRACE_DEBUG ("%s", __FUNCTION__); + SMP_TRACE_DEBUG ("%s\n", __FUNCTION__); memcpy(private_key, p_cb->private_key, BT_OCTET32_LEN); memcpy(peer_publ_key.x, p_cb->peer_publ_key.x, BT_OCTET32_LEN); @@ -1161,7 +1164,7 @@ void smp_calculate_local_commitment(tSMP_CB *p_cb) { UINT8 random_input; - SMP_TRACE_DEBUG("%s", __FUNCTION__); + SMP_TRACE_DEBUG("%s\n", __FUNCTION__); switch (p_cb->selected_association_model) { @@ -1169,7 +1172,7 @@ void smp_calculate_local_commitment(tSMP_CB *p_cb) case SMP_MODEL_SEC_CONN_NUM_COMP: if (p_cb->role == HCI_ROLE_MASTER) SMP_TRACE_WARNING ("local commitment calc on master is not expected \ - for Just Works/Numeric Comparison models"); + for Just Works/Numeric Comparison models\n"); smp_calculate_f4(p_cb->loc_publ_key.x, p_cb->peer_publ_key.x, p_cb->rand, 0, p_cb->commitment); break; @@ -1180,12 +1183,12 @@ void smp_calculate_local_commitment(tSMP_CB *p_cb) random_input, p_cb->commitment); break; case SMP_MODEL_SEC_CONN_OOB: - SMP_TRACE_WARNING ("local commitment calc is expected for OOB model BEFORE pairing"); + SMP_TRACE_WARNING ("local commitment calc is expected for OOB model BEFORE pairing\n"); smp_calculate_f4(p_cb->loc_publ_key.x, p_cb->loc_publ_key.x, p_cb->local_random, 0, p_cb->commitment); break; default: - SMP_TRACE_ERROR("Association Model = %d is not used in LE SC", + SMP_TRACE_ERROR("Association Model = %d is not used in LE SC\n", p_cb->selected_association_model); return; } @@ -1215,7 +1218,7 @@ void smp_calculate_peer_commitment(tSMP_CB *p_cb, BT_OCTET16 output_buf) case SMP_MODEL_SEC_CONN_NUM_COMP: if (p_cb->role == HCI_ROLE_SLAVE) SMP_TRACE_WARNING ("peer commitment calc on slave is not expected \ - for Just Works/Numeric Comparison models"); + for Just Works/Numeric Comparison models\n"); smp_calculate_f4(p_cb->peer_publ_key.x, p_cb->loc_publ_key.x, p_cb->rrand, 0, output_buf); break; @@ -1230,12 +1233,12 @@ void smp_calculate_peer_commitment(tSMP_CB *p_cb, BT_OCTET16 output_buf) output_buf); break; default: - SMP_TRACE_ERROR("Association Model = %d is not used in LE SC", + SMP_TRACE_ERROR("Association Model = %d is not used in LE SC\n", p_cb->selected_association_model); return; } - SMP_TRACE_EVENT ("peer commitment calculation is completed"); + SMP_TRACE_EVENT ("peer commitment calculation is completed\n"); } /******************************************************************************* @@ -1386,7 +1389,7 @@ UINT32 smp_calculate_g2(UINT8 *u, UINT8 *v, UINT8 *x, UINT8 *y) UINT8 *p_prnt = NULL; #endif - SMP_TRACE_DEBUG ("%s", __FUNCTION__); + SMP_TRACE_DEBUG ("%s\n", __FUNCTION__); p = msg; ARRAY_TO_STREAM(p, y, BT_OCTET16_LEN); diff --git a/components/bt/bluedroid/stack/smp/smp_l2c.c b/components/bt/bluedroid/stack/smp/smp_l2c.c index 6f97742c5e..0aa5ee095d 100755 --- a/components/bt/bluedroid/stack/smp/smp_l2c.c +++ b/components/bt/bluedroid/stack/smp/smp_l2c.c @@ -93,14 +93,14 @@ static void smp_connect_callback (UINT16 channel, BD_ADDR bd_addr, BOOLEAN conne tSMP_INT_DATA int_data; BD_ADDR dummy_bda = {0}; - SMP_TRACE_EVENT ("SMDBG l2c %s", __FUNCTION__); + SMP_TRACE_EVENT ("SMDBG l2c %s\n", __FUNCTION__); if (transport == BT_TRANSPORT_BR_EDR || memcmp(bd_addr, dummy_bda, BD_ADDR_LEN) == 0) return; if (memcmp(bd_addr, p_cb->pairing_bda, BD_ADDR_LEN) == 0) { - SMP_TRACE_EVENT ("%s() for pairing BDA: %08x%04x Event: %s", + SMP_TRACE_EVENT ("%s() for pairing BDA: %08x%04x Event: %s\n", __FUNCTION__, (bd_addr[0]<<24)+(bd_addr[1]<<16)+(bd_addr[2]<<8) + bd_addr[3], (bd_addr[4]<<8)+bd_addr[5], @@ -146,14 +146,14 @@ static void smp_data_received(UINT16 channel, BD_ADDR bd_addr, BT_HDR *p_buf) tSMP_CB *p_cb = &smp_cb; UINT8 *p = (UINT8 *)(p_buf + 1) + p_buf->offset; UINT8 cmd ; - SMP_TRACE_EVENT ("SMDBG l2c %s", __FUNCTION__); + SMP_TRACE_EVENT ("\nSMDBG l2c %s\n", __FUNCTION__); STREAM_TO_UINT8(cmd, p); /* sanity check */ if ((SMP_OPCODE_MAX < cmd) || (SMP_OPCODE_MIN > cmd)) { - SMP_TRACE_WARNING( "Ignore received command with RESERVED code 0x%02x", cmd); + SMP_TRACE_WARNING( "Ignore received command with RESERVED code 0x%02x\n", cmd); GKI_freebuf (p_buf); return; } @@ -184,7 +184,7 @@ static void smp_data_received(UINT16 channel, BD_ADDR bd_addr, BT_HDR *p_buf) if (cmd == SMP_OPCODE_CONFIRM) { SMP_TRACE_DEBUG ("in %s cmd = 0x%02x, peer_auth_req = 0x%02x," - "loc_auth_req = 0x%02x", + "loc_auth_req = 0x%02x\n", __FUNCTION__, cmd, p_cb->peer_auth_req, p_cb->loc_auth_req); if ((p_cb->peer_auth_req & SMP_SC_SUPPORT_BIT) && diff --git a/components/bt/bluedroid/stack/smp/smp_main.c b/components/bt/bluedroid/stack/smp/smp_main.c index 2d80343a6f..e9b3775207 100755 --- a/components/bt/bluedroid/stack/smp/smp_main.c +++ b/components/bt/bluedroid/stack/smp/smp_main.c @@ -442,7 +442,7 @@ static const UINT8 smp_slave_entry_map[][SMP_STATE_MAX] = { /* state name: Idle WaitApp SecReq Pair Wait Confirm Rand PublKey SCPhs1 Wait Wait SCPhs2 Wait DHKChk Enc Bond CrLocSc Rsp Pend ReqRsp Cfm Exch Strt Cmtm Nonce Strt DHKChk Pend Pend OobData */ -/* PAIR_REQ */{ 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, +/* PAIR_REQ */{ 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* PAIR_RSP */{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* CONFIRM */{ 0, 4, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* RAND */{ 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 }, @@ -491,7 +491,7 @@ static const UINT8 smp_slave_idle_table[][SMP_SM_NUM_COLS] = /* PAIR_REQ */ {SMP_PROC_PAIR_CMD, SMP_SEND_APP_CBACK, SMP_STATE_WAIT_APP_RSP} /* CR_LOC_SC_OOB_DATA */ ,{SMP_CREATE_PRIVATE_KEY, SMP_SM_NO_ACTION, SMP_STATE_CREATE_LOCAL_SEC_CONN_OOB_DATA} }; - + static const UINT8 smp_slave_wait_for_app_response_table [][SMP_SM_NUM_COLS] = { /* Event Action Next State */ @@ -525,7 +525,6 @@ static const UINT8 smp_slave_pair_request_response_table[][SMP_SM_NUM_COLS] = /* Event Action Next State */ /* CONFIRM */ {SMP_PROC_CONFIRM, SMP_SM_NO_ACTION, SMP_STATE_CONFIRM}, /* TK_REQ */ {SMP_SEND_APP_CBACK, SMP_SM_NO_ACTION, SMP_STATE_WAIT_APP_RSP}, - /* TK/Confirm ready */ /* KEY_READY */{SMP_PROC_SL_KEY, SMP_SM_NO_ACTION, SMP_STATE_PAIR_REQ_RSP} /* PUBL_KEY_EXCH_REQ */,{ SMP_CREATE_PRIVATE_KEY, SMP_SM_NO_ACTION, SMP_STATE_PUBLIC_KEY_EXCH}, @@ -772,15 +771,15 @@ void smp_sm_event(tSMP_CB *p_cb, tSMP_EVENT event, void *p_data) UINT8 action, entry, i; tSMP_ENTRY_TBL entry_table = smp_entry_table[p_cb->role]; - SMP_TRACE_EVENT("main smp_sm_event"); + SMP_TRACE_EVENT("main smp_sm_event\n"); if (curr_state >= SMP_STATE_MAX) { - SMP_TRACE_DEBUG( "Invalid state: %d", curr_state) ; + SMP_TRACE_DEBUG( "Invalid state: %d\n", curr_state) ; return; } SMP_TRACE_DEBUG( "SMP Role: %s State: [%s (%d)], Event: [%s (%d)]",\ - (p_cb->role == 0x01) ?"Slave" : "Master", smp_get_state_name( p_cb->state), + (p_cb->role == 0x01) ?"Slave" : "Master\n", smp_get_state_name( p_cb->state), p_cb->state, smp_get_event_name(event), event) ; /* look up the state table for the current state */ @@ -799,7 +798,7 @@ void smp_sm_event(tSMP_CB *p_cb, tSMP_EVENT event, void *p_data) } else { - SMP_TRACE_DEBUG( "Ignore event [%s (%d)] in state [%s (%d)]", + SMP_TRACE_DEBUG( "Ignore event [%s (%d)] in state [%s (%d)]\n", smp_get_event_name(event), event, smp_get_state_name(curr_state), curr_state); return; @@ -825,7 +824,7 @@ void smp_sm_event(tSMP_CB *p_cb, tSMP_EVENT event, void *p_data) break; } } - SMP_TRACE_DEBUG( "result state = %s", smp_get_state_name( p_cb->state ) ) ; + SMP_TRACE_DEBUG( "result state = %s\n", smp_get_state_name( p_cb->state ) ) ; } /******************************************************************************* diff --git a/components/bt/bluedroid/stack/smp/smp_utils.c b/components/bt/bluedroid/stack/smp/smp_utils.c index a3809115ec..4d988bad46 100755 --- a/components/bt/bluedroid/stack/smp/smp_utils.c +++ b/components/bt/bluedroid/stack/smp/smp_utils.c @@ -314,7 +314,7 @@ BOOLEAN smp_send_cmd(UINT8 cmd_code, tSMP_CB *p_cb) BT_HDR *p_buf; BOOLEAN sent = FALSE; UINT8 failure = SMP_PAIR_INTERNAL_ERR; - SMP_TRACE_EVENT("smp_send_cmd on l2cap cmd_code=0x%x", cmd_code); + SMP_TRACE_EVENT("smp_send_cmd on l2cap cmd_code=0x%x\n", cmd_code); if ( cmd_code <= (SMP_OPCODE_MAX + 1 /* for SMP_OPCODE_PAIR_COMMITM */) && smp_cmd_build_act[cmd_code] != NULL) { @@ -418,7 +418,7 @@ static BT_HDR * smp_build_confirm_cmd(UINT8 cmd_code, tSMP_CB *p_cb) UINT8 *p; UNUSED(cmd_code); - SMP_TRACE_EVENT("smp_build_confirm_cmd"); + SMP_TRACE_EVENT("smp_build_confirm_cmd\n"); if ((p_buf = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR) + SMP_CONFIRM_CMD_SIZE + L2CAP_MIN_OFFSET)) != NULL) { p = (UINT8 *)(p_buf + 1) + L2CAP_MIN_OFFSET; @@ -445,7 +445,7 @@ static BT_HDR * smp_build_rand_cmd(UINT8 cmd_code, tSMP_CB *p_cb) UINT8 *p; UNUSED(cmd_code); - SMP_TRACE_EVENT("%s", __func__); + SMP_TRACE_EVENT("%s\n", __func__); if ((p_buf = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR) + SMP_RAND_CMD_SIZE + L2CAP_MIN_OFFSET)) != NULL) { @@ -473,7 +473,7 @@ static BT_HDR * smp_build_encrypt_info_cmd(UINT8 cmd_code, tSMP_CB *p_cb) UINT8 *p; UNUSED(cmd_code); - SMP_TRACE_EVENT("smp_build_encrypt_info_cmd"); + SMP_TRACE_EVENT("smp_build_encrypt_info_cmd\n"); if ((p_buf = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR) + SMP_ENC_INFO_SIZE + L2CAP_MIN_OFFSET)) != NULL) { p = (UINT8 *)(p_buf + 1) + L2CAP_MIN_OFFSET; @@ -501,7 +501,7 @@ static BT_HDR * smp_build_master_id_cmd(UINT8 cmd_code, tSMP_CB *p_cb) UINT8 *p; UNUSED(cmd_code); - SMP_TRACE_EVENT("%s", __func__); + SMP_TRACE_EVENT("%s\n", __func__); if ((p_buf = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR) + SMP_MASTER_ID_SIZE + L2CAP_MIN_OFFSET)) != NULL) { @@ -533,7 +533,7 @@ static BT_HDR * smp_build_identity_info_cmd(UINT8 cmd_code, tSMP_CB *p_cb) UNUSED(cmd_code); UNUSED(p_cb); - SMP_TRACE_EVENT("smp_build_identity_info_cmd"); + SMP_TRACE_EVENT("smp_build_identity_info_cmd\n"); if ((p_buf = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR) + SMP_ID_INFO_SIZE + L2CAP_MIN_OFFSET)) != NULL) { p = (UINT8 *)(p_buf + 1) + L2CAP_MIN_OFFSET; @@ -564,7 +564,7 @@ static BT_HDR * smp_build_id_addr_cmd(UINT8 cmd_code, tSMP_CB *p_cb) UNUSED(cmd_code); UNUSED(p_cb); - SMP_TRACE_EVENT("smp_build_id_addr_cmd"); + SMP_TRACE_EVENT("smp_build_id_addr_cmd\n"); if ((p_buf = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR) + SMP_ID_ADDR_SIZE + L2CAP_MIN_OFFSET)) != NULL) { p = (UINT8 *)(p_buf + 1) + L2CAP_MIN_OFFSET; @@ -593,7 +593,7 @@ static BT_HDR * smp_build_signing_info_cmd(UINT8 cmd_code, tSMP_CB *p_cb) UINT8 *p; UNUSED(cmd_code); - SMP_TRACE_EVENT("smp_build_signing_info_cmd"); + SMP_TRACE_EVENT("smp_build_signing_info_cmd\n"); if ((p_buf = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR) + SMP_SIGN_INFO_SIZE + L2CAP_MIN_OFFSET)) != NULL) { p = (UINT8 *)(p_buf + 1) + L2CAP_MIN_OFFSET; @@ -621,7 +621,7 @@ static BT_HDR * smp_build_pairing_fail(UINT8 cmd_code, tSMP_CB *p_cb) UINT8 *p; UNUSED(cmd_code); - SMP_TRACE_EVENT("%s", __func__); + SMP_TRACE_EVENT("%s\n", __func__); if ((p_buf = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR) + SMP_PAIR_FAIL_SIZE + L2CAP_MIN_OFFSET)) != NULL) { p = (UINT8 *)(p_buf + 1) + L2CAP_MIN_OFFSET; @@ -649,7 +649,7 @@ static BT_HDR *smp_build_security_request(UINT8 cmd_code, tSMP_CB *p_cb) UINT8 *p; UNUSED(cmd_code); - SMP_TRACE_EVENT("%s", __func__); + SMP_TRACE_EVENT("%s\n", __func__); if ((p_buf = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR) + 2 + L2CAP_MIN_OFFSET)) != NULL) { p = (UINT8 *)(p_buf + 1) + L2CAP_MIN_OFFSET; @@ -682,7 +682,7 @@ static BT_HDR *smp_build_pair_public_key_cmd(UINT8 cmd_code, tSMP_CB *p_cb) UINT8 *p_publ_key = publ_key; UNUSED(cmd_code); - SMP_TRACE_EVENT("%s", __FUNCTION__); + SMP_TRACE_EVENT("%s\n", __FUNCTION__); memcpy(p_publ_key, p_cb->loc_publ_key.x, BT_OCTET32_LEN); memcpy(p_publ_key + BT_OCTET32_LEN, p_cb->loc_publ_key.y, BT_OCTET32_LEN); @@ -715,7 +715,7 @@ static BT_HDR *smp_build_pairing_commitment_cmd(UINT8 cmd_code, tSMP_CB *p_cb) UINT8 *p; UNUSED(cmd_code); - SMP_TRACE_EVENT("%s", __func__); + SMP_TRACE_EVENT("%s\n", __func__); if ((p_buf = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR) + SMP_PAIR_COMMITM_SIZE + L2CAP_MIN_OFFSET)) != NULL) { @@ -744,7 +744,7 @@ static BT_HDR *smp_build_pair_dhkey_check_cmd(UINT8 cmd_code, tSMP_CB *p_cb) UINT8 *p; UNUSED(cmd_code); - SMP_TRACE_EVENT("%s", __FUNCTION__); + SMP_TRACE_EVENT("%s\n", __FUNCTION__); if ((p_buf = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR) + SMP_PAIR_DHKEY_CHECK_SIZE + L2CAP_MIN_OFFSET)) != NULL) { @@ -773,7 +773,7 @@ static BT_HDR * smp_build_pairing_keypress_notification_cmd(UINT8 cmd_code, tSMP UINT8 *p; UNUSED(cmd_code); - SMP_TRACE_EVENT("%s", __FUNCTION__); + SMP_TRACE_EVENT("%s\n", __FUNCTION__); if ((p_buf = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR)\ + SMP_PAIR_KEYPR_NOTIF_SIZE + L2CAP_MIN_OFFSET)) != NULL) { @@ -804,7 +804,7 @@ void smp_convert_string_to_tk(BT_OCTET16 tk, UINT32 passkey) { UINT8 *p = tk; tSMP_KEY key; - SMP_TRACE_EVENT("smp_convert_string_to_tk"); + SMP_TRACE_EVENT("smp_convert_string_to_tk\n"); UINT32_TO_STREAM(p, passkey); key.key_type = SMP_KEY_TYPE_TK; @@ -826,7 +826,7 @@ void smp_convert_string_to_tk(BT_OCTET16 tk, UINT32 passkey) *******************************************************************************/ void smp_mask_enc_key(UINT8 loc_enc_size, UINT8 * p_data) { - SMP_TRACE_EVENT("smp_mask_enc_key"); + SMP_TRACE_EVENT("smp_mask_enc_key\n"); if (loc_enc_size < BT_OCTET16_LEN) { for (; loc_enc_size < BT_OCTET16_LEN; loc_enc_size ++) @@ -849,7 +849,7 @@ void smp_xor_128(BT_OCTET16 a, BT_OCTET16 b) { UINT8 i, *aa = a, *bb = b; - SMP_TRACE_EVENT("smp_xor_128"); + SMP_TRACE_EVENT("smp_xor_128\n"); for (i = 0; i < BT_OCTET16_LEN; i++) { aa[i] = aa[i] ^ bb[i]; @@ -870,7 +870,7 @@ void smp_cb_cleanup(tSMP_CB *p_cb) tSMP_CALLBACK *p_callback = p_cb->p_callback; UINT8 trace_level = p_cb->trace_level; - SMP_TRACE_EVENT("smp_cb_cleanup"); + SMP_TRACE_EVENT("smp_cb_cleanup\n"); memset(p_cb, 0, sizeof(tSMP_CB)); p_cb->p_callback = p_callback; @@ -888,7 +888,7 @@ void smp_cb_cleanup(tSMP_CB *p_cb) *******************************************************************************/ void smp_remove_fixed_channel(tSMP_CB *p_cb) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (p_cb->smp_over_br) L2CA_RemoveFixedChnl (L2CAP_SMP_BR_CID, p_cb->pairing_bda); @@ -909,7 +909,7 @@ void smp_remove_fixed_channel(tSMP_CB *p_cb) *******************************************************************************/ void smp_reset_control_value(tSMP_CB *p_cb) { - SMP_TRACE_EVENT("smp_reset_control_value"); + SMP_TRACE_EVENT("smp_reset_control_value\n"); btu_stop_timer (&p_cb->rsp_timer_ent); p_cb->flags = 0; /* set the link idle timer to drop the link when pairing is done @@ -939,7 +939,7 @@ void smp_proc_pairing_cmpl(tSMP_CB *p_cb) tSMP_CALLBACK *p_callback = p_cb->p_callback; BD_ADDR pairing_bda; - SMP_TRACE_DEBUG ("smp_proc_pairing_cmpl "); + SMP_TRACE_DEBUG ("smp_proc_pairing_cmpl \n"); evt_data.cmplt.reason = p_cb->status; evt_data.cmplt.smp_over_br = p_cb->smp_over_br; @@ -953,7 +953,7 @@ void smp_proc_pairing_cmpl(tSMP_CB *p_cb) evt_data.cmplt.is_pair_cancel = TRUE; - SMP_TRACE_DEBUG ("send SMP_COMPLT_EVT reason=0x%0x sec_level=0x%0x", + SMP_TRACE_DEBUG ("send SMP_COMPLT_EVT reason=0x%0x sec_level=0x%0x\n", evt_data.cmplt.reason, evt_data.cmplt.sec_level ); @@ -981,12 +981,12 @@ BOOLEAN smp_command_has_invalid_parameters(tSMP_CB *p_cb) { UINT8 cmd_code = p_cb->rcvd_cmd_code; - SMP_TRACE_DEBUG("%s for cmd code 0x%02x", __func__, cmd_code); + SMP_TRACE_DEBUG("%s for cmd code 0x%02x\n", __func__, cmd_code); if ((cmd_code > (SMP_OPCODE_MAX + 1 /* for SMP_OPCODE_PAIR_COMMITM */)) || (cmd_code < SMP_OPCODE_MIN)) { - SMP_TRACE_WARNING("Somehow received command with the RESERVED code 0x%02x", cmd_code); + SMP_TRACE_WARNING("Somehow received command with the RESERVED code 0x%02x\n", cmd_code); return TRUE; } @@ -1014,12 +1014,12 @@ BOOLEAN smp_command_has_valid_fixed_length(tSMP_CB *p_cb) { UINT8 cmd_code = p_cb->rcvd_cmd_code; - SMP_TRACE_DEBUG("%s for cmd code 0x%02x", __func__, cmd_code); + SMP_TRACE_DEBUG("%s for cmd code 0x%02x\n", __func__, cmd_code); if (p_cb->rcvd_cmd_len != smp_cmd_size_per_spec[cmd_code]) { SMP_TRACE_WARNING("Rcvd from the peer cmd 0x%02x with invalid length\ - 0x%02x (per spec the length is 0x%02x).", + 0x%02x (per spec the length is 0x%02x).\n", cmd_code, p_cb->rcvd_cmd_len, smp_cmd_size_per_spec[cmd_code]); return FALSE; } @@ -1048,12 +1048,12 @@ BOOLEAN smp_pairing_request_response_parameters_are_valid(tSMP_CB *p_cb) UINT8 bond_flag = p_cb->peer_auth_req & 0x03; //0x03 is gen bond with appropriate mask UINT8 enc_size = p_cb->peer_enc_size; - SMP_TRACE_DEBUG("%s for cmd code 0x%02x", __func__, p_cb->rcvd_cmd_code); + SMP_TRACE_DEBUG("%s for cmd code 0x%02x\n", __func__, p_cb->rcvd_cmd_code); if (io_caps >= BTM_IO_CAP_MAX) { SMP_TRACE_WARNING("Rcvd from the peer cmd 0x%02x with IO Capabilty \ - value (0x%02x) out of range).", + value (0x%02x) out of range).\n", p_cb->rcvd_cmd_code, io_caps); return FALSE; } @@ -1061,7 +1061,7 @@ BOOLEAN smp_pairing_request_response_parameters_are_valid(tSMP_CB *p_cb) if (!((oob_flag == SMP_OOB_NONE) || (oob_flag == SMP_OOB_PRESENT))) { SMP_TRACE_WARNING("Rcvd from the peer cmd 0x%02x with OOB data flag value \ - (0x%02x) out of range).", + (0x%02x) out of range).\n", p_cb->rcvd_cmd_code, oob_flag); return FALSE; } @@ -1069,7 +1069,7 @@ BOOLEAN smp_pairing_request_response_parameters_are_valid(tSMP_CB *p_cb) if (!((bond_flag == SMP_AUTH_NO_BOND) || (bond_flag == SMP_AUTH_BOND))) { SMP_TRACE_WARNING("Rcvd from the peer cmd 0x%02x with Bonding_Flags value (0x%02x)\ - out of range).", + out of range).\n", p_cb->rcvd_cmd_code, bond_flag); return FALSE; } @@ -1077,7 +1077,7 @@ BOOLEAN smp_pairing_request_response_parameters_are_valid(tSMP_CB *p_cb) if ((enc_size < SMP_ENCR_KEY_SIZE_MIN) || (enc_size > SMP_ENCR_KEY_SIZE_MAX)) { SMP_TRACE_WARNING("Rcvd from the peer cmd 0x%02x with Maximum Encryption \ - Key value (0x%02x) out of range).", + Key value (0x%02x) out of range).\n", p_cb->rcvd_cmd_code, enc_size); return FALSE; } @@ -1098,12 +1098,12 @@ BOOLEAN smp_pairing_keypress_notification_is_valid(tSMP_CB *p_cb) { tBTM_SP_KEY_TYPE keypress_notification = p_cb->peer_keypress_notification; - SMP_TRACE_DEBUG("%s for cmd code 0x%02x", __func__, p_cb->rcvd_cmd_code); + SMP_TRACE_DEBUG("%s for cmd code 0x%02x\n", __func__, p_cb->rcvd_cmd_code); if (keypress_notification >= BTM_SP_KEY_OUT_OF_RANGE) { SMP_TRACE_WARNING("Rcvd from the peer cmd 0x%02x with Pairing Keypress \ - Notification value (0x%02x) out of range).", + Notification value (0x%02x) out of range).\n", p_cb->rcvd_cmd_code, keypress_notification); return FALSE; } @@ -1150,7 +1150,7 @@ void smp_reject_unexpected_pairing_command(BD_ADDR bd_addr) BT_HDR *p_buf; UINT8 *p; - SMP_TRACE_DEBUG ("%s", __FUNCTION__); + SMP_TRACE_DEBUG ("%s\n", __FUNCTION__); if ((p_buf = (BT_HDR *)GKI_getbuf(sizeof(BT_HDR) +\ SMP_PAIR_FAIL_SIZE + L2CAP_MIN_OFFSET)) != NULL) @@ -1188,14 +1188,14 @@ tSMP_ASSO_MODEL smp_select_association_model(tSMP_CB *p_cb) tSMP_ASSO_MODEL model = SMP_MODEL_OUT_OF_RANGE; p_cb->le_secure_connections_mode_is_used = FALSE; - SMP_TRACE_EVENT("%s", __FUNCTION__); - SMP_TRACE_DEBUG("%s p_cb->peer_io_caps = %d p_cb->local_io_capability = %d", + SMP_TRACE_EVENT("%s\n", __FUNCTION__); + SMP_TRACE_DEBUG("%s p_cb->peer_io_caps = %d p_cb->local_io_capability = %d\n", __FUNCTION__, p_cb->peer_io_caps, p_cb->local_io_capability); - SMP_TRACE_DEBUG("%s p_cb->peer_oob_flag = %d p_cb->loc_oob_flag = %d", + SMP_TRACE_DEBUG("%s p_cb->peer_oob_flag = %d p_cb->loc_oob_flag = %d\n", __FUNCTION__, p_cb->peer_oob_flag, p_cb->loc_oob_flag); - SMP_TRACE_DEBUG("%s p_cb->peer_auth_req = 0x%02x p_cb->loc_auth_req = 0x%02x", + SMP_TRACE_DEBUG("%s p_cb->peer_auth_req = 0x%02x p_cb->loc_auth_req = 0x%02x\n", __FUNCTION__, p_cb->peer_auth_req, p_cb->loc_auth_req); - SMP_TRACE_DEBUG("%s p_cb->secure_connections_only_mode_required = %s", + SMP_TRACE_DEBUG("%s p_cb->secure_connections_only_mode_required = %s\n", __FUNCTION__, p_cb->secure_connections_only_mode_required ? "TRUE" : "FALSE"); @@ -1204,7 +1204,7 @@ tSMP_ASSO_MODEL smp_select_association_model(tSMP_CB *p_cb) p_cb->le_secure_connections_mode_is_used = TRUE; } - SMP_TRACE_DEBUG("use_sc_process = %d", p_cb->le_secure_connections_mode_is_used); + SMP_TRACE_DEBUG("use_sc_process = %d\n", p_cb->le_secure_connections_mode_is_used); if (p_cb->le_secure_connections_mode_is_used) { @@ -1228,7 +1228,7 @@ tSMP_ASSO_MODEL smp_select_legacy_association_model(tSMP_CB *p_cb) { tSMP_ASSO_MODEL model = SMP_MODEL_OUT_OF_RANGE; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); /* if OOB data is present on both devices, then use OOB association model */ if (p_cb->peer_oob_flag == SMP_OOB_PRESENT && p_cb->loc_oob_flag == SMP_OOB_PRESENT) return SMP_MODEL_OOB; @@ -1266,7 +1266,7 @@ tSMP_ASSO_MODEL smp_select_association_model_secure_connections(tSMP_CB *p_cb) { tSMP_ASSO_MODEL model = SMP_MODEL_OUT_OF_RANGE; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); /* if OOB data is present on at least one device, then use OOB association model */ if (p_cb->peer_oob_flag == SMP_OOB_PRESENT || p_cb->loc_oob_flag == SMP_OOB_PRESENT) return SMP_MODEL_SEC_CONN_OOB; @@ -1303,7 +1303,7 @@ void smp_reverse_array(UINT8 *arr, UINT8 len) { UINT8 i =0, tmp; - SMP_TRACE_DEBUG("smp_reverse_array"); + SMP_TRACE_DEBUG("smp_reverse_array\n"); for (i = 0; i < len/2; i ++) { @@ -1330,9 +1330,9 @@ UINT8 smp_calculate_random_input(UINT8 *random, UINT8 round) UINT8 j = round%8; UINT8 ri; - SMP_TRACE_DEBUG("random: 0x%02x, round: %d, i: %d, j: %d", random[i], round, i, j); + SMP_TRACE_DEBUG("random: 0x%02x, round: %d, i: %d, j: %d\n", random[i], round, i, j); ri = ((random[i] >> j) & 1) | 0x80; - SMP_TRACE_DEBUG("%s ri=0x%02x", __func__, ri); + SMP_TRACE_DEBUG("%s ri=0x%02x\n", __func__, ri); return ri; } @@ -1347,7 +1347,7 @@ UINT8 smp_calculate_random_input(UINT8 *random, UINT8 round) *******************************************************************************/ void smp_collect_local_io_capabilities(UINT8 *iocap, tSMP_CB *p_cb) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); iocap[0] = p_cb->local_io_capability; iocap[1] = p_cb->loc_oob_flag; @@ -1365,7 +1365,7 @@ void smp_collect_local_io_capabilities(UINT8 *iocap, tSMP_CB *p_cb) *******************************************************************************/ void smp_collect_peer_io_capabilities(UINT8 *iocap, tSMP_CB *p_cb) { - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); iocap[0] = p_cb->peer_io_caps; iocap[1] = p_cb->peer_oob_flag; @@ -1388,7 +1388,7 @@ void smp_collect_local_ble_address(UINT8 *le_addr, tSMP_CB *p_cb) BD_ADDR bda; UINT8 *p = le_addr; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); BTM_ReadConnectionAddr( p_cb->pairing_bda, bda, &addr_type); BDADDR_TO_STREAM(p, bda); @@ -1411,11 +1411,11 @@ void smp_collect_peer_ble_address(UINT8 *le_addr, tSMP_CB *p_cb) BD_ADDR bda; UINT8 *p = le_addr; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (!BTM_ReadRemoteConnectionAddr(p_cb->pairing_bda, bda, &addr_type)) { - SMP_TRACE_ERROR("can not collect peer le addr information for unknown device"); + SMP_TRACE_ERROR("can not collect peer le addr information for unknown device\n"); return; } @@ -1438,7 +1438,7 @@ BOOLEAN smp_check_commitment(tSMP_CB *p_cb) { BT_OCTET16 expected; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); smp_calculate_peer_commitment(p_cb, expected); print128(expected, (const UINT8 *)"calculated peer commitment"); @@ -1446,11 +1446,11 @@ BOOLEAN smp_check_commitment(tSMP_CB *p_cb) if (memcmp(p_cb->remote_commitment, expected, BT_OCTET16_LEN)) { - SMP_TRACE_WARNING("Commitment check fails"); + SMP_TRACE_WARNING("Commitment check fails\n"); return FALSE; } - SMP_TRACE_DEBUG("Commitment check succeeds"); + SMP_TRACE_DEBUG("Commitment check succeeds\n"); return TRUE; } @@ -1469,14 +1469,14 @@ void smp_save_secure_connections_long_term_key(tSMP_CB *p_cb) tBTM_LE_LENC_KEYS lle_key; tBTM_LE_PENC_KEYS ple_key; - SMP_TRACE_DEBUG("%s-Save LTK as local LTK key", __func__); + SMP_TRACE_DEBUG("%s-Save LTK as local LTK key\n", __func__); memcpy(lle_key.ltk, p_cb->ltk, BT_OCTET16_LEN); lle_key.div = 0; lle_key.key_size = p_cb->loc_enc_size; lle_key.sec_level = p_cb->sec_level; btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_LENC, (tBTM_LE_KEY_VALUE *)&lle_key, TRUE); - SMP_TRACE_DEBUG("%s-Save LTK as peer LTK key", __func__); + SMP_TRACE_DEBUG("%s-Save LTK as peer LTK key\n", __func__); ple_key.ediv = 0; memset(ple_key.rand, 0, BT_OCTET8_LEN); memcpy(ple_key.ltk, p_cb->ltk, BT_OCTET16_LEN); @@ -1504,7 +1504,7 @@ BOOLEAN smp_calculate_f5_mackey_and_long_term_key(tSMP_CB *p_cb) UINT8 *p_na; UINT8 *p_nb; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (p_cb->role == HCI_ROLE_MASTER) { @@ -1523,11 +1523,11 @@ BOOLEAN smp_calculate_f5_mackey_and_long_term_key(tSMP_CB *p_cb) if(!smp_calculate_f5(p_cb->dhkey, p_na, p_nb, a, b, p_cb->mac_key, p_cb->ltk)) { - SMP_TRACE_ERROR("%s failed", __func__); + SMP_TRACE_ERROR("%s failed\n", __func__); return FALSE; } - SMP_TRACE_EVENT ("%s is completed", __func__); + SMP_TRACE_EVENT ("%s is completed\n", __func__); return TRUE; } @@ -1545,7 +1545,7 @@ BOOLEAN smp_request_oob_data(tSMP_CB *p_cb) { tSMP_OOB_DATA_TYPE req_oob_type = SMP_OOB_INVALID_TYPE; - SMP_TRACE_DEBUG("%s", __func__); + SMP_TRACE_DEBUG("%s\n", __func__); if (p_cb->peer_oob_flag == SMP_OOB_PRESENT && p_cb->loc_oob_flag == SMP_OOB_PRESENT) { @@ -1562,7 +1562,7 @@ BOOLEAN smp_request_oob_data(tSMP_CB *p_cb) req_oob_type = SMP_OOB_PEER; } - SMP_TRACE_DEBUG("req_oob_type = %d", req_oob_type); + SMP_TRACE_DEBUG("req_oob_type = %d\n", req_oob_type); if (req_oob_type == SMP_OOB_INVALID_TYPE) return FALSE; diff --git a/components/bt/bt.c b/components/bt/bt.c index 23f8aea92e..051a45d8fd 100644 --- a/components/bt/bt.c +++ b/components/bt/bt.c @@ -1,134 +1,134 @@ -// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at - -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include -#include -#include - -#include "freertos/FreeRTOS.h" -#include "freertos/task.h" -#include "freertos/queue.h" -#include "freertos/semphr.h" -#include "freertos/xtensa_api.h" -#include "freertos/portmacro.h" -#include "esp_types.h" -#include "esp_system.h" -#include "esp_task.h" -#include "esp_intr.h" -#include "esp_attr.h" -#include "bt.h" - -#if CONFIG_BT_ENABLED - -/* not for user call, so don't put to include file */ -extern void btdm_osi_funcs_register(void *osi_funcs); -extern void btdm_controller_init(void); - - -#define BT_DEBUG(...) -#define BT_API_CALL_CHECK(info, api_call, ret) \ -do{\ - esp_err_t __err = (api_call);\ - if ((ret) != __err) {\ - BT_DEBUG("%s %d %s ret=%d\n", __FUNCTION__, __LINE__, (info), __err);\ - return __err;\ - }\ -} while(0) - -struct osi_funcs_t { - xt_handler (*_set_isr)(int n, xt_handler f, void *arg); - void (*_ints_on)(unsigned int mask); - void (*_interrupt_disable)(void); - void (*_interrupt_restore)(void); - void (*_task_yield)(void); - void *(*_semphr_create)(uint32_t max, uint32_t init); - int32_t (*_semphr_give_from_isr)(void *semphr, void *hptw); - int32_t (*_semphr_take)(void *semphr, uint32_t block_time_ms); - void *(*_mutex_create)(void); - int32_t (*_mutex_lock)(void *mutex); - int32_t (*_mutex_unlock)(void *mutex); - esp_err_t (* _read_efuse_mac)(uint8_t mac[6]); -}; - -static portMUX_TYPE global_int_mux = portMUX_INITIALIZER_UNLOCKED; - -static void IRAM_ATTR interrupt_disable(void) -{ - portENTER_CRITICAL(&global_int_mux); -} - -static void IRAM_ATTR interrupt_restore(void) -{ - portEXIT_CRITICAL(&global_int_mux); -} - -static void * IRAM_ATTR semphr_create_wrapper(uint32_t max, uint32_t init) -{ - return (void *)xSemaphoreCreateCounting(max, init); -} - -static int32_t IRAM_ATTR semphr_give_from_isr_wrapper(void *semphr, void *hptw) -{ - return (int32_t)xSemaphoreGiveFromISR(semphr, hptw); -} - -static int32_t IRAM_ATTR semphr_take_wrapper(void *semphr, uint32_t block_time_ms) -{ - return (int32_t)xSemaphoreTake(semphr, block_time_ms / portTICK_RATE_MS); -} - -static void * IRAM_ATTR mutex_create_wrapper(void) -{ - return (void *)xSemaphoreCreateMutex(); -} - -static int32_t IRAM_ATTR mutex_lock_wrapper(void *mutex) -{ - return (int32_t)xSemaphoreTake(mutex, portMAX_DELAY); -} - -static int32_t IRAM_ATTR mutex_unlock_wrapper(void *mutex) -{ - return (int32_t)xSemaphoreGive(mutex); -} - -static struct osi_funcs_t osi_funcs = { - ._set_isr = xt_set_interrupt_handler, - ._ints_on = xt_ints_on, - ._interrupt_disable = interrupt_disable, - ._interrupt_restore = interrupt_restore, - ._task_yield = vPortYield, - ._semphr_create = semphr_create_wrapper, - ._semphr_give_from_isr = semphr_give_from_isr_wrapper, - ._semphr_take = semphr_take_wrapper, - ._mutex_create = mutex_create_wrapper, - ._mutex_lock = mutex_lock_wrapper, - ._mutex_unlock = mutex_unlock_wrapper, - ._read_efuse_mac = system_efuse_read_mac, -}; - -static void bt_controller_task(void *pvParam) -{ - btdm_osi_funcs_register(&osi_funcs); - btdm_controller_init(); -} - -void bt_controller_init() -{ - xTaskCreatePinnedToCore(bt_controller_task, "btController", - ESP_TASK_BT_CONTROLLER_STACK, NULL, - ESP_TASK_BT_CONTROLLER_PRIO, NULL, 0); -} - -#endif +// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include +#include + +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "freertos/queue.h" +#include "freertos/semphr.h" +#include "freertos/xtensa_api.h" +#include "freertos/portmacro.h" +#include "esp_types.h" +#include "esp_system.h" +#include "esp_task.h" +#include "esp_intr.h" +#include "esp_attr.h" +#include "bt.h" + +#if CONFIG_BT_ENABLED + +/* not for user call, so don't put to include file */ +extern void btdm_osi_funcs_register(void *osi_funcs); +extern void btdm_controller_init(void); + + +#define BT_DEBUG(...) +#define BT_API_CALL_CHECK(info, api_call, ret) \ +do{\ + esp_err_t __err = (api_call);\ + if ((ret) != __err) {\ + BT_DEBUG("%s %d %s ret=%d\n", __FUNCTION__, __LINE__, (info), __err);\ + return __err;\ + }\ +} while(0) + +struct osi_funcs_t { + xt_handler (*_set_isr)(int n, xt_handler f, void *arg); + void (*_ints_on)(unsigned int mask); + void (*_interrupt_disable)(void); + void (*_interrupt_restore)(void); + void (*_task_yield)(void); + void *(*_semphr_create)(uint32_t max, uint32_t init); + int32_t (*_semphr_give_from_isr)(void *semphr, void *hptw); + int32_t (*_semphr_take)(void *semphr, uint32_t block_time_ms); + void *(*_mutex_create)(void); + int32_t (*_mutex_lock)(void *mutex); + int32_t (*_mutex_unlock)(void *mutex); + esp_err_t (* _read_efuse_mac)(uint8_t mac[6]); +}; + +static portMUX_TYPE global_int_mux = portMUX_INITIALIZER_UNLOCKED; + +static void IRAM_ATTR interrupt_disable(void) +{ + portENTER_CRITICAL(&global_int_mux); +} + +static void IRAM_ATTR interrupt_restore(void) +{ + portEXIT_CRITICAL(&global_int_mux); +} + +static void * IRAM_ATTR semphr_create_wrapper(uint32_t max, uint32_t init) +{ + return (void *)xSemaphoreCreateCounting(max, init); +} + +static int32_t IRAM_ATTR semphr_give_from_isr_wrapper(void *semphr, void *hptw) +{ + return (int32_t)xSemaphoreGiveFromISR(semphr, hptw); +} + +static int32_t IRAM_ATTR semphr_take_wrapper(void *semphr, uint32_t block_time_ms) +{ + return (int32_t)xSemaphoreTake(semphr, block_time_ms / portTICK_RATE_MS); +} + +static void * IRAM_ATTR mutex_create_wrapper(void) +{ + return (void *)xSemaphoreCreateMutex(); +} + +static int32_t IRAM_ATTR mutex_lock_wrapper(void *mutex) +{ + return (int32_t)xSemaphoreTake(mutex, portMAX_DELAY); +} + +static int32_t IRAM_ATTR mutex_unlock_wrapper(void *mutex) +{ + return (int32_t)xSemaphoreGive(mutex); +} + +static struct osi_funcs_t osi_funcs = { + ._set_isr = xt_set_interrupt_handler, + ._ints_on = xt_ints_on, + ._interrupt_disable = interrupt_disable, + ._interrupt_restore = interrupt_restore, + ._task_yield = vPortYield, + ._semphr_create = semphr_create_wrapper, + ._semphr_give_from_isr = semphr_give_from_isr_wrapper, + ._semphr_take = semphr_take_wrapper, + ._mutex_create = mutex_create_wrapper, + ._mutex_lock = mutex_lock_wrapper, + ._mutex_unlock = mutex_unlock_wrapper, + ._read_efuse_mac = system_efuse_read_mac, +}; + +static void bt_controller_task(void *pvParam) +{ + btdm_osi_funcs_register(&osi_funcs); + btdm_controller_init(); +} + +void bt_controller_init() +{ + xTaskCreatePinnedToCore(bt_controller_task, "btController", + ESP_TASK_BT_CONTROLLER_STACK, NULL, + ESP_TASK_BT_CONTROLLER_PRIO, NULL, 0); +} + +#endif diff --git a/components/bt/component.mk b/components/bt/component.mk index b5a5489ed2..67907b2994 100644 --- a/components/bt/component.mk +++ b/components/bt/component.mk @@ -9,6 +9,7 @@ COMPONENT_ADD_INCLUDEDIRS := bluedroid/bta/include \ bluedroid/gki/include \ bluedroid/hci/include \ bluedroid/osi/include \ + bluedroid/profiles/core/include \ bluedroid/profiles/esp/include \ bluedroid/profiles/std/avrc/include \ bluedroid/profiles/std/battery/include \ @@ -48,7 +49,9 @@ COMPONENT_SRCDIRS := bluedroid/bta/dm \ bluedroid/hci \ bluedroid/main \ bluedroid/osi \ + bluedroid/profiles/core \ bluedroid/profiles/esp/ble_button \ + bluedroid/profiles/esp/wechat_AirSync \ bluedroid/profiles/esp \ bluedroid/profiles/std/avrc \ bluedroid/profiles/std/battery \ diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/app_core/bt_app_core.c b/examples/06_bluedroid_demos/components/bluedroid_demos/app_core/bt_app_core.c index 6a6a018e32..7e7f73db14 100644 --- a/examples/06_bluedroid_demos/components/bluedroid_demos/app_core/bt_app_core.c +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/app_core/bt_app_core.c @@ -14,12 +14,14 @@ #include "bt_app_common.h" #include "controller.h" - +//#include "prf_defs.h" #include "hash_map.h" #include "hash_functions.h" #include "alarm.h" -#include "app_button.h" +//#include "app_button.h" +#if (BUT_PROFILE_CFG) #include "button_pro.h" +#endif ///BUT_PROFILE_CFG #include "thread.h" #include "bt_app_common.h" #include "dis_api.h" @@ -64,12 +66,17 @@ static void bt_app_task_handler(void *arg) if (e->sig == 0xff) { fixed_queue_process(bta_app_msg_queue); fixed_queue_process(bt_app_general_alarm_queue); - }else if(e->sig == BUTTON_PRESS_EVT){ - LOG_ERROR("button_press_event come in,button_value=%x\n",e->par); - button_msg[1] = e->par; - button_msg_notify(2,button_msg); } - osi_free(e); +#if (BUT_PROFILE_CFG) + else if(e->sig == BUTTON_PRESS_EVT){ + LOG_ERROR("button_press_event come in,button_value=%x\n",e->par); + button_msg[1] = e->par; + button_msg_notify(2,button_msg); + + + } +#endif ///BUT_PROFILE_CFG + } } } @@ -187,7 +194,7 @@ void bt_app_task_start_up(void) return; error_exit: - LOG_ERROR("%s Unable to allocate resources for bt_app", __func__); + LOG_ERROR("%s Unable to allocate resources for bt_app\n", __func__); bt_app_task_shut_down(); } @@ -243,13 +250,13 @@ static void bt_app_dm_upstreams_evt(UINT16 event, char *p_param) /*set connectable,discoverable, pairable and paired only modes of local device*/ - tBTA_DM_DISC disc_mode = BTA_DM_GENERAL_DISC | BTA_DM_BLE_GENERAL_DISCOVERABLE; - tBTA_DM_CONN conn_mode = BTA_DM_CONN | BTA_DM_BLE_CONNECTABLE; - BTA_DmSetVisibility(disc_mode, conn_mode, BTA_DM_IGNORE, BTA_DM_IGNORE); + tBTA_DM_DISC disc_mode = BTA_DM_BLE_GENERAL_DISCOVERABLE; + tBTA_DM_CONN conn_mode = BTA_DM_BLE_CONNECTABLE; + BTA_DmSetVisibility(disc_mode, conn_mode, (UINT8)BTA_DM_NON_PAIRABLE, (UINT8)BTA_DM_CONN_ALL); #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE)) /* Enable local privacy */ - BTA_DmBleConfigLocalPrivacy(BLE_LOCAL_PRIVACY_ENABLED); + //BTA_DmBleConfigLocalPrivacy(BLE_LOCAL_PRIVACY_ENABLED); do { const controller_t *controller = controller_get_interface(); char bdstr[18]; @@ -261,17 +268,27 @@ static void bt_app_dm_upstreams_evt(UINT16 event, char *p_param) break; case BTA_DM_BLE_SEC_REQ_EVT: - smp_cmd.local_io_capability = 0x03; //no input no output - smp_cmd.loc_oob_flag = 0x00; //oob data not present - smp_cmd.loc_auth_req = 0x05; - smp_cmd.loc_enc_size = 0x10; - smp_cmd.local_i_key = 0x07; - smp_cmd.local_r_key = 0x07; - memcpy(smp_cmd.pairing_bda,p_data->ble_req.bd_addr,0x06); - smp_send_cmd(SMP_OPCODE_PAIRING_RSP,&smp_cmd); - smp_set_state(SMP_STATE_WAIT_CONFIRM); + smp_cb.local_io_capability = 0x03; //no input no output + smp_cb.loc_oob_flag = 0x00; //oob data not present + smp_cb.loc_auth_req = 0x01; + smp_cb.loc_enc_size = 0x10; + smp_cb.local_i_key = 0x01; + smp_cb.local_r_key = 0x01; //1101 + + //memcpy(smp_cb.pairing_bda,p_data->ble_req.bd_addr,0x06); + + smp_sm_event(&smp_cb,SMP_PAIRING_REQ_EVT,NULL); + //smp_send_cmd(SMP_OPCODE_PAIRING_RSP,&smp_cb); + //smp_generate_srand_mrand_confirm(&smp_cb,NULL); + //smp_set_state(SMP_STATE_PAIR_REQ_RSP,SMP_BR_PAIRING_REQ_EVT); //BTA_DmConfirm(p_data->ble_req.bd_addr,true); break; + case BTA_DM_BLE_KEY_EVT: + if(p_data->ble_key.key_type == BTM_LE_KEY_PENC) + { + smp_set_state(SMP_STATE_IDLE); + } + break; default: break; } @@ -320,7 +337,7 @@ void bt_app_start_timer(TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout_sec) alarm = hash_map_get(bt_app_general_alarm_hash_map, p_tle); pthread_mutex_unlock(&bt_app_general_alarm_lock); if (alarm == NULL) { - LOG_ERROR("%s Unable to create alarm", __func__); + LOG_ERROR("%s Unable to create alarm\n", __func__); return; } @@ -364,6 +381,10 @@ static void bt_app_general_alarm_process(TIMER_LIST_ENT *p_tle) // bt_test_start_inquiry(); + /*set connectable,discoverable, pairable and paired only modes of local device*/ + // tBTA_DM_DISC disc_mode = BTA_DM_BLE_GENERAL_DISCOVERABLE; + // tBTA_DM_CONN conn_mode = BTA_DM_BLE_CONNECTABLE; + // BTA_DmSetVisibility(disc_mode, conn_mode, (UINT8)BTA_DM_NON_PAIRABLE, (UINT8)BTA_DM_CONN_ALL); gatts_server_test(); //gattc_client_test(); diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/app_core/bt_app_sec.c b/examples/06_bluedroid_demos/components/bluedroid_demos/app_core/bt_app_sec.c new file mode 100644 index 0000000000..7662e6e68f --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/app_core/bt_app_sec.c @@ -0,0 +1,108 @@ +/** + **************************************************************************************** + * + * @file bt_app_sec.c + * + * @brief Application entry point + * + * Copyright (C) Espressif 2016 + * Created by Yulong at 2016/10/13 + * + * + **************************************************************************************** + */ + +#include "bt_app_sec.h" +#include // standard library +#include + + + +extern void srand (unsigned int seed); +extern int random (void); + +/// Application Security Environment Structure +tAPP_SEC_ENV app_sec_env; + + +/******************************************************************************* +** +** Function app_ble_sec_gen_tk +** +** Description This function is called to generate the ble tk +** +** Returns the generate tk value +** +*******************************************************************************/ +UINT32 app_ble_sec_gen_tk(void) +{ + // Generate a PIN Code (Between 100000 and 999999) + return (100000 + (random()%900000)); +} + +/******************************************************************************* +** +** Function app_ble_sec_gen_ltk +** +** Description This function is called to generate the ble ltk +** +** Returns NULL +** +*******************************************************************************/ +void app_ble_sec_gen_ltk(UINT8 key_size) +{ + // Counter + UINT8 i; + app_sec_env.key_size = key_size; + + // Randomly generate the LTK and the Random Number + for (i = 0; i < RAND_NB_LEN; i++) + { + app_sec_env.rand_nb.nb[i] = random()%256; + } + + // Randomly generate the end of the LTK + for (i = 0; i < SEC_KEY_LEN; i++) + { + app_sec_env.ltk.key[i] = (((key_size) < (16 - i)) ? 0 : random()%256); + } + + // Randomly generate the EDIV + app_sec_env.ediv = random()%65536; +} + + +/******************************************************************************* +** +** Function app_ble_sec_init +** +** Description This function is init the security env and function +** +** Returns NULL +** +*******************************************************************************/ +void app_ble_sec_init() +{ + // Reset Security Environment + memset(&app_sec_env, 0, sizeof(app_sec_env)); +} + + +/******************************************************************************* +** +** Function app_ble_security_start +** +** Description This function is called by the slave when the seurity start +** +** Returns NULL +** +*******************************************************************************/ +void app_ble_security_start(void) +{ + +} + + + + + diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/app_airsync_md5.c b/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/app_airsync_md5.c new file mode 100644 index 0000000000..7271f6473a --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/app_airsync_md5.c @@ -0,0 +1,130 @@ +/** + **************************************************************************************** + * + * @file app_airsync_md5.h + * + * @brief Application airsync md5 generation Entry Point + * + * Copyright (C) ESPRESSIF 2016 + * Created by Yulong at 2016/10/9 + * + **************************************************************************************** + */ + +#include "prf_defs.h" +#if (WX_AIRSYNC_CFG) + + +#include +#include +#include +#include "gki.h" +#include "app_airsync_md5.h" + +const uint32_t X[4][2] = {{0, 1}, {1, 5}, {5, 3}, {0, 7}}; +const uint32_t S[4][4] = {{ 7, 12, 17, 22 },{ 5, 9 , 14, 20 },{ 4, 11, 16, 23 },{ 6, 10, 15, 21 }}; +uint32_t F( uint32_t X, uint32_t Y, uint32_t Z ) +{ + return ( X & Y ) | ( ~X & Z ); +} +uint32_t G( uint32_t X, uint32_t Y, uint32_t Z ) + { + return ( X & Z ) | ( Y & ~Z ); + } +uint32_t H( uint32_t X, uint32_t Y, uint32_t Z ) +{ + return X ^ Y ^ Z; +} +uint32_t I( uint32_t X, uint32_t Y, uint32_t Z ) +{ + return Y ^ ( X | ~Z ); +} + // rotates x left s bits. +uint32_t rotate_left( uint32_t x, uint32_t s ) +{ + return ( x << s ) | ( x >> ( 32 - s ) ); +} + + // Pre-processin +uint32_t count_padding_bits ( uint32_t length ) +{ +// uint32_t div = length * BITS / BLOCK_SIZE; + uint32_t mod = length * BITS % BLOCK_SIZE; + uint32_t c_bits; + if ( mod == 0 ) + { + c_bits = MOD_SIZE; + } + else + { + c_bits = ( MOD_SIZE + BLOCK_SIZE - mod ) % BLOCK_SIZE; + } + return c_bits / BITS; +} + +MD5String append_padding_bits ( char * argv ) +{ + uint32_t msg_length = strlen ( argv ); + uint32_t bit_length = count_padding_bits ( msg_length ); + uint64_t app_length = msg_length * BITS; + MD5String string; + string.str = (char *)GKI_getbuf(msg_length + bit_length + APP_SIZE / BITS); + strncpy ( string.str, argv, msg_length ); + memset ( string.str + msg_length, 0, bit_length ); + string.str [ msg_length ] = SINGLE_ONE_BIT; + memmove ( string.str + msg_length + bit_length, (char *)&app_length, sizeof( uint64_t ) ); + string.len = msg_length + bit_length + sizeof( uint64_t ); + return string; +} + +int32_t wechat_md5 (char *argv, uint8_t *md5_32) +{ + MD5String string; + uint32_t w[16]; + uint32_t chain[4]; + uint32_t state[4]; + + uint32_t ( *auxi[ 4 ])( uint32_t, uint32_t, uint32_t ) = { F, G, H, I }; + int sIdx; + int wIdx; + string = append_padding_bits ( argv ); + chain[0] = A; + chain[1] = B; + chain[2] = C; + chain[3] = D; + for (uint32_t j = 0; j < string.len; j += BLOCK_SIZE / BITS) + { + memmove ( (char *)w, string.str + j, BLOCK_SIZE / BITS ); + memmove ( state, chain, sizeof(chain) ); + for ( uint8_t roundIdx = 0; roundIdx < 4; roundIdx++ ) + { + wIdx = X[ roundIdx ][ 0 ]; + sIdx = 0; + for (uint8_t i = 0; i < 16; i++ ) + { + state[sIdx] = state [(sIdx + 1)%4] + rotate_left( state[sIdx] +(*auxi[ roundIdx])( state[(sIdx+1) % 4], + state[(sIdx+2) % 4], + state[(sIdx+3) % 4]) + w[ wIdx ] + (uint32_t)floor((1ULL << 32) * fabs(sin( roundIdx * 16 + i + 1 )) ), + S[ roundIdx ][ i % 4 ]); + sIdx = ( sIdx + 3 ) % 4; + wIdx = ( wIdx + X[ roundIdx ][ 1 ] ) & 0xF; + } + } + chain[ 0 ] += state[ 0 ]; + chain[ 1 ] += state[ 1 ]; + chain[ 2 ] += state[ 2 ]; + chain[ 3 ] += state[ 3 ]; + } + memmove ( md5_32 + 0, (char *)&chain[0], sizeof(uint32_t) ); + memmove ( md5_32 + 4, (char *)&chain[1], sizeof(uint32_t) ); + memmove ( md5_32 + 8, (char *)&chain[2], sizeof(uint32_t) ); + memmove ( md5_32 + 12, (char *)&chain[3], sizeof(uint32_t) ); + free(string.str); + string.str = NULL; + return EXIT_SUCCESS; + +} + + +#endif ///WX_AIRSYNC_CFG + diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/app_airsync_prf.c b/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/app_airsync_prf.c new file mode 100644 index 0000000000..60cc8329fc --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/app_airsync_prf.c @@ -0,0 +1,160 @@ +/** + **************************************************************************************** + * + * @file app_airsync_prf.c + * + * @brief Application Security Entry Point + * + * Copyright (C) ESPRESSIF 2016 + * Created by Yulong at 2016/9/30 + * + **************************************************************************************** + */ + +#include "prf_defs.h" +#if (WX_AIRSYNC_CFG) + +#include "app_airsync_prf.h" +#include "wx_airsync_prf.h" +#include "app_wechat_util.h" +#include "gki.h" +#include "mpbledemo2.h" + +/***************************************************************************** +* data handle +*****************************************************************************/ +data_info g_send_data; + +static data_info g_rcv_data; +data_handler *pDataHandler; + + +static void airsync_process_msgreceive_cb(UINT8 app_id, + UINT8 conn_id,uint8_t *pData, uint16_t length); + +///function for register all products +static void register_all_products(void) +{ + REGISTER(mpbledemo2); + // could register more products if defined +} + +void app_wechat_init(void) +{ + register_all_products(); + + data_handler_init(&m_mpbledemo2_handler,PRODUCT_TYPE_MPBLEDEMO2); + m_mpbledemo2_handler->m_data_init_func(); + m_mpbledemo2_handler->m_data_init_peripheral_func(); + + app_wechat_SetDatahandler(m_mpbledemo2_handler); +} + +int ble_wechat_indicate_data_chunk(void) +{ + uint16_t chunk_len = 0; + chunk_len = g_send_data.len - g_send_data.offset; + chunk_len = chunk_len > BLE_WECHAT_MAX_DATA_LEN?BLE_WECHAT_MAX_DATA_LEN:chunk_len; + + if(chunk_len == 0) + { + app_wechat_datahandler()->m_data_free_func(g_send_data.data,g_send_data.len); + g_send_data.data = NULL; + g_send_data.len = 0; + g_send_data.offset = 0; + return 0; + } + + g_send_data.offset += chunk_len; + return 1; +} + + + /******************************************************************************* +** +** Function airsync_msgreceive_cb +** +** Description the callback function after the airsync profile have been +** receive the data from the peer device +** parms appid:the appid have been register to the gatt database +** conn_id:the current connection index +** msg_val:the airsync value receive from peer device +** Returns NULL +** +*******************************************************************************/ +static void airsync_process_msgreceive_cb(UINT8 app_id, + UINT8 conn_id,uint8_t *pData, uint16_t length) +{ + int error_code; + int chunk_size = 0; + if(length <= BLE_WECHAT_MAX_DATA_LEN) + { + if(g_rcv_data.len == 0) + { + BpFixHead *fix_head = (BpFixHead *)pData; + g_rcv_data.len = ntohs(fix_head->nLength); + g_rcv_data.offset = 0; + g_rcv_data.data = (uint8_t *)GKI_getbuf(g_rcv_data.len); + } + + chunk_size = g_rcv_data.len - g_rcv_data.offset; + chunk_size = chunk_size < length ? chunk_size : length; + memcpy(g_rcv_data.data + g_rcv_data.offset, pData, chunk_size); + g_rcv_data.offset += chunk_size; + + if (g_rcv_data.len <= g_rcv_data.offset) + { + error_code = app_wechat_datahandler()->m_data_consume_func(g_rcv_data.data, g_rcv_data.len); + app_wechat_datahandler()->m_data_free_func(g_rcv_data.data,g_rcv_data.len); + wechat_error_chack(app_wechat_datahandler(), error_code); + g_rcv_data.len = 0; + g_rcv_data.offset = 0; + + app_wechat_datahandler()->m_data_main_process_func(); + } + + + } + + +} + + void app_wechat_SetDatahandler(data_handler* pHandler) +{ + pDataHandler = pHandler; +} + +bool ble_wechat_is_last_data_sent_out(void) +{ + return (g_send_data.len == 0 && g_send_data.offset == 0 ) || \ + (g_send_data.len != 0 && g_send_data.len == g_send_data.offset); +} + +//device sent data on the indicate characteristic +int ble_wechat_indicate_data(uint8_t *data, int len) +{ + if(data == NULL || len == 0) + { + return 0; + } + + if(!ble_wechat_is_last_data_sent_out()) + { + return 0; + } + + g_send_data.data = data; + g_send_data.len = len; + g_send_data.offset = 0; + + return (ble_wechat_indicate_data_chunk()); +} + +data_handler *app_wechat_datahandler(void) +{ + return pDataHandler; +} + + +#endif ///WX_AIRSYNC_CFG + diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/epb.c b/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/epb.c new file mode 100644 index 0000000000..3a830b064b --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/epb.c @@ -0,0 +1,414 @@ +// epb.c +// WeChat Embedded Proto Buffer +// +// Created by harlliu@tencent.com on 14-02-15. +// Copyright 2014 Tencent. All rights reserved. +// + +// Version : 1.0.2 + +#include "prf_defs.h" +#if (WX_AIRSYNC_CFG) + + +#include +#include "epb.h" + + +#define __LITTLE_ENDIAN__ 1 //Need Test + +typedef enum { + WIRETYPE_VARINT = 0, + WIRETYPE_FIXED64 = 1, + WIRETYPE_LENGTH_DELIMITED = 2, + WIRETYPE_FIXED32 = 5 +} WireType; + +#define CONTINUOUS_MASK 0x80 +#define WIRETYPE_MASK 0x07 + +static int epb_get_varint32_bits(const uint8_t *data, int len, uint32_t *value); + +inline static int sizeof_tag(uint16_t tag) +{ + return ((tag&0xff00) == 0) ? 1 : 2; //TODO:Tag more then two bytes +} + +static uint16_t epb_get_wire_type(uint16_t tag) { + uint16_t wire_type = tag & WIRETYPE_MASK; + if ((tag>>8) != 0) + wire_type = (tag>>8) & WIRETYPE_MASK; + + return wire_type; +} + +static int epb_get_value_length(const uint8_t *data, int len, uint32_t wire_type) +{ + int offset = 0; + switch(wire_type) { + case WIRETYPE_VARINT: + while ((data[offset++]&CONTINUOUS_MASK)!=0 && offset= len) + return -1; + + if (offset >= 5) + break; + + p_value |= ((uint32_t)data[offset]&0x7F) << (offset*7); + ++offset; + } + *value = p_value; + return offset; +} + +static uint32_t epb_get_fixed32_bits(const uint8_t *data, int len) +{ + if(len < 4) + return 0; + + uint32_t value = 0; +#ifdef __LITTLE_ENDIAN__ + memcpy(&value, data, sizeof(uint32_t)); +#else + value = (data[3]<<24)|(data[2]<<16)|(data[1]<<8)|data[0]; +#endif + return value; +} + +void epb_unpack_init(Epb *e, const uint8_t *buf, int len) +{ + e->unpack_buf = buf; + e->buf_len = len; +} + +bool epb_has_tag(Epb *e, uint16_t tag) +{ + int offset = epb_get_tag_value_offset(e->unpack_buf, e->buf_len, tag); + if (offset < 0) + return false; + else + return true; +} + +uint32_t epb_get_uint32(Epb *e, uint16_t tag) +{ + int offset = epb_get_tag_value_offset(e->unpack_buf, e->buf_len, tag); + if (offset < 0) + return 0; + + uint32_t value = 0; + epb_get_varint32_bits(e->unpack_buf+offset, e->buf_len-offset, &value); + return value; +} + +int32_t epb_get_int32(Epb *e, uint16_t tag) +{ + return epb_get_uint32(e, tag); +} + +int32_t epb_get_sint32(Epb *e, uint16_t tag) +{ + uint32_t value = epb_get_uint32(e, tag); + if (value&1) + return -(value>>1) - 1; + else + return value>>1; +} + +bool epb_get_bool(Epb *e, uint16_t tag) +{ + return epb_get_uint32(e, tag); +} + +int epb_get_enum(Epb *e, uint16_t tag) +{ + return epb_get_uint32(e, tag); +} + +const uint8_t *epb_get_bytes(Epb *e, uint16_t tag, int *len) +{ + int offset = epb_get_tag_value_offset(e->unpack_buf, e->buf_len, tag); + if (offset < 0) + return NULL; + + uint32_t l; + offset += epb_get_varint32_bits(e->unpack_buf+offset, e->buf_len-offset, &l); + *len = (int)l; + + return e->unpack_buf+offset; +} + +const char *epb_get_string(Epb *e, uint16_t tag, int *len) +{ + return (char *)epb_get_bytes(e, tag, len); +} + +const Message *epb_get_message(Epb *e, uint16_t tag, int *len) +{ + return (Message *)epb_get_bytes(e, tag, len); +} + +uint32_t epb_get_fixed32(Epb *e, uint16_t tag) +{ + int offset = epb_get_tag_value_offset(e->unpack_buf, e->buf_len, tag); + if (offset < 0) + return 0; + + return epb_get_fixed32_bits(e->unpack_buf+offset, e->buf_len-offset); +} + +int32_t epb_get_sfixed32(Epb *e, uint16_t tag) +{ + return epb_get_fixed32(e, tag); +} + +float epb_get_float(Epb *e, uint16_t tag) +{ + uint32_t bits = epb_get_fixed32(e, tag); + return *(float *)&bits; +} + +/* + epb pack functions +*/ + +inline static int epb_pack_buf_remain(Epb *e) +{ + return e->buf_len - e->buf_offset; +} + +static int epb_pack_tag(Epb *e, uint16_t tag) +{ + int tag_len = sizeof_tag(tag); + if (epb_pack_buf_remain(e) >= tag_len) { + uint8_t *buf = e->pack_buf + e->buf_offset; + if (tag_len == 2) //TODO + *(buf++) = 0xff&(tag>>8); + *buf = 0xff&tag; + e->buf_offset += tag_len; + return tag_len; + } + return -1; +} + +static int epb_pack_varint32_bits(Epb *e, uint32_t value) +{ + uint8_t buf[5] = {0}; + int i = 0; + do { + buf[i] = value&0x7f; + if (i-1 >= 0) + buf[i-1] |= 0x80; + value = value >> 7; + ++i; + } while (value!=0 && i<5); + if (epb_pack_buf_remain(e) >= i) { + memcpy(e->pack_buf+e->buf_offset, buf, i); + e->buf_offset += i; + return i; + } + return -1; +} + +void epb_pack_init(Epb *e, uint8_t *buf, int len) +{ + e->pack_buf = buf; + e->buf_len = len; + e->buf_offset = 0; +} + +int epb_get_packed_size(Epb *e) +{ + return e->buf_offset; +} + +int epb_set_uint32(Epb *e, uint16_t tag, uint32_t value) +{ + int len = 0; + int ret = epb_pack_tag(e, tag); + if (ret < 0) return ret; + len += ret; + + ret = epb_pack_varint32_bits(e, value); + if (ret < 0) return ret; + len += ret; + + return len; +} + +int epb_set_int32(Epb *e, uint16_t tag, int32_t value) +{ + return epb_set_uint32(e, tag, value); +} + +int epb_set_sint32(Epb *e, uint16_t tag, int32_t value) +{ + uint32_t v = (value << 1) ^ (value >> 31); + return epb_set_uint32(e, tag, v); +} + +int epb_set_bool(Epb *e, uint16_t tag, bool value) +{ + return epb_set_uint32(e, tag, value); +} + +int epb_set_enum(Epb *e, uint16_t tag, int value) +{ + return epb_set_uint32(e, tag, value); +} + +static int epb_set_fixed32_bits(Epb *e, uint32_t value) +{ + if (epb_pack_buf_remain(e) >= 4) { +#ifdef __LITTLE_ENDIAN__ + memcpy(e->pack_buf+e->buf_offset, &value, 4); +#else + uint8_t *data = (uint8_t *)&value; + for (int i=0; i<4; i++) { + *(e->pack_buf+e->buf_offset+i) = data[4-i]; + } +#endif + e->buf_offset += 4; + return 4; + } + return -1; +} + +static int epb_pack_length_delimited(Epb *e, const uint8_t *data, int len) +{ + if (epb_pack_buf_remain(e) >= len) { + memcpy(e->pack_buf + e->buf_offset, data, len); + e->buf_offset += len; + return len; + } + return -1; +} + +int epb_set_bytes(Epb *e, uint16_t tag, const uint8_t *data, int length) +{ + int len = 0; + int ret = epb_pack_tag(e, tag); + if (ret < 0) return ret; + len += ret; + + ret = epb_pack_varint32_bits(e, length); + if (ret < 0) return ret; + len += ret; + + ret = epb_pack_length_delimited(e, data, length); + if (ret < 0) return ret; + len += ret; + + return len; +} + +int epb_set_string(Epb *e, uint16_t tag, const char *data, int len) +{ + return epb_set_bytes(e, tag, (const uint8_t *)data, len); +} + +int epb_set_message(Epb *e, uint16_t tag, const Message *data, int len) +{ + return epb_set_bytes(e, tag, data, len); +} + +int epb_set_fixed32(Epb *e, uint16_t tag, uint32_t value) +{ + int len = 0; + int ret = epb_pack_tag(e, tag); + if (ret < 0) return ret; + len += ret; + + ret = epb_set_fixed32_bits(e, value); + if (ret < 0) return ret; + len += ret; + + return len; +} + +int epb_set_sfixed32(Epb *e, uint16_t tag, int32_t value) +{ + return epb_set_fixed32(e, tag, value); +} + +int epb_set_float(Epb *e, uint16_t tag, float value) +{ + uint32_t v = *(uint32_t *)&value; + return epb_set_fixed32(e, tag, v); +} + +int epb_varint32_pack_size(uint16_t tag, uint32_t value, bool is_signed) +{ + if (is_signed) + value = (value << 1) ^ (value >> 31); + + int i = 0; + do { + value = value >> 7; + ++i; + } while (value!=0 && i<5); + + return sizeof_tag(tag) + i; +} + +int epb_fixed32_pack_size(uint16_t tag) +{ + return sizeof_tag(tag) + 4; +} + +int epb_length_delimited_pack_size(uint16_t tag, int len) +{ + return epb_varint32_pack_size(tag, len, false) + len; +} + + +#endif ///WX_AIRSYNC_CFG \ No newline at end of file diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/epb_mmbp.c b/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/epb_mmbp.c new file mode 100644 index 0000000000..48f9f7b937 --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/epb_mmbp.c @@ -0,0 +1,565 @@ +// epb_MmBp.c +// WeChat Embedded Proto Buffer +// +// Generated by harlliu@tencent.com on 14-11-26. +// Copyright 2014 Tencent. All rights reserved. +// + +// Version : 1.0.4 + +#include "prf_defs.h" +#if (WX_AIRSYNC_CFG) + + +#include +#include +#include +#include "epb_MmBp.h" +#include "gki.h" + +#define TAG_BaseResponse_ErrCode 0x08 +#define TAG_BaseResponse_ErrMsg 0x12 + +#define TAG_AuthRequest_BaseRequest 0x0a +#define TAG_AuthRequest_Md5DeviceTypeAndDeviceId 0x12 +#define TAG_AuthRequest_ProtoVersion 0x18 +#define TAG_AuthRequest_AuthProto 0x20 +#define TAG_AuthRequest_AuthMethod 0x28 +#define TAG_AuthRequest_AesSign 0x32 +#define TAG_AuthRequest_MacAddress 0x3a +#define TAG_AuthRequest_TimeZone 0x52 +#define TAG_AuthRequest_Language 0x5a +#define TAG_AuthRequest_DeviceName 0x62 + +#define TAG_AuthResponse_BaseResponse 0x0a +#define TAG_AuthResponse_AesSessionKey 0x12 + +#define TAG_InitRequest_BaseRequest 0x0a +#define TAG_InitRequest_RespFieldFilter 0x12 +#define TAG_InitRequest_Challenge 0x1a + +#define TAG_InitResponse_BaseResponse 0x0a +#define TAG_InitResponse_UserIdHigh 0x10 +#define TAG_InitResponse_UserIdLow 0x18 +#define TAG_InitResponse_ChalleangeAnswer 0x20 +#define TAG_InitResponse_InitScence 0x28 +#define TAG_InitResponse_AutoSyncMaxDurationSecond 0x30 +#define TAG_InitResponse_UserNickName 0x5a +#define TAG_InitResponse_PlatformType 0x60 +#define TAG_InitResponse_Model 0x6a +#define TAG_InitResponse_Os 0x72 +#define TAG_InitResponse_Time 0x78 +#define TAG_InitResponse_TimeZone 0x8001 +#define TAG_InitResponse_TimeString 0x8a01 + +#define TAG_SendDataRequest_BaseRequest 0x0a +#define TAG_SendDataRequest_Data 0x12 +#define TAG_SendDataRequest_Type 0x18 + +#define TAG_SendDataResponse_BaseResponse 0x0a +#define TAG_SendDataResponse_Data 0x12 + +#define TAG_RecvDataPush_BasePush 0x0a +#define TAG_RecvDataPush_Data 0x12 +#define TAG_RecvDataPush_Type 0x18 + +#define TAG_SwitchViewPush_BasePush 0x0a +#define TAG_SwitchViewPush_SwitchViewOp 0x10 +#define TAG_SwitchViewPush_ViewId 0x18 + +#define TAG_SwitchBackgroudPush_BasePush 0x0a +#define TAG_SwitchBackgroudPush_SwitchBackgroundOp 0x10 + + +int epb_base_request_pack_size(BaseRequest *request) +{ + int pack_size = 0; + + return pack_size; +} + +int epb_pack_base_request(BaseRequest *request, uint8_t *buf, int buf_len) +{ + Epb epb; + epb_pack_init(&epb, buf, buf_len); + + return epb_get_packed_size(&epb); +} + +BaseResponse *epb_unpack_base_response(const uint8_t *buf, int buf_len) +{ + Epb epb; + epb_unpack_init(&epb, buf, buf_len); + + if (!epb_has_tag(&epb, TAG_BaseResponse_ErrCode)) { + return NULL; + } + + BaseResponse *response = (BaseResponse *)GKI_getbuf(sizeof(BaseResponse)); + memset(response, 0, sizeof(BaseResponse)); + response->err_code = epb_get_int32(&epb, TAG_BaseResponse_ErrCode); + if (epb_has_tag(&epb, TAG_BaseResponse_ErrMsg)) { + response->err_msg.str = epb_get_string(&epb, TAG_BaseResponse_ErrMsg, &response->err_msg.len); + response->has_err_msg = true; + } + + return response; +} + +void epb_unpack_base_response_free(BaseResponse *response) +{ + GKI_freebuf(response); +} + +BasePush *epb_unpack_base_push(const uint8_t *buf, int buf_len) +{ + Epb epb; + epb_unpack_init(&epb, buf, buf_len); + + BasePush *push = (BasePush *)GKI_getbuf(sizeof(BasePush)); + memset(push, 0, sizeof(BasePush)); + + return push; +} + +void epb_unpack_base_push_free(BasePush *push) +{ + GKI_freebuf(push); +} + +int epb_auth_request_pack_size(AuthRequest *request) +{ + int pack_size = 0; + int len = 0; + + len = epb_base_request_pack_size(request->base_request); + pack_size += epb_length_delimited_pack_size(TAG_AuthRequest_BaseRequest, len); + if (request->has_md5_device_type_and_device_id) { + pack_size += epb_length_delimited_pack_size(TAG_AuthRequest_Md5DeviceTypeAndDeviceId, request->md5_device_type_and_device_id.len); + } + pack_size += epb_varint32_pack_size(TAG_AuthRequest_ProtoVersion, request->proto_version, false); + pack_size += epb_varint32_pack_size(TAG_AuthRequest_AuthProto, request->auth_proto, false); + pack_size += epb_varint32_pack_size(TAG_AuthRequest_AuthMethod, request->auth_method, false); + if (request->has_aes_sign) { + pack_size += epb_length_delimited_pack_size(TAG_AuthRequest_AesSign, request->aes_sign.len); + } + if (request->has_mac_address) { + pack_size += epb_length_delimited_pack_size(TAG_AuthRequest_MacAddress, request->mac_address.len); + } + if (request->has_time_zone) { + pack_size += epb_length_delimited_pack_size(TAG_AuthRequest_TimeZone, request->time_zone.len); + } + if (request->has_language) { + pack_size += epb_length_delimited_pack_size(TAG_AuthRequest_Language, request->language.len); + } + if (request->has_device_name) { + pack_size += epb_length_delimited_pack_size(TAG_AuthRequest_DeviceName, request->device_name.len); + } + + return pack_size; +} + +int epb_pack_auth_request(AuthRequest *request, uint8_t *buf, int buf_len) +{ + Epb epb; + epb_pack_init(&epb, buf, buf_len); + + int ret; + int tmp_len; + uint8_t *tmp; + + tmp_len = epb_base_request_pack_size(request->base_request); + tmp = (uint8_t *)GKI_getbuf(tmp_len); + ret = epb_pack_base_request(request->base_request, tmp, tmp_len); + if (ret < 0) { + GKI_freebuf(tmp); + return ret; + } + ret = epb_set_message(&epb, TAG_AuthRequest_BaseRequest, tmp, tmp_len); + GKI_freebuf(tmp); + if (ret < 0) return ret; + if (request->has_md5_device_type_and_device_id) { + ret = epb_set_bytes(&epb, TAG_AuthRequest_Md5DeviceTypeAndDeviceId, request->md5_device_type_and_device_id.data, request->md5_device_type_and_device_id.len); + if (ret < 0) return ret; + } + ret = epb_set_int32(&epb, TAG_AuthRequest_ProtoVersion, request->proto_version); + if (ret < 0) return ret; + ret = epb_set_int32(&epb, TAG_AuthRequest_AuthProto, request->auth_proto); + if (ret < 0) return ret; + ret = epb_set_enum(&epb, TAG_AuthRequest_AuthMethod, request->auth_method); + if (ret < 0) return ret; + if (request->has_aes_sign) { + ret = epb_set_bytes(&epb, TAG_AuthRequest_AesSign, request->aes_sign.data, request->aes_sign.len); + if (ret < 0) return ret; + } + if (request->has_mac_address) { + ret = epb_set_bytes(&epb, TAG_AuthRequest_MacAddress, request->mac_address.data, request->mac_address.len); + if (ret < 0) return ret; + } + if (request->has_time_zone) { + ret = epb_set_string(&epb, TAG_AuthRequest_TimeZone, request->time_zone.str, request->time_zone.len); + if (ret < 0) return ret; + } + if (request->has_language) { + ret = epb_set_string(&epb, TAG_AuthRequest_Language, request->language.str, request->language.len); + if (ret < 0) return ret; + } + if (request->has_device_name) { + ret = epb_set_string(&epb, TAG_AuthRequest_DeviceName, request->device_name.str, request->device_name.len); + if (ret < 0) return ret; + } + + return epb_get_packed_size(&epb); +} + +AuthResponse *epb_unpack_auth_response(const uint8_t *buf, int buf_len) +{ + Epb epb; + epb_unpack_init(&epb, buf, buf_len); + + const uint8_t *tmp; + int tmp_len; + + if (!epb_has_tag(&epb, TAG_AuthResponse_BaseResponse)) { + return NULL; + } + if (!epb_has_tag(&epb, TAG_AuthResponse_AesSessionKey)) { + return NULL; + } + + AuthResponse *response = (AuthResponse *)GKI_getbuf(sizeof(AuthResponse)); + memset(response, 0, sizeof(AuthResponse)); + tmp = epb_get_message(&epb, TAG_AuthResponse_BaseResponse, &tmp_len); + response->base_response = epb_unpack_base_response(tmp, tmp_len); + if (response->base_response == NULL) { + GKI_freebuf(response); + return NULL; + } + response->aes_session_key.data = epb_get_bytes(&epb, TAG_AuthResponse_AesSessionKey, &response->aes_session_key.len); + + return response; +} + +void epb_unpack_auth_response_free(AuthResponse *response) +{ + epb_unpack_base_response_free(response->base_response); + GKI_freebuf(response); +} + +int epb_init_request_pack_size(InitRequest *request) +{ + int pack_size = 0; + int len = 0; + + len = epb_base_request_pack_size(request->base_request); + pack_size += epb_length_delimited_pack_size(TAG_InitRequest_BaseRequest, len); + if (request->has_resp_field_filter) { + pack_size += epb_length_delimited_pack_size(TAG_InitRequest_RespFieldFilter, request->resp_field_filter.len); + } + if (request->has_challenge) { + pack_size += epb_length_delimited_pack_size(TAG_InitRequest_Challenge, request->challenge.len); + } + + return pack_size; +} + +int epb_pack_init_request(InitRequest *request, uint8_t *buf, int buf_len) +{ + Epb epb; + epb_pack_init(&epb, buf, buf_len); + + int ret; + int tmp_len; + uint8_t *tmp; + + tmp_len = epb_base_request_pack_size(request->base_request); + tmp = (uint8_t *)GKI_getbuf(tmp_len); + ret = epb_pack_base_request(request->base_request, tmp, tmp_len); + if (ret < 0) { + GKI_freebuf(tmp); + return ret; + } + ret = epb_set_message(&epb, TAG_InitRequest_BaseRequest, tmp, tmp_len); + GKI_freebuf(tmp); + if (ret < 0) return ret; + if (request->has_resp_field_filter) { + ret = epb_set_bytes(&epb, TAG_InitRequest_RespFieldFilter, request->resp_field_filter.data, request->resp_field_filter.len); + if (ret < 0) return ret; + } + if (request->has_challenge) { + ret = epb_set_bytes(&epb, TAG_InitRequest_Challenge, request->challenge.data, request->challenge.len); + if (ret < 0) return ret; + } + + return epb_get_packed_size(&epb); +} + +InitResponse *epb_unpack_init_response(const uint8_t *buf, int buf_len) +{ + Epb epb; + epb_unpack_init(&epb, buf, buf_len); + + const uint8_t *tmp; + int tmp_len; + + if (!epb_has_tag(&epb, TAG_InitResponse_BaseResponse)) { + return NULL; + } + if (!epb_has_tag(&epb, TAG_InitResponse_UserIdHigh)) { + return NULL; + } + if (!epb_has_tag(&epb, TAG_InitResponse_UserIdLow)) { + return NULL; + } + + InitResponse *response = (InitResponse *)GKI_getbuf(sizeof(InitResponse)); + memset(response, 0, sizeof(InitResponse)); + tmp = epb_get_message(&epb, TAG_InitResponse_BaseResponse, &tmp_len); + response->base_response = epb_unpack_base_response(tmp, tmp_len); + if (response->base_response == NULL) { + GKI_freebuf(response); + return NULL; + } + response->user_id_high = epb_get_uint32(&epb, TAG_InitResponse_UserIdHigh); + response->user_id_low = epb_get_uint32(&epb, TAG_InitResponse_UserIdLow); + if (epb_has_tag(&epb, TAG_InitResponse_ChalleangeAnswer)) { + response->challeange_answer = epb_get_uint32(&epb, TAG_InitResponse_ChalleangeAnswer); + response->has_challeange_answer = true; + } + if (epb_has_tag(&epb, TAG_InitResponse_InitScence)) { + response->init_scence = (EmInitScence)epb_get_enum(&epb, TAG_InitResponse_InitScence); + response->has_init_scence = true; + } + if (epb_has_tag(&epb, TAG_InitResponse_AutoSyncMaxDurationSecond)) { + response->auto_sync_max_duration_second = epb_get_uint32(&epb, TAG_InitResponse_AutoSyncMaxDurationSecond); + response->has_auto_sync_max_duration_second = true; + } + if (epb_has_tag(&epb, TAG_InitResponse_UserNickName)) { + response->user_nick_name.str = epb_get_string(&epb, TAG_InitResponse_UserNickName, &response->user_nick_name.len); + response->has_user_nick_name = true; + } + if (epb_has_tag(&epb, TAG_InitResponse_PlatformType)) { + response->platform_type = (EmPlatformType)epb_get_enum(&epb, TAG_InitResponse_PlatformType); + response->has_platform_type = true; + } + if (epb_has_tag(&epb, TAG_InitResponse_Model)) { + response->model.str = epb_get_string(&epb, TAG_InitResponse_Model, &response->model.len); + response->has_model = true; + } + if (epb_has_tag(&epb, TAG_InitResponse_Os)) { + response->os.str = epb_get_string(&epb, TAG_InitResponse_Os, &response->os.len); + response->has_os = true; + } + if (epb_has_tag(&epb, TAG_InitResponse_Time)) { + response->time = epb_get_int32(&epb, TAG_InitResponse_Time); + response->has_time = true; + } + if (epb_has_tag(&epb, TAG_InitResponse_TimeZone)) { + response->time_zone = epb_get_int32(&epb, TAG_InitResponse_TimeZone); + response->has_time_zone = true; + } + if (epb_has_tag(&epb, TAG_InitResponse_TimeString)) { + response->time_string.str = epb_get_string(&epb, TAG_InitResponse_TimeString, &response->time_string.len); + response->has_time_string = true; + } + + return response; +} + +void epb_unpack_init_response_free(InitResponse *response) +{ + epb_unpack_base_response_free(response->base_response); + GKI_freebuf((void *)response); +} + +int epb_send_data_request_pack_size(SendDataRequest *request) +{ + int pack_size = 0; + int len = 0; + + len = epb_base_request_pack_size(request->base_request); + pack_size += epb_length_delimited_pack_size(TAG_SendDataRequest_BaseRequest, len); + pack_size += epb_length_delimited_pack_size(TAG_SendDataRequest_Data, request->data.len); + if (request->has_type) { + pack_size += epb_varint32_pack_size(TAG_SendDataRequest_Type, request->type, false); + } + + return pack_size; +} + +int epb_pack_send_data_request(SendDataRequest *request, uint8_t *buf, int buf_len) +{ + Epb epb; + epb_pack_init(&epb, buf, buf_len); + + int ret; + int tmp_len; + uint8_t *tmp; + + tmp_len = epb_base_request_pack_size(request->base_request); + tmp = (uint8_t *)GKI_getbuf(tmp_len); + ret = epb_pack_base_request(request->base_request, tmp, tmp_len); + if (ret < 0) { + GKI_freebuf(tmp); + return ret; + } + ret = epb_set_message(&epb, TAG_SendDataRequest_BaseRequest, tmp, tmp_len); + GKI_freebuf(tmp); + if (ret < 0) return ret; + ret = epb_set_bytes(&epb, TAG_SendDataRequest_Data, request->data.data, request->data.len); + if (ret < 0) return ret; + if (request->has_type) { + ret = epb_set_enum(&epb, TAG_SendDataRequest_Type, request->type); + if (ret < 0) return ret; + } + + return epb_get_packed_size(&epb); +} + +SendDataResponse *epb_unpack_send_data_response(const uint8_t *buf, int buf_len) +{ + Epb epb; + epb_unpack_init(&epb, buf, buf_len); + + const uint8_t *tmp; + int tmp_len; + + if (!epb_has_tag(&epb, TAG_SendDataResponse_BaseResponse)) { + return NULL; + } + + SendDataResponse *response = (SendDataResponse *)GKI_getbuf(sizeof(SendDataResponse)); + memset(response, 0, sizeof(SendDataResponse)); + tmp = epb_get_message(&epb, TAG_SendDataResponse_BaseResponse, &tmp_len); + response->base_response = epb_unpack_base_response(tmp, tmp_len); + if (response->base_response == NULL) { + GKI_freebuf(response); + return NULL; + } + if (epb_has_tag(&epb, TAG_SendDataResponse_Data)) { + response->data.data = epb_get_bytes(&epb, TAG_SendDataResponse_Data, &response->data.len); + response->has_data = true; + } + + return response; +} + +void epb_unpack_send_data_response_free(SendDataResponse *response) +{ + epb_unpack_base_response_free(response->base_response); + GKI_freebuf(response); +} + +RecvDataPush *epb_unpack_recv_data_push(const uint8_t *buf, int buf_len) +{ + Epb epb; + epb_unpack_init(&epb, buf, buf_len); + + const uint8_t *tmp; + int tmp_len; + + if (!epb_has_tag(&epb, TAG_RecvDataPush_BasePush)) { + return NULL; + } + if (!epb_has_tag(&epb, TAG_RecvDataPush_Data)) { + return NULL; + } + + RecvDataPush *push = (RecvDataPush *)GKI_getbuf(sizeof(RecvDataPush)); + memset(push, 0, sizeof(RecvDataPush)); + tmp = epb_get_message(&epb, TAG_RecvDataPush_BasePush, &tmp_len); + push->base_push = epb_unpack_base_push(tmp, tmp_len); + if (push->base_push == NULL) { + GKI_freebuf(push); + return NULL; + } + push->data.data = epb_get_bytes(&epb, TAG_RecvDataPush_Data, &push->data.len); + if (epb_has_tag(&epb, TAG_RecvDataPush_Type)) { + push->type = (EmDeviceDataType)epb_get_enum(&epb, TAG_RecvDataPush_Type); + push->has_type = true; + } + + return push; +} + +void epb_unpack_recv_data_push_free(RecvDataPush *push) +{ + epb_unpack_base_push_free(push->base_push); + push->base_push = NULL; + GKI_freebuf(push); +} + +SwitchViewPush *epb_unpack_switch_view_push(const uint8_t *buf, int buf_len) +{ + Epb epb; + epb_unpack_init(&epb, buf, buf_len); + + const uint8_t *tmp; + int tmp_len; + + if (!epb_has_tag(&epb, TAG_SwitchViewPush_BasePush)) { + return NULL; + } + if (!epb_has_tag(&epb, TAG_SwitchViewPush_SwitchViewOp)) { + return NULL; + } + if (!epb_has_tag(&epb, TAG_SwitchViewPush_ViewId)) { + return NULL; + } + + SwitchViewPush *push = (SwitchViewPush *)GKI_getbuf(sizeof(SwitchViewPush)); + memset(push, 0, sizeof(SwitchViewPush)); + tmp = epb_get_message(&epb, TAG_SwitchViewPush_BasePush, &tmp_len); + push->base_push = epb_unpack_base_push(tmp, tmp_len); + if (push->base_push == NULL) { + GKI_freebuf(push); + return NULL; + } + push->switch_view_op = (EmSwitchViewOp)epb_get_enum(&epb, TAG_SwitchViewPush_SwitchViewOp); + push->view_id = (EmViewId)epb_get_enum(&epb, TAG_SwitchViewPush_ViewId); + + return push; +} + +void epb_unpack_switch_view_push_free(SwitchViewPush *push) +{ + epb_unpack_base_push_free(push->base_push); + GKI_freebuf(push); +} + +SwitchBackgroudPush *epb_unpack_switch_backgroud_push(const uint8_t *buf, int buf_len) +{ + Epb epb; + epb_unpack_init(&epb, buf, buf_len); + + const uint8_t *tmp; + int tmp_len; + + if (!epb_has_tag(&epb, TAG_SwitchBackgroudPush_BasePush)) { + return NULL; + } + if (!epb_has_tag(&epb, TAG_SwitchBackgroudPush_SwitchBackgroundOp)) { + return NULL; + } + + SwitchBackgroudPush *push = (SwitchBackgroudPush *)GKI_getbuf(sizeof(SwitchBackgroudPush)); + memset(push, 0, sizeof(SwitchBackgroudPush)); + tmp = epb_get_message(&epb, TAG_SwitchBackgroudPush_BasePush, &tmp_len); + push->base_push = epb_unpack_base_push(tmp, tmp_len); + if (push->base_push == NULL) { + GKI_freebuf(push); + return NULL; + } + push->switch_background_op = (EmSwitchBackgroundOp)epb_get_enum(&epb, TAG_SwitchBackgroudPush_SwitchBackgroundOp); + + return push; +} + +void epb_unpack_switch_backgroud_push_free(SwitchBackgroudPush *push) +{ + epb_unpack_base_push_free(push->base_push); + GKI_freebuf(push); +} + +#endif ///WX_AIRSYNC_CFG + diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/mpbledemo2.c b/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/mpbledemo2.c new file mode 100644 index 0000000000..68fd24d791 --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/mpbledemo2.c @@ -0,0 +1,586 @@ +/* +* WeChat mpbledemo2 +* +* author by anqiren 2014/12/02 V1.0bat +* +**/ + +#include "prf_defs.h" + +#if (WX_AIRSYNC_CFG) + +#include +#include +#include +#include +#include "app_airsync_prf.h" +#include "wechat_aes.h" +#include "epb_MmBp.h" +#include "wechar_crc.h" +#include "app_wechat_util.h" +#include "app_airsync_md5.h" +#include "mpbledemo2.h" +#include "gki.h" + + +mpbledemo2_info m_info = {CMD_NULL, {NULL, 0}}; + +#if defined EAM_md5AndNoEnrypt || EAM_md5AndAesEnrypt + uint8_t md5_type_and_id[16]; +#endif + +uint8_t challeange[CHALLENAGE_LENGTH] = {0x11,0x22,0x33,0x44}; //为了方便这里填了一组确定的数组，使用过程中请自行生成随机数 + +mpbledemo2_state mpbledemo2Sta = {false, false, false, false, false, false,0,0,0}; +const uint8_t key[16] = DEVICE_KEY; +uint8_t session_key[32] = {0}; +data_handler *m_mpbledemo2_handler = NULL; +uint8_t isLightOn; +/**** NOTIFICATION BITS ***********/ +uint8_t FirstNotificationBit ; +uint8_t SecondNotificationBit; + + +//static void mpbledemo2_handleCmdFromServer(BleDemo2CmdID cmd, uint8_t *ptrData, uint32_t lengthInByte); + +/**@brief Function for the light initialization. + * + * @details Initializes all lights used by this application. + */ + +int32_t mpbledemo2_get_md5(void) +{ + int32_t error_code = 0; +#if defined EAM_md5AndNoEnrypt || EAM_md5AndAesEnrypt + char device_type[] = DEVICE_TYPE; + char device_id[] = DEVICE_ID; + char argv[sizeof(DEVICE_TYPE) + sizeof(DEVICE_ID) - 1]; + memcpy(argv,device_type,sizeof(DEVICE_TYPE)); +/*when add the DEVICE_ID to DEVICE_TYPE, the offset shuld -1 to overwrite '\0' at the end of DEVICE_TYPE */ + memcpy(argv + sizeof(DEVICE_TYPE)-1,device_id,sizeof(DEVICE_ID)); + + error_code = wechat_md5(argv, md5_type_and_id); + +#endif + return error_code; +} + +void mpbledemo2_reset() +{ + mpbledemo2Sta.auth_send = false; + mpbledemo2Sta.auth_state = false; + mpbledemo2Sta.indication_state = false; + mpbledemo2Sta.init_send = false; + mpbledemo2Sta.init_state = false; + mpbledemo2Sta.send_data_seq = 0; + mpbledemo2Sta.push_data_seq = 0; + mpbledemo2Sta.seq = 0; +} + +int32_t mpbledemo2_init(void) +{ + mpbledemo2_reset(); + return (mpbledemo2_get_md5()); +} + + +void mpbledemo2_indication_state(bool isEnable) +{ + mpbledemo2Sta.indication_state = isEnable; + if (false == isEnable) + { + mpbledemo2Sta.auth_send = false; + } +} + +int32_t device_auth() +{ + if (m_mpbledemo2_handler == NULL) { + m_mpbledemo2_handler = get_handler_by_type(PRODUCT_TYPE_MPBLEDEMO2); + } + uint8_t *data = NULL; + uint32_t len = 0; + + ARGS_ITEM_SET(mpbledemo2_info, m_mpbledemo2_handler->m_data_produce_args, cmd, CMD_AUTH); + m_mpbledemo2_handler->m_data_produce_func(m_mpbledemo2_handler->m_data_produce_args, &data, &len); + if(data == NULL) + { + return errorCodeProduce; + } + + //sent data + ble_wechat_indicate_data(data, len); + return 0; + } + + +int32_t device_init() + { + uint8_t *data = NULL; + uint32_t len = 0; + ARGS_ITEM_SET(mpbledemo2_info, m_mpbledemo2_handler->m_data_produce_args, cmd, CMD_INIT); + m_mpbledemo2_handler->m_data_produce_func(m_mpbledemo2_handler->m_data_produce_args, &data, &len); + if(data == NULL) + { + return errorCodeProduce; + } + + //sent data + ble_wechat_indicate_data(data, len); + + return 0; +} + +void mpbledemo2_main_process() +{ + int error_code = 0; + if((mpbledemo2Sta.indication_state) && (!mpbledemo2Sta.auth_state) && (!mpbledemo2Sta.auth_send) ) + { + error_code = device_auth(); + if (0 == error_code) + { + mpbledemo2Sta.auth_send = true; + } + } + if((mpbledemo2Sta.auth_state) && (!mpbledemo2Sta.init_state) && (!mpbledemo2Sta.init_send)) + { + error_code = device_init(); + if (0 == error_code) + { + mpbledemo2Sta.init_send = true; + } + } +} + +void mpbledemo2_data_free_func(uint8_t *data, uint32_t len) +{ + if(data) + { + GKI_freebuf(data); + data = NULL; + } +} + +void mpbledemo2_data_produce_func(void *args, uint8_t **r_data, uint32_t *r_len) +{ + static uint16_t bleDemoHeadLen = sizeof(BlueDemoHead); + mpbledemo2_info *info = (mpbledemo2_info *)args; + BaseRequest basReq = {NULL}; + static uint8_t fix_head_len = sizeof(BpFixHead); + BpFixHead fix_head = {0xFE, 1, 0, htons(ECI_req_auth), 0}; + mpbledemo2Sta.seq++; + switch (info->cmd) + { + case CMD_AUTH: + { + #if defined EAM_md5AndAesEnrypt + uint8_t deviceid[] = DEVICE_ID; + static uint32_t seq = 0x00000001; // + uint32_t ran = 0x11223344; //为了方便起见这里放了一个固定值做为随机数，在使用时请自行生成随机数。 + ran = t_htonl(ran); + seq = t_htonl(seq); + uint8_t id_len = strlen(DEVICE_ID); + uint8_t* data = GKI_getbuf(id_len+8); + if(!data){return;} + memcpy(data,deviceid,id_len); + memcpy(data+id_len,(uint8_t*)&ran,4); + memcpy(data+id_len+4,(uint8_t*)&seq,4); + uint32_t crc = crc32(0, data, id_len+8); + crc = t_htonl(crc); + memset(data,0x00,id_len+8); + memcpy(data,(uint8_t*)&ran,4); + memcpy(data+4,(uint8_t*)&seq,4); + memcpy(data+8,(uint8_t*)&crc,4); + uint8_t CipherText[16]; + AES_Init(key); + AES_Encrypt_PKCS7 (data, CipherText, 12, key); + if(data){GKI_freebuf(data);data = NULL;} + AuthRequest authReq = {&basReq, true,{md5_type_and_id, MD5_TYPE_AND_ID_LENGTH}, + PROTO_VERSION, AUTH_PROTO, (EmAuthMethod)AUTH_METHOD, true , + {CipherText, CIPHER_TEXT_LENGTH}, false, {NULL, 0}, false, {NULL, 0}, false, + {NULL, 0},true,{DEVICE_ID,sizeof(DEVICE_ID)}}; + seq++; + #endif + + #if defined EAM_macNoEncrypt + static uint8_t mac_address[MAC_ADDRESS_LENGTH]; + //get_mac_addr(mac_address); + AuthRequest authReq = {&basReq, false,{NULL, 0}, PROTO_VERSION, AUTH_PROTO, (EmAuthMethod)AUTH_METHOD, false,{NULL, 0}, true, {mac_address, MAC_ADDRESS_LENGTH}, false, {NULL, 0}, false, {NULL, 0},true,{DEVICE_ID,sizeof(DEVICE_ID)}}; + #endif + + #if defined EAM_md5AndNoEnrypt + AuthRequest authReq = {&basReq, true,{md5_type_and_id, MD5_TYPE_AND_ID_LENGTH}, PROTO_VERSION, (EmAuthMethod)AUTH_PROTO, (EmAuthMethod)AUTH_METHOD, false ,{NULL, 0}, false, {NULL, 0}, false, {NULL, 0}, false, {NULL, 0},true,{DEVICE_ID,sizeof(DEVICE_ID)}}; + #endif + *r_len = epb_auth_request_pack_size(&authReq) + fix_head_len; + *r_data = (uint8_t *)GKI_getbuf(*r_len); + if(!(*r_data)){return;} + if(epb_pack_auth_request(&authReq, *r_data+fix_head_len, *r_len-fix_head_len)<0) + { + *r_data = NULL; + return; + } + fix_head.nCmdId = htons(ECI_req_auth); + fix_head.nLength = htons(*r_len); + fix_head.nSeq = htons(mpbledemo2Sta.seq); + memcpy(*r_data, &fix_head, fix_head_len); + return ; + } + case CMD_INIT: + { + //has challeange + InitRequest initReq = {&basReq,false, {NULL, 0},true, {challeange, CHALLENAGE_LENGTH}}; + *r_len = epb_init_request_pack_size(&initReq) + fix_head_len; + #if defined EAM_md5AndAesEnrypt + uint8_t length = *r_len; + uint8_t *p = GKI_getbuf(AES_get_length( *r_len-fix_head_len)); + if(!p){return;} + *r_len = AES_get_length( *r_len-fix_head_len)+fix_head_len; + #endif + //pack data + *r_data = (uint8_t *)GKI_getbuf(*r_len); + if(!(*r_data)){return;} + if(epb_pack_init_request(&initReq, *r_data+fix_head_len, *r_len-fix_head_len)<0) + {*r_data = NULL;return;} + //encrypt body + #if defined EAM_md5AndAesEnrypt + AES_Init(session_key); + AES_Encrypt_PKCS7(*r_data+fix_head_len,p,length-fix_head_len,session_key);//原始数据长度 + memcpy(*r_data + fix_head_len, p, *r_len-fix_head_len); + if(p)GKI_freebuf(p); + #endif + fix_head.nCmdId = htons(ECI_req_init); + fix_head.nLength = htons(*r_len); + fix_head.nSeq = htons(mpbledemo2Sta.seq); + memcpy(*r_data, &fix_head, fix_head_len); + return ; + } + case CMD_SENDDAT: + { + + BlueDemoHead *bleDemoHead = (BlueDemoHead*)GKI_getbuf(bleDemoHeadLen+info->send_msg.len); + if (!bleDemoHead) + { + return; + } + + // header of sent data + bleDemoHead->m_magicCode[0] = MPBLEDEMO2_MAGICCODE_H; + bleDemoHead->m_magicCode[1] = MPBLEDEMO2_MAGICCODE_L; + bleDemoHead->m_version = htons(MPBLEDEMO2_VERSION); + bleDemoHead->m_totalLength = htons(bleDemoHeadLen + info->send_msg.len); + bleDemoHead->m_cmdid = htons(sendTextReq); + bleDemoHead->m_seq = htons(mpbledemo2Sta.seq); + bleDemoHead->m_errorCode = 0; + + /*connect body and head.*/ + /*turn to uint8_t* befort offset.*/ + memcpy((uint8_t*)bleDemoHead + bleDemoHeadLen, info->send_msg.str, info->send_msg.len); + + SendDataRequest sendDatReq = + { + &basReq, + { (uint8_t*) bleDemoHead, (bleDemoHeadLen + info->send_msg.len)}, // define the data content wrapped in epb + false, // no type, the data is directly sent to vendor server + (EmDeviceDataType)NULL + }; + *r_len = epb_send_data_request_pack_size(&sendDatReq) + fix_head_len; + + #if defined EAM_md5AndAesEnrypt + uint16_t length = *r_len; + uint8_t *p = GKI_getbuf(AES_get_length( *r_len-fix_head_len)); + if(!p){return;} + *r_len = AES_get_length( *r_len-fix_head_len)+fix_head_len; + #endif + + *r_data = (uint8_t *)GKI_getbuf(*r_len); + if(!(*r_data)){return;} + if(epb_pack_send_data_request(&sendDatReq, *r_data+fix_head_len, *r_len-fix_head_len)<0) + { + *r_data = NULL; + #if defined EAM_md5AndAesEnrypt + if(p){GKI_freebuf(p); + p = NULL;} + #endif + return; + } + + #if defined EAM_md5AndAesEnrypt + //encrypt body + AES_Init(session_key); + AES_Encrypt_PKCS7(*r_data+fix_head_len,p,length-fix_head_len,session_key);//原始数据长度 + memcpy(*r_data + fix_head_len, p, *r_len-fix_head_len); + if(p){GKI_freebuf(p); p = NULL;} + #endif + + // header of epb + fix_head.nCmdId = htons(ECI_req_sendData); + fix_head.nLength = htons(*r_len); + fix_head.nSeq = htons(mpbledemo2Sta.seq); + + memcpy(*r_data, &fix_head, fix_head_len); + if(bleDemoHead){GKI_freebuf(bleDemoHead);bleDemoHead = NULL;} + + // increase sequence by 1 + mpbledemo2Sta.send_data_seq++; + return ; + } + } +} + +int mpbledemo2_data_consume_func(uint8_t *data, uint32_t len) +{ + BpFixHead *fix_head = (BpFixHead *)data; + uint8_t fix_head_len = sizeof(BpFixHead); + switch(ntohs(fix_head->nCmdId)) + { + case ECI_none: + { + + + } + break; + case ECI_resp_auth: + { + AuthResponse* authResp; + authResp = epb_unpack_auth_response(data+fix_head_len,len-fix_head_len); + if(authResp->base_response) + { + if(authResp->base_response->err_code == 0) + { + mpbledemo2Sta.auth_state = true; + } + else + { + int32_t returnedErrCode = authResp->base_response->err_code; + epb_unpack_auth_response_free(authResp); + return returnedErrCode; + } + } + #if defined EAM_md5AndAesEnrypt // get sessionkey + if(authResp->aes_session_key.len) + { + AES_Init(key); + AES_Decrypt(session_key,authResp->aes_session_key.data,authResp->aes_session_key.len,key); + } + #endif + epb_unpack_auth_response_free(authResp); + } + break; + case ECI_resp_sendData: + { + + #if defined EAM_md5AndAesEnrypt + uint32_t length = len- fix_head_len;//加密后数据长度 + uint8_t *p = GKI_getbuf (length); + if(!p){ if(data)GKI_freebuf(data);data = NULL; return 0;} + AES_Init(session_key); + //解密数据 + AES_Decrypt(p,data+fix_head_len,len- fix_head_len,session_key); + + uint8_t temp; + temp = p[length - 1];//算出填充长度 + len = len - temp;//取加密前数据总长度 + memcpy(data + fix_head_len, p ,length -temp);//把明文放回 + if(p){GKI_freebuf(p);p = NULL;} + #endif + SendDataResponse *sendDataResp; + sendDataResp = epb_unpack_send_data_response(data+fix_head_len,len-fix_head_len); + if (!sendDataResp) + { + return errorCodeUnpackSendDataResp; + } + + if(sendDataResp->base_response->err_code) + { + epb_unpack_send_data_response_free(sendDataResp); + return sendDataResp->base_response->err_code; + } + epb_unpack_send_data_response_free(sendDataResp); + } + break; + case ECI_resp_init: + { + FirstNotificationBit = 0; + SecondNotificationBit = 0; + + #if defined EAM_md5AndAesEnrypt + uint32_t length = len- fix_head_len; //加密后数据长度 + uint8_t *p = GKI_getbuf (length); + if(!p){if(data)GKI_freebuf(data);data = NULL; return 0;} + AES_Init(session_key); + //解密数据 + AES_Decrypt(p,data+fix_head_len,len- fix_head_len,session_key); + + uint8_t temp; + temp = p[length - 1]; //算出填充长度 + len = len - temp; //取加密前数据总长度 + memcpy(data + fix_head_len, p ,length -temp); //把明文放回 + if(p){GKI_freebuf(p);p = NULL;} + #endif + InitResponse *initResp = epb_unpack_init_response(data+fix_head_len, len-fix_head_len); + if(!initResp) + { + return errorCodeUnpackInitResp; + } + + if(initResp->base_response) + { + if(initResp->base_response->err_code == 0) + { + if(initResp->has_challeange_answer) + { + if(crc32(0,challeange,CHALLENAGE_LENGTH) == initResp->challeange_answer) + { + mpbledemo2Sta.init_state = true; + } + } + else mpbledemo2Sta.init_state = true; + mpbledemo2Sta.wechats_switch_state = true; + } + else + { + epb_unpack_init_response_free(initResp); + return initResp->base_response->err_code; + } + } + epb_unpack_init_response_free(initResp); + } + break; + case ECI_push_recvData: + { + #if defined EAM_md5AndAesEnrypt + uint32_t length = len- fix_head_len;//加密后数据长度 + uint8_t *p = GKI_getbuf (length); + if(!p){if(data)GKI_freebuf(data); data =NULL; return 0;} + AES_Init(session_key); + //解密数据 + AES_Decrypt(p,data+fix_head_len,len- fix_head_len,session_key); + + uint8_t temp; + temp = p[length - 1];//算出填充长度 + len = len - temp;//取加密前数据总长度 + memcpy(data + fix_head_len, p ,length -temp);//把明文放回 + if(p){GKI_freebuf(p);p = NULL;} + #endif + RecvDataPush *recvDatPush; + recvDatPush = epb_unpack_recv_data_push(data+fix_head_len, len-fix_head_len); + + if(!recvDatPush) + { + return errorCodeUnpackRecvDataPush; + } + + BlueDemoHead *bledemohead = (BlueDemoHead*)recvDatPush->data.data; + + + // ble demo command handle + + epb_unpack_recv_data_push_free(recvDatPush); + mpbledemo2Sta.push_data_seq++; + } + break; + case ECI_push_switchView: + { + + mpbledemo2Sta.wechats_switch_state = !mpbledemo2Sta.wechats_switch_state; + + #if defined EAM_md5AndAesEnrypt + uint32_t length = len- fix_head_len;//加密后数据长度 + uint8_t *p = GKI_getbuf (length); + if(!p){if(data)GKI_freebuf(data);data = NULL; return 0;} + AES_Init(session_key); + //解密数据 + AES_Decrypt(p,data+fix_head_len,len- fix_head_len,session_key); + + uint8_t temp; + temp = p[length - 1];//算出填充长度 + len = len - temp;//取加密前数据总长度 + memcpy(data + fix_head_len, p ,length -temp);//把明文放回 + if(p){GKI_freebuf(p);p = NULL;} + #endif + SwitchViewPush *swichViewPush; + swichViewPush = epb_unpack_switch_view_push(data+fix_head_len,len-fix_head_len); + if(!swichViewPush) + { + return errorCodeUnpackSwitchViewPush; + } + epb_unpack_switch_view_push_free(swichViewPush); + } + break; + case ECI_push_switchBackgroud: + { + + #if defined EAM_md5AndAesEnrypt + uint32_t length = len- fix_head_len;//加密后数据长度 + uint8_t *p = GKI_getbuf (length); + if(!p){if(data)GKI_freebuf(data);data = NULL; return 0;} + AES_Init(session_key); + //解密数据 + AES_Decrypt(p,data+fix_head_len,len- fix_head_len,session_key); + uint8_t temp; + temp = p[length - 1];//算出填充长度 + len = len - temp;//取加密前数据总长度 + memcpy(data + fix_head_len, p ,length -temp);//把明文放回 + if(data){GKI_freebuf(p);p = NULL;} + #endif + SwitchBackgroudPush *switchBackgroundPush = epb_unpack_switch_backgroud_push(data+fix_head_len,len-fix_head_len); + if(! switchBackgroundPush) + { + return errorCodeUnpackSwitchBackgroundPush; + } + epb_unpack_switch_backgroud_push_free(switchBackgroundPush); + } + break; + case ECI_err_decode: + break; + default: + { + + } + break; + } + return 0; +} +void mpbledemo2_data_error_func(int error_code) +{ + if(error_code) + { + + //NVIC_SystemReset(); + } +} + +data_handler mpbledemo2_data_handler = { + .m_product_type = PRODUCT_TYPE_MPBLEDEMO2, + .m_data_produce_func = &mpbledemo2_data_produce_func, + .m_data_free_func = &mpbledemo2_data_free_func, + .m_data_consume_func = &mpbledemo2_data_consume_func, + .m_data_error_func = &mpbledemo2_data_error_func, + .m_data_init_peripheral_func = NULL, + .m_data_init_func = &mpbledemo2_init, + .m_data_main_process_func = &mpbledemo2_main_process, + .m_data_button_handler_func = NULL, + .m_data_produce_args = &m_info, + .next = NULL +}; + +// send data to wechat server +int32_t mpbledemo2_sendData(uint8_t* ptrData, uint32_t lengthInByte) +{ + uint8_t *data = NULL; + uint32_t len = 0; + ARGS_ITEM_SET(mpbledemo2_info, m_mpbledemo2_handler->m_data_produce_args, cmd, CMD_SENDDAT); + ARGS_ITEM_SET(mpbledemo2_info, m_mpbledemo2_handler->m_data_produce_args, send_msg.len, lengthInByte); + ARGS_ITEM_SET(mpbledemo2_info, m_mpbledemo2_handler->m_data_produce_args, send_msg.str, (const char *)ptrData); + + m_mpbledemo2_handler->m_data_produce_func(m_mpbledemo2_handler->m_data_produce_args, &data, &len); + if(data == NULL) + { + return errorCodeProduce; + } + ble_wechat_indicate_data(data, len); + return 0; +} + +#endif ///WX_AIRSYNC_CFG + diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/wechar_crc.c b/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/wechar_crc.c new file mode 100644 index 0000000000..2239a75ca4 --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/wechar_crc.c @@ -0,0 +1,51 @@ +// crc32.c +// WeChat Embedded +// +// Created by harlliu on 14-03-03. +// Copyright 2014 Tencent. All rights reserved. +// + + +#include "prf_defs.h" +#if (WX_AIRSYNC_CFG) + +#include +#include "wechar_crc.h" + +#define DO1(buf) crc = crc_table(((int)crc ^ (*buf++)) & 0xff) ^ (crc >> 8); +#define DO2(buf) DO1(buf); DO1(buf); +#define DO4(buf) DO2(buf); DO2(buf); +#define DO8(buf) DO4(buf); DO4(buf); + + +static uint32_t crc_table(uint32_t index) +{ + uint32_t c = index; + uint32_t poly = 0xedb88320L; + int k; + + for (k = 0; k < 8; k++) + c = c & 1 ? poly ^ (c >> 1) : c >> 1; + + return c; +} + +uint32_t crc32(uint32_t crc, const uint8_t *buf, int len) +{ + if (buf == NULL) return 0L; + + crc = crc ^ 0xffffffffL; + while (len >= 8) + { + DO8(buf); + len -= 8; + } + if (len) do { + DO1(buf); + } while (--len); + return crc ^ 0xffffffffL; +} + + +#endif ///WX_AIRSYNC_CFG + diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/wechat_aes.c b/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/wechat_aes.c new file mode 100644 index 0000000000..9841f49117 --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/app_profiles/app_WX_airsync/wechat_aes.c @@ -0,0 +1,450 @@ +/////////////////////////////////////////////////////////////////////////////// +// 文 件 名：wechat_aes.c +// 描 述：AES加密算法 +// 创 建 人：Liangbofu +// 创建日期：2009-07-17 +/////////////////////////////////////////////////////////////////////////////// + +#include "prf_defs.h" +#if (WX_AIRSYNC_CFG) + +#include "wechat_aes.h" +#include +#include +#include +#include + +// 为了能针对C51进行优化，并且又使代码可用于ARM和PC等环境， +// 在非C51环境（没有定义__C51__）下需要把C51特定的关键字定义为空 +#ifndef __C51__ + #define code + #define data + #define idata + #define xdata + #define pdata + typedef unsigned char BOOL; +#else + typedef bit BOOL; +#endif + + +#define Nk (AES_KEY_LENGTH / 32) // 以“字”（4字节）为单位的密钥长度 +#define Nb 4 // 以“字”（4字节）为单位的加解密数据块大小，固定为4 + +// Nr：加密的轮数 +#if AES_KEY_LENGTH == 128 + #define Nr 10 +#elif AES_KEY_LENGTH == 192 + #define Nr 12 +#elif AES_KEY_LENGTH == 256 + #define Nr 14 +#else + #error AES_KEY_LENGTH must be 128, 192 or 256 BOOLs! +#endif + +// GF(28) 多项式 +#define BPOLY 0x1B // Lower 8 BOOLs of (x^8 + x^4 + x^3 + x + 1), ie. (x^4 + x^3 + x + 1). + +// AES子密钥表，当密钥长度为128位时，占用176字节空间 +static xdata unsigned char g_roundKeyTable[4*Nb*(Nr+1)]; + +// 加密用的SBox +static code const unsigned char SBox[256] = +{ + 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, + 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, + 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, + 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, + 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, + 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, + 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, + 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, + 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, + 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, + 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, + 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, + 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, + 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, + 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, + 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 +}; + +// 解密用的SBox +static code const unsigned char InvSBox[256] = +{ + 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, + 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, + 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, + 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, + 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, + 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, + 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, + 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, + 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, + 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, + 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, + 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, + 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, + 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, + 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, + 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d +}; + + +/////////////////////////////////////////////////////////////////////////////// +// 函数名： RotationWord +// 描述： 对一个“字”数据进行循环右移。 +// 输入参数： pWord -- 要右移的4字节数据。 +// 输出参数： pWord -- 右移后的4字节数据。 +// 返回值： 无。 +/////////////////////////////////////////////////////////////////////////////// +static void RotationWord(unsigned char *pWord) +{ + unsigned char temp = pWord[0]; + pWord[0] = pWord[1]; + pWord[1] = pWord[2]; + pWord[2] = pWord[3]; + pWord[3] = temp; +} + +/////////////////////////////////////////////////////////////////////////////// +// 函数名： XorBytes +// 描述： 批量异或两组数据。 +// 输入参数： pData1 -- 要异或的第一组数据。 +// pData1 -- 要异或的第二组数据。 +// nCount -- 要异或的数据长度。 +// 输出参数： pData1 -- 异或后的结果。 +// 返回值： 无。 +/////////////////////////////////////////////////////////////////////////////// +static void XorBytes(unsigned char *pData1, const unsigned char *pData2, unsigned char nCount) +{ + unsigned char i; + + for (i = 0; i < nCount; i++) + { + pData1[i] ^= pData2[i]; + } +} + +/////////////////////////////////////////////////////////////////////////////// +// 函数名： AddRoundKey +// 描述： 把 中间状态数据 加上（异或）子密钥，数据长度为16字节。 +// 输入参数： pState -- 状态数据。 +// pRoundKey -- 子密钥数据。 +// 输出参数： pState -- 加上子密钥后的状态数据。 +// 返回值： 无。 +/////////////////////////////////////////////////////////////////////////////// +// static void AddRoundKey(unsigned char *pState, const unsigned char *pRoundKey) +// { +// XorBytes(pState, pRoundKey, 4*Nb); +// } + +// AddRoundKey的宏形式，比函数形式可以节省4字节的data数据 +#define AddRoundKey(pState, pRoundKey) \ + XorBytes((pState), (pRoundKey), 4*Nb) + + +/////////////////////////////////////////////////////////////////////////////// +// 函数名： SubBytes +// 描述： 通过S盒子置换状态数据。 +// 输入参数： pState -- 状态数据。 +// nCount -- 状态数据长度。 +// bInvert -- 是否使用反向S盒子（解密时使用）。 +// 输出参数： pState -- 置换后的状态数据。 +// 返回值： 无。 +/////////////////////////////////////////////////////////////////////////////// +static void SubBytes(unsigned char *pState, unsigned char nCount, BOOL bInvert) +{ + unsigned char i; + const unsigned char code *pSBox = bInvert ? InvSBox : SBox; + + for (i = 0; i < nCount; i++) + { + pState[i] = pSBox[pState[i]]; + } +} + +/////////////////////////////////////////////////////////////////////////////// +// 函数名： ShiftRows +// 描述： 把状态数据移行。 +// 输入参数： pState -- 状态数据。 +// bInvert -- 是否反向移行（解密时使用）。 +// 输出参数： pState -- 移行后的状态数据。 +// 返回值： 无。 +/////////////////////////////////////////////////////////////////////////////// +static void ShiftRows(unsigned char *pState, BOOL bInvert) +{ + // 注意：状态数据以列形式存放！ + + unsigned char r; // row， 行 + unsigned char c; // column，列 + unsigned char temp; + unsigned char rowData[4]; + + for (r = 1; r < 4; r++) + { + // 备份一行数据 + for (c = 0; c < 4; c++) + { + rowData[c] = pState[r + 4*c]; + } + + temp = bInvert ? (4 - r) : r; + for (c = 0; c < 4; c++) + { + pState[r + 4*c] = rowData[(c + temp) % 4]; + } + } +} + +/////////////////////////////////////////////////////////////////////////////// +// 函数名： GfMultBy02 +// 描述： 在GF(28)域的 乘2 运算。 +// 输入参数： num -- 乘数。 +// 输出参数： 无。 +// 返回值： num乘以2的结果。 +/////////////////////////////////////////////////////////////////////////////// +static unsigned char GfMultBy02(unsigned char num) +{ + if ((num & 0x80) == 0) + { + num = num << 1; + } + else + { + num = (num << 1) ^ BPOLY; + } + + return num; +} + +/////////////////////////////////////////////////////////////////////////////// +// 函数名： MixColumns +// 描述： 混合状态各列数据。 +// 输入参数： pState -- 状态数据。 +// bInvert -- 是否反向混合（解密时使用）。 +// 输出参数： pState -- 混合列后的状态数据。 +// 返回值： 无。 +/////////////////////////////////////////////////////////////////////////////// +static void MixColumns(unsigned char *pState, BOOL bInvert) +{ + unsigned char i; + unsigned char temp; + unsigned char a0Pa2_M4; // 4(a0 + a2) + unsigned char a1Pa3_M4; // 4(a1 + a3) + unsigned char result[4]; + + for (i = 0; i < 4; i++, pState += 4) + { + // b0 = 2a0 + 3a1 + a2 + a3 + // = (a0 + a1 + a2 + a3) + 2(a0 + a1) + a0 + + temp = pState[0] ^ pState[1] ^ pState[2] ^ pState[3]; + result[0] = temp ^ pState[0] ^ GfMultBy02((unsigned char) (pState[0] ^ pState[1])); + result[1] = temp ^ pState[1] ^ GfMultBy02((unsigned char) (pState[1] ^ pState[2])); + result[2] = temp ^ pState[2] ^ GfMultBy02((unsigned char) (pState[2] ^ pState[3])); + result[3] = temp ^ pState[3] ^ GfMultBy02((unsigned char) (pState[3] ^ pState[0])); + + if (bInvert) + { + // b0' = 14a0 + 11a1 + 13a2 + 9a3 + // = (a0 + a1 + a2 + a3) + 2(a0 + a1) + a0 （这部分为b0） + // + 2(4(a0 + a2) + 4(a1 + a3)) + // + 4(a0 + a2) + + a0Pa2_M4 = GfMultBy02(GfMultBy02((unsigned char) (pState[0] ^ pState[2]))); + a1Pa3_M4 = GfMultBy02(GfMultBy02((unsigned char) (pState[1] ^ pState[3]))); + temp = GfMultBy02((unsigned char) (a0Pa2_M4 ^ a1Pa3_M4)); + result[0] ^= temp ^ a0Pa2_M4; + result[1] ^= temp ^ a1Pa3_M4; + result[2] ^= temp ^ a0Pa2_M4; + result[3] ^= temp ^ a1Pa3_M4; + } + + memcpy(pState, result, 4); + } +} + +/////////////////////////////////////////////////////////////////////////////// +// 函数名： BlockEncrypt +// 描述： 对单块数据加密。 +// 输入参数： pState -- 状态数据。 +// 输出参数： pState -- 加密后的状态数据。 +// 返回值： 无。 +/////////////////////////////////////////////////////////////////////////////// +static void BlockEncrypt(unsigned char *pState) +{ + unsigned char i; + + AddRoundKey(pState, g_roundKeyTable); + + for (i = 1; i <= Nr; i++) // i = [1, Nr] + { + SubBytes(pState, 4*Nb, 0); + ShiftRows(pState, 0); + + if (i != Nr) + { + MixColumns(pState, 0); + } + + AddRoundKey(pState, &g_roundKeyTable[4*Nb*i]); + } + +// 为了节省代码，合并到循化执行 +// SubBytes(pState, 4*Nb); +// ShiftRows(pState, 0); +// AddRoundKey(pState, &g_roundKeyTable[4*Nb*Nr]); +} + +/////////////////////////////////////////////////////////////////////////////// +// 函数名： BlockDecrypt +// 描述： 对单块数据解密。 +// 输入参数： pState -- 状态数据。 +// 输出参数： pState -- 解密后的状态数据。 +// 返回值： 无。 +/////////////////////////////////////////////////////////////////////////////// +static void BlockDecrypt(unsigned char *pState) +{ + unsigned char i; + + AddRoundKey(pState, &g_roundKeyTable[4*Nb*Nr]); + + for (i = Nr; i > 0; i--) // i = [Nr, 1] + { + ShiftRows(pState, 1); + SubBytes(pState, 4*Nb, 1); + AddRoundKey(pState, &g_roundKeyTable[4*Nb*(i-1)]); + + if (i != 1) + { + MixColumns(pState, 1); + } + } +} + + +/////////////////////////////////////////////////////////////////////////////// +// 函数名： AES_Init +// 描述： 初始化，在此执行扩展密钥操作。 +// 输入参数： pKey -- 原始密钥，其长度必须为 AES_KEY_LENGTH/8 字节。 +// 输出参数： 无。 +// 返回值： 无。 +/////////////////////////////////////////////////////////////////////////////// +void AES_Init(const void *pKey) +{ + // 扩展密钥 + unsigned char i; + unsigned char *pRoundKey; + unsigned char Rcon[4] = {0x01, 0x00, 0x00, 0x00}; + + memcpy(g_roundKeyTable, pKey, 4*Nk); + + pRoundKey = &g_roundKeyTable[4*Nk]; + + for (i = Nk; i < Nb*(Nr+1); pRoundKey += 4, i++) + { + memcpy(pRoundKey, pRoundKey - 4, 4); + + if (i % Nk == 0) + { + RotationWord(pRoundKey); + SubBytes(pRoundKey, 4, 0); + XorBytes(pRoundKey, Rcon, 4); + + Rcon[0] = GfMultBy02(Rcon[0]); + } + else if (Nk > 6 && i % Nk == Nb) + { + SubBytes(pRoundKey, 4, 0); + } + + XorBytes(pRoundKey, pRoundKey - 4*Nk, 4); + } +} + +unsigned int AES_get_length(unsigned int length) +{ + return ((length>>4) + 1)<<4; +} +////////////////////////////////////////////////////////////////////////// +// 函数名： AES_Encrypt +// 描述： 加密数据 +// 输入参数： pPlainText -- 明文，即需加密的数据，其长度为nDataLen字节。 +// nDataLen -- 数据长度，以字节为单位 +// pIV -- 初始化向量，如果使用ECB模式，可设为NULL。 +// 输出参数： pCipherText -- 密文，即由明文加密后的数据，可以与pPlainText相同。 +// 返回值： 无。 +////////////////////////////////////////////////////////////////////////// +unsigned int AES_Encrypt_PKCS7(const unsigned char *pPlainText, unsigned char *pCipherText, + unsigned int nDataLen, const unsigned char *pIV) +{ + unsigned int i; + //长度调整 + unsigned int length = nDataLen; + nDataLen = ((nDataLen>>4) + 1)<<4; + uint8_t p=(Nb<<2)-(length%(Nb<<2)); + if (pPlainText != pCipherText){memcpy(pCipherText,pPlainText,length);} + //填充 + unsigned char temp[16]; + memset(temp,p,16); + if(length 0 ; i--, pCipherText += 4*Nb) + { + #if AES_MODE == AES_MODE_CBC + XorBytes(pCipherText, pIV, 4*Nb); + #endif + BlockEncrypt(pCipherText); + pIV = pCipherText; + } + return(nDataLen); +} +////////////////////////////////////////////////////////////////////////// +// 函数名： AES_Decrypt +// 描述： 解密数据 +// 输入参数： pCipherText -- 密文，即需解密的数据，其长度为nDataLen字节。 +// nDataLen -- 数据长度，以字节为单位，必须为AES_KEY_LENGTH/8的整倍数。 +// pIV -- 初始化向量，如果使用ECB模式，可设为NULL。 +// 输出参数： pPlainText -- 明文，即由密文解密后的数据，可以与pCipherText相同。 +// 返回值： 无。 +////////////////////////////////////////////////////////////////////////// +void AES_Decrypt(unsigned char *pPlainText, const unsigned char *pCipherText, + unsigned int nDataLen, const unsigned char *pIV) +{ + unsigned int i; + + if (pPlainText != pCipherText) + { + memcpy(pPlainText, pCipherText, nDataLen); + } + + // 从最后一块数据开始解密，这样不用开辟空间来保存IV + pPlainText += nDataLen - 4*Nb; + for (i = nDataLen/(4*Nb); i > 0 ; i--, pPlainText -= 4*Nb) + { + BlockDecrypt(pPlainText); + + #if AES_MODE == AES_MODE_CBC + if (i == 1) + {// 最后一块数据 + XorBytes(pPlainText, pIV, 4*Nb); + } + else + { + XorBytes(pPlainText, pPlainText - 4*Nb, 4*Nb); + } + #endif + } +} + + +#endif ///WX_AIRSYNC_CFG + diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/app_project/SampleServerProject.c b/examples/06_bluedroid_demos/components/bluedroid_demos/app_project/SampleServerProject.c index 6b517ec4d2..d5c0264bee 100644 --- a/examples/06_bluedroid_demos/components/bluedroid_demos/app_project/SampleServerProject.c +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/app_project/SampleServerProject.c @@ -12,6 +12,8 @@ #include #include +#include "prf_defs.h" + #include "bta_api.h" #include "bta_gatt_api.h" #include "controller.h" @@ -23,10 +25,16 @@ #include "dis_api.h" #include "bt_app_common.h" -//#include "app_button.h" -//#include "button_pro.h" +//#include "prf_defs.h" + +#include "wx_airsync_prf.h" + +#include "button_pro.h" + #include "hid_le_prf.h" -#include "prf_defs.h" + +// + #include "hcimsgs.h" #include "bt_app_defs.h" @@ -45,12 +53,20 @@ static unsigned char BASE_UUID[16] = { }; UINT16 ijiazu_uuid = 0xffff; +UINT16 wechat_uuid = 0xfee7; tBTA_BLE_SERVICE ijiazu_service = { 0x01, //only one service in the ijiazu button profile false, &ijiazu_uuid }; /* 16 bits services */ +tBTA_BLE_SERVICE wechat_service = { + 0x01, //only one service in the ijiazu button profile + false, + &wechat_uuid + }; /* 16 bits services */ + + UINT8 beacon_manu[25] = {0x4c, 0x00,0x02, 0x15, 0xfd, 0xa5, 0x06, 0x93, 0xa4, 0xe2, 0x4f, 0xb1, 0xaf, 0xcf, 0xc6, 0xeb, 0x07, 0x64, 0x78, 0x25, @@ -58,8 +74,9 @@ UINT8 beacon_manu[25] = {0x4c, 0x00,0x02, 0x15, 0xfd, 0xa5, 0x06, 0x93, 0xa4, 0x //UINT8 ijiazu_manu[17] = {0xff,0x20,0x14,0x07,0x22,0x00,0x02,0x5B,0x00,0x33,0x49,0x31,0x30,0x4a,0x30,0x30,0x31}; UINT8 ijiazu_manu[17] = {0xff,0x20,0x14,0x07,0x22,0x00,0x02,0x5B,0x00,0x33,0x49,0x31,0x30,0x4a,0x30,0x30,0x31}; +UINT8 wechat_manu[] = {0x00,0x00,0x18,0xfe,0x34,0x6a,0x86,0x2e}; tBTA_BLE_MANU p_ijiazu_manu = {sizeof(ijiazu_manu),ijiazu_manu}; /* manufacturer data */ - +tBTA_BLE_MANU p_wechat_manu = {sizeof(wechat_manu),wechat_manu}; BD_ADDR rand_ijiazu_addr = {0x00,0x02,0x5B,0x00,0x32,0x55}; @@ -104,6 +121,50 @@ tESP_BLE_ADV_DATA ijiazu_adv_data[ADV_SCAN_IDX_MAX] = } }; +tESP_BLE_ADV_DATA wechat_adv_data[ADV_SCAN_IDX_MAX] = +{ + [BLE_ADV_DATA_IDX] = { + .adv_name = NULL, + { + {0,0}, + NULL, //no manufature data to be setting in the ijiazu adervetisiing datas + &wechat_service, + NULL, //the 128 bits service uuid set to null(not used) + NULL, //the 32 bits Service UUID set to null(not used) + NULL, //16 bits services Solicitation UUIDs set to null(not used) + NULL, //List of 32 bit Service Solicitation UUIDs set to null(not used) + NULL, //List of 128 bit Service Solicitation UUIDs set to null(not used) + NULL, //proprietary data set to null(not used) + NULL, //service data set not null(no service data to be sent) + 0x0200, //device type : generic display + BTA_DM_GENERAL_DISC, // General discoverable. + 0xFE //the tx power value,defult value is 0 + }, + + }, + [BLE_SCAN_RSP_DATA_IDX] = { + .adv_name = "wechat_demo", + { + {0,0}, + &p_wechat_manu, + NULL, + NULL, //the 128 bits service uuid set to null(not used) + NULL, //the 32 bits Service UUID set to null(not used) + NULL, //16 bits services Solicitation UUIDs set to null(not used) + NULL, //List of 32 bit Service Solicitation UUIDs set to null(not used) + NULL, //List of 128 bit Service Solicitation UUIDs set to null(not used) + NULL, //proprietary data set to null(not used) + NULL, //service data set not null(no service data to be sent) + 0x0000, //device type : generic display + 0x00, // General discoverable. + 0x00}, //the tx power value,defult value is 0 + + } +}; + +#if (BUT_PROFILE_CFG) +static void SimpleDataCallBack(UINT8 app_id, UINT8 event, UINT8 len, UINT8 *p_data); +#endif typedef struct { uint8_t uu[16]; @@ -177,13 +238,22 @@ static void bta_gatts_set_adv_data_cback(tBTA_STATUS call_status) DIS_SrInit(dis_attr_mask); */ /*instantiate a battery service*/ - bas_register(); + //bas_register(); /*instantiate the driver for button profile*/ //app_button_init(); +#if (BUT_PROFILE_CFG) /*instantiate a button service*/ - //button_init(); + button_init(SimpleDataCallBack); +#endif ///BUT_PROFILE_CFG + +#if (HIDD_LE_PROFILE_CFG) /*instantiate a hid device service*/ hidd_le_init(); +#endif ///HIDD_LE_PROFILE_CFG + +#if (WX_AIRSYNC_CFG) + AirSync_Init(NULL); +#endif ///WX_AIRSYNC_CFG /*start advetising*/ // BTA_GATTS_Listen(server_if, true, NULL); } @@ -202,10 +272,10 @@ void bta_gatts_callback(tBTA_GATTS_EVT event, tBTA_GATTS* p_data) LOG_ERROR("set advertising parameters\n"); //set the advertising data to the btm layer - ESP_AppBleConfigadvData(&ijiazu_adv_data[BLE_ADV_DATA_IDX], + ESP_AppBleConfigadvData(&wechat_adv_data[BLE_ADV_DATA_IDX], bta_gatts_set_adv_data_cback); //set the adversting data to the btm layer - ESP_AppBleSetScanRsp(&ijiazu_adv_data[BLE_SCAN_RSP_DATA_IDX],NULL); + ESP_AppBleSetScanRsp(&wechat_adv_data[BLE_SCAN_RSP_DATA_IDX],NULL); } break; @@ -227,6 +297,25 @@ void bta_gatts_callback(tBTA_GATTS_EVT event, tBTA_GATTS* p_data) } +#if (BUT_PROFILE_CFG) +static void SimpleDataCallBack(UINT8 app_id, UINT8 event, UINT8 len, UINT8 *p_data) +{ + LOG_ERROR("the event value is:%x\n",event); + switch(event) + { + case RECEIVE_NET_PASSWD_EVT: + LOG_ERROR("Received the network passwork"); + break; + case RECEIVE_NET_SSD_EVT: + LOG_ERROR("Received the network SSID"); + break; + default: + break; + } +} +#endif ///BUT_PROFILE_CFG + + static void ble_server_appRegister(void) { bt_uuid_t uuid; diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/component.mk b/examples/06_bluedroid_demos/components/bluedroid_demos/component.mk index 971743c526..d8ee3a878b 100644 --- a/examples/06_bluedroid_demos/components/bluedroid_demos/component.mk +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/component.mk @@ -12,9 +12,10 @@ COMPONENT_SRCDIRS := \ app_client_profiles/battery_c \ app_client_profiles \ app_profiles/app_sample_button \ + app_profiles/app_WX_airsync \ app_profiles \ - app_project - + app_project + CFLAGS += -Wno-error=unused-label -Wno-error=return-type -Wno-error=missing-braces -Wno-error=pointer-sign -Wno-error=parentheses -I./include diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/include/app_airsync_md5.h b/examples/06_bluedroid_demos/components/bluedroid_demos/include/app_airsync_md5.h new file mode 100644 index 0000000000..6fe956d615 --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/include/app_airsync_md5.h @@ -0,0 +1,52 @@ +/** + **************************************************************************************** + * + * @file app_airsync_md5.h + * + * @brief Application airsync md5 generation head Entry Point + * + * Copyright (C) ESPRESSIF 2016 + * Created by Yulong at 2016/10/9 + * + **************************************************************************************** + */ + +#ifndef __APP_AIRSYNC_MD5__ +#define __APP_AIRSYNC_MD5__ + +#include "prf_defs.h" +#if (WX_AIRSYNC_CFG) + + +#include +#include +#include +#include + +#define SINGLE_ONE_BIT 0x80 +#define BLOCK_SIZE 512 +#define MOD_SIZE 448 +#define APP_SIZE 64 +#define BITS 8 + +// MD5 Chaining Variable +#define A 0x67452301UL +#define B 0xEFCDAB89UL +#define C 0x98BADCFEUL +#define D 0x10325476UL + +typedef struct +{ + char *str; + uint32_t len; +}MD5String; + + +int32_t wechat_md5 ( char *argv, uint8_t *md5_32); + + +#endif ///WX_AIRSYNC_CFG + +#endif /// __APP_AIRSYNC_MD5__ + + diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/include/app_airsync_prf.h b/examples/06_bluedroid_demos/components/bluedroid_demos/include/app_airsync_prf.h new file mode 100644 index 0000000000..5e5699d56f --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/include/app_airsync_prf.h @@ -0,0 +1,47 @@ +/** + **************************************************************************************** + * + * @file app_airsync_prf.h + * + * @brief Application Security Entry Point + * + * Copyright (C) ESPRESSIF 2016 + * Created by Yulong at 2016/9/30 + * + **************************************************************************************** + */ +#ifndef _APP_AIRSYNC_PRF_H__ +#define _APP_AIRSYNC_PRF_H__ + +#include "prf_defs.h" +#if (WX_AIRSYNC_CFG) + + +#include "app_wechat_util.h" +#include +#include + +#define MAGIC_NUMBER 0xFE + +/** + **************************************************************************************** + * @brief Create Wechat Database + * + **************************************************************************************** + */ +void app_wechat_create_db(void); + +void app_wechat_SetDatahandler(data_handler* pHandler); +int ble_wechat_indicate_data(uint8_t *data, int len); +int ble_wechat_indicate_data_chunk(void); +void ble_wechat_process_received_data(uint8_t* pData, uint32_t length); +data_handler* app_wechat_datahandler(void); +bool ble_wechat_is_last_data_sent_out(void); + + +#endif ///WX_AIRSYNC_CFG + +#endif ///_APP_AIRSYNC_PRF_H__ + + + diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/include/app_wechat_util.h b/examples/06_bluedroid_demos/components/bluedroid_demos/include/app_wechat_util.h new file mode 100644 index 0000000000..5de417deba --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/include/app_wechat_util.h @@ -0,0 +1,85 @@ +#ifndef __APP_WECHAT_UTIL_H__ +#define __APP_WECHAT_UTIL_H__ + +#include "prf_defs.h" +if (WX_AIRSYNC_CFG) +#include +#include + +#define PRODUCT_TYPE_UNKNOWN 0 +#define PRODUCT_TYPE_MPBLEDEMO2 1 + +typedef void (*data_produce_func)(void *args, uint8_t **r_data, uint32_t *r_len); +typedef void (*data_free_func)(uint8_t *data, uint32_t len); +typedef int (*data_consume_func)(uint8_t *data, uint32_t len); +typedef void (*data_error_func)(int error_code); + +typedef int32_t (*data_button_handler_func)(uint8_t pin_no); +typedef void (*data_main_process_func)(void); +typedef int32_t (*data_init_func)(void); +typedef int32_t (*data_init_peripheral_func)(void); + +typedef struct data_handler{ + int m_product_type; + data_produce_func m_data_produce_func; + data_free_func m_data_free_func; + data_consume_func m_data_consume_func; + data_error_func m_data_error_func; + data_init_peripheral_func m_data_init_peripheral_func; + data_init_func m_data_init_func; + data_main_process_func m_data_main_process_func; + data_button_handler_func m_data_button_handler_func; + void *m_data_produce_args; + struct data_handler *next; +} data_handler; + +extern data_handler first_handler; + +#define REGISTER(NAME) \ + do { \ + data_handler *tmp = &NAME##_data_handler; \ + tmp->next = first_handler.next; \ + first_handler.next = tmp; \ + } while(0) + +#define ARGS_ITEM_SET(ARGS_TYPE, ARGS_POINTER, ITEM_NAME, ITEM_VALUE) \ + do { \ + ARGS_TYPE *tmp = (ARGS_TYPE *)(ARGS_POINTER); \ + tmp->ITEM_NAME = (ITEM_VALUE); \ + } while(0) + + +typedef struct +{ + unsigned char bMagicNumber; + unsigned char bVer; + unsigned short nLength; + unsigned short nCmdId; + unsigned short nSeq; +} BpFixHead; + +/* + * TYPE DEFINITIONS + **************************************************************************************** + */ + +typedef struct +{ + uint8_t *data; + uint16_t len; + uint16_t offset; +} data_info; + +data_handler* get_handler_by_type(int type); +unsigned short htons(unsigned short val); +unsigned short ntohs(unsigned short val); +unsigned long t_htonl(unsigned long h); +unsigned long t_ntohl(unsigned long n); + +void wechat_error_chack(data_handler *p_data_handler, int error_code); +void data_handler_init(data_handler** p_data_handler, uint8_t product_type); + +#endif ///WX_AIRSYNC_CFG + +#endif ///__APP_WECHAT_UTIL_H__ + diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/include/bt_app_api.h b/examples/06_bluedroid_demos/components/bluedroid_demos/include/bt_app_api.h new file mode 100644 index 0000000000..41c573da1c --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/include/bt_app_api.h @@ -0,0 +1,18 @@ +/** + **************************************************************************************** + * + * @file bt_app_api.h + * + * @brief Application entry point + * + * Copyright (C) Espressif 2016 + * Created by Yulong at 2016/10/13 + * + * + **************************************************************************************** + */ + + + + + diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/include/bt_app_sec.h b/examples/06_bluedroid_demos/components/bluedroid_demos/include/bt_app_sec.h new file mode 100644 index 0000000000..6c003ae0c5 --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/include/bt_app_sec.h @@ -0,0 +1,78 @@ +/** + **************************************************************************************** + * + * @file bt_app_sec.h + * + * @brief Application entry point + * + * Copyright (C) Espressif 2016 + * Created by Yulong at 2016/10/13 + * + * + **************************************************************************************** + */ + +#include "bt_types.h" + +#define APP_SEC_IRK_FLAG (0) +#define RAND_NB_LEN 0x08 +#define SEC_KEY_LEN 0x10 + + /* + * STRUCTURES DEFINITIONS + **************************************************************************************** + */ + + + /// Generic Security key structure +typedef struct + { + /// Key value MSB -> LSB + UINT8 key[SEC_KEY_LEN]; + }smp_sec_key; + + ///Random number structure +typedef struct +{ + ///8-byte array for random number + UINT8 nb[RAND_NB_LEN]; +}rand_nb; + + typedef struct + { + // LTK + smp_sec_key ltk; + // Random Number + rand_nb rand_nb; + // EDIV + UINT16 ediv; + // LTK key size + UINT8 key_size; + + // Last paired peer address type + UINT8 peer_addr_type; + // Last paired peer address + BD_ADDR peer_addr; + + // authentication level + UINT8 auth; + + }tAPP_SEC_ENV; + + extern tAPP_SEC_ENV app_sec_env; + + /* + * GLOBAL FUNCTIONS DECLARATIONS + **************************************************************************************** + */ + +void app_ble_sec_init(void); + +void app_ble_sec_pairing_cmp_evt_send(UINT8); + +UINT32 app_ble_sec_gen_tk(void); + +void app_ble_sec_gen_ltk(UINT8 key_size); + +void app_ble_security_start(void); + diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/include/epb.h b/examples/06_bluedroid_demos/components/bluedroid_demos/include/epb.h new file mode 100644 index 0000000000..b9d031d39f --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/include/epb.h @@ -0,0 +1,117 @@ +// epb.h +// MicroMessenger +// +// Created by harlliu@tencent.com on 14-02-15. +// Copyright 2014 Tencent. All rights reserved. +// + +// Version : 1.0.2 + +#ifndef __EPB_H__ +#define __EPB_H__ + +#include "prf_defs.h" +#if (WX_AIRSYNC_CFG) + + +#include +#include + +typedef struct +{ + uint8_t *data; + int len; +} Bytes; + +typedef struct +{ + const uint8_t *data; + int len; +} CBytes; + +typedef struct +{ + char *str; + int len; +} String; + +typedef struct +{ + const char *str; + int len; +} CString; + +typedef uint8_t Message; + +typedef struct +{ + const uint8_t *unpack_buf; + uint8_t *pack_buf; + int buf_len; + int buf_offset; +} Epb; + +/* + * embeded protobuf unpack functions + */ + +void epb_unpack_init(Epb *e, const uint8_t *buf, int len); +bool epb_has_tag(Epb *e, uint16_t tag); + +//Varint +int32_t epb_get_int32(Epb *e, uint16_t tag); +uint32_t epb_get_uint32(Epb *e, uint16_t tag); +int32_t epb_get_sint32(Epb *e, uint16_t tag); +bool epb_get_bool(Epb *e, uint16_t tag); +int epb_get_enum(Epb *e, uint16_t tag); + +//Length Delimited +const char *epb_get_string(Epb *e, uint16_t tag, int *len); +const uint8_t *epb_get_bytes(Epb *e, uint16_t tag, int *len); +const Message *epb_get_message(Epb *e, uint16_t tag, int *len); + +//Length Delimited Packed Repeadted Field +//TODO + +//Fixed32 +uint32_t epb_get_fixed32(Epb *e, uint16_t tag); +int32_t epb_get_sfixed32(Epb *e, uint16_t tag); +float epb_get_float(Epb *e, uint16_t tag); + +/* + * embeded protobuf pack functions + */ + +void epb_pack_init(Epb *e, uint8_t *buf, int len); +int epb_get_packed_size(Epb *e); + +//Varint +int epb_set_int32(Epb *e, uint16_t tag, int32_t value); +int epb_set_uint32(Epb *e, uint16_t tag, uint32_t value); +int epb_set_sint32(Epb *e, uint16_t tag, int32_t value); +int epb_set_bool(Epb *e, uint16_t tag, bool value); +int epb_set_enum(Epb *e, uint16_t tag, int value); + +//Length Delimited +int epb_set_string(Epb *e, uint16_t tag, const char *data, int len); +int epb_set_bytes(Epb *e, uint16_t tag, const uint8_t *data, int len); +int epb_set_message(Epb *e, uint16_t tag, const Message *data, int len); + +//Length Delimited Packed Repeadted Field +//TODO + +//Fixed32 +int epb_set_fixed32(Epb *e, uint16_t tag, uint32_t value); +int epb_set_sfixed32(Epb *e, uint16_t tag, int32_t value); +int epb_set_float(Epb *e, uint16_t tag, float value); + +//Pack size +int epb_varint32_pack_size(uint16_t tag, uint32_t value, bool is_signed); +int epb_fixed32_pack_size(uint16_t tag); +int epb_length_delimited_pack_size(uint16_t tag, int len); + + +#endif ///WX_AIRSYNC_CFG + +#endif ///__EPB_H__ + diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/include/epb_mmbp.h b/examples/06_bluedroid_demos/components/bluedroid_demos/include/epb_mmbp.h new file mode 100644 index 0000000000..293b951836 --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/include/epb_mmbp.h @@ -0,0 +1,248 @@ +// epb_MmBp.h +// WeChat Embedded Proto Buffer +// +// Generated by harlliu@tencent.com on 14-11-26. +// Copyright 2014 Tencent. All rights reserved. +// + +// Version : 1.0.4 + +#ifndef __EPB_MMBP_H__ +#define __EPB_MMBP_H__ + +#include "prf_defs.h" +#if (WX_AIRSYNC_CFG) + + +#include "epb.h" + +typedef enum +{ + ECI_none = 0, + ECI_req_auth = 10001, + ECI_req_sendData = 10002, + ECI_req_init = 10003, + ECI_resp_auth = 20001, + ECI_resp_sendData = 20002, + ECI_resp_init = 20003, + ECI_push_recvData = 30001, + ECI_push_switchView = 30002, + ECI_push_switchBackgroud = 30003, + ECI_err_decode = 29999 +} EmCmdId; + +typedef enum +{ + EEC_system = -1, + EEC_needAuth = -2, + EEC_sessionTimeout = -3, + EEC_decode = -4, + EEC_deviceIsBlock = -5, + EEC_serviceUnAvalibleInBackground = -6, + EEC_deviceProtoVersionNeedUpdate = -7, + EEC_phoneProtoVersionNeedUpdate = -8, + EEC_maxReqInQueue = -9, + EEC_userExitWxAccount = -10 +} EmErrorCode; + +typedef enum +{ + EAM_md5 = 1, + EAM_macNoEncrypt = 2 +} EmAuthMethod; + +typedef enum +{ + EIRFF_userNickName = 0x1, + EIRFF_platformType = 0x2, + EIRFF_model = 0x4, + EIRFF_os = 0x8, + EIRFF_time = 0x10, + EIRFF_timeZone = 0x20, + EIRFF_timeString = 0x40 +} EmInitRespFieldFilter; + +typedef enum +{ + EIS_deviceChat = 1, + EIS_autoSync = 2 +} EmInitScence; + +typedef enum +{ + EPT_ios = 1, + EPT_andriod = 2, + EPT_wp = 3, + EPT_s60v3 = 4, + EPT_s60v5 = 5, + EPT_s40 = 6, + EPT_bb = 7 +} EmPlatformType; + +typedef enum +{ + EDDT_manufatureSvr = 0, + EDDT_wxWristBand = 1, + EDDT_wxDeviceHtmlChatView = 10001 +} EmDeviceDataType; + +typedef enum +{ + ESVO_enter = 1, + ESVO_exit = 2 +} EmSwitchViewOp; + +typedef enum +{ + EVI_deviceChatView = 1, + EVI_deviceChatHtmlView = 2 +} EmViewId; + +typedef enum +{ + ESBO_enterBackground = 1, + ESBO_enterForground = 2, + ESBO_sleep = 3 +} EmSwitchBackgroundOp; + +typedef struct +{ + void *none; +} BaseRequest; + +typedef struct +{ + int32_t err_code; + bool has_err_msg; + CString err_msg; +} BaseResponse; + +typedef struct +{ + void *none; +} BasePush; + +typedef struct +{ + BaseRequest *base_request; + bool has_md5_device_type_and_device_id; + Bytes md5_device_type_and_device_id; + int32_t proto_version; + int32_t auth_proto; + EmAuthMethod auth_method; + bool has_aes_sign; + Bytes aes_sign; + bool has_mac_address; + Bytes mac_address; + bool has_time_zone; + String time_zone; + bool has_language; + String language; + bool has_device_name; + String device_name; +} AuthRequest; + +typedef struct +{ + BaseResponse *base_response; + CBytes aes_session_key; +} AuthResponse; + +typedef struct +{ + BaseRequest *base_request; + bool has_resp_field_filter; + Bytes resp_field_filter; + bool has_challenge; + Bytes challenge; +} InitRequest; + +typedef struct +{ + BaseResponse *base_response; + uint32_t user_id_high; + uint32_t user_id_low; + bool has_challeange_answer; + uint32_t challeange_answer; + bool has_init_scence; + EmInitScence init_scence; + bool has_auto_sync_max_duration_second; + uint32_t auto_sync_max_duration_second; + bool has_user_nick_name; + CString user_nick_name; + bool has_platform_type; + EmPlatformType platform_type; + bool has_model; + CString model; + bool has_os; + CString os; + bool has_time; + int32_t time; + bool has_time_zone; + int32_t time_zone; + bool has_time_string; + CString time_string; +} InitResponse; + +typedef struct +{ + BaseRequest *base_request; + Bytes data; + bool has_type; + EmDeviceDataType type; +} SendDataRequest; + +typedef struct +{ + BaseResponse *base_response; + bool has_data; + CBytes data; +} SendDataResponse; + +typedef struct +{ + BasePush *base_push; + CBytes data; + bool has_type; + EmDeviceDataType type; +} RecvDataPush; + +typedef struct +{ + BasePush *base_push; + EmSwitchViewOp switch_view_op; + EmViewId view_id; +} SwitchViewPush; + +typedef struct +{ + BasePush *base_push; + EmSwitchBackgroundOp switch_background_op; +} SwitchBackgroudPush; + +BaseResponse *epb_unpack_base_response(const uint8_t *buf, int buf_len); +void epb_unpack_base_response_free(BaseResponse *response); +int epb_auth_request_pack_size(AuthRequest *request); +int epb_pack_auth_request(AuthRequest *request, uint8_t *buf, int buf_len); +AuthResponse *epb_unpack_auth_response(const uint8_t *buf, int buf_len); +void epb_unpack_auth_response_free(AuthResponse *response); +int epb_init_request_pack_size(InitRequest *request); +int epb_pack_init_request(InitRequest *request, uint8_t *buf, int buf_len); +InitResponse *epb_unpack_init_response(const uint8_t *buf, int buf_len); +void epb_unpack_init_response_free(InitResponse *response); +int epb_send_data_request_pack_size(SendDataRequest *request); +int epb_pack_send_data_request(SendDataRequest *request, uint8_t *buf, int buf_len); +SendDataResponse *epb_unpack_send_data_response(const uint8_t *buf, int buf_len); +void epb_unpack_send_data_response_free(SendDataResponse *response); +RecvDataPush *epb_unpack_recv_data_push(const uint8_t *buf, int buf_len); +void epb_unpack_recv_data_push_free(RecvDataPush *push); +SwitchViewPush *epb_unpack_switch_view_push(const uint8_t *buf, int buf_len); +void epb_unpack_switch_view_push_free(SwitchViewPush *push); +SwitchBackgroudPush *epb_unpack_switch_backgroud_push(const uint8_t *buf, int buf_len); +void epb_unpack_switch_backgroud_push_free(SwitchBackgroudPush *push); + + +#endif ///WX_AIRSYNC_CFG + +#endif ///__EPB_MMBP_H__ + diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/include/mpbledemo2.h b/examples/06_bluedroid_demos/components/bluedroid_demos/include/mpbledemo2.h new file mode 100644 index 0000000000..0a48058d40 --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/include/mpbledemo2.h @@ -0,0 +1,140 @@ + +#ifndef __MPBLEDEMO2_H__ +#define __MPBLEDEMO2_H__ + +#include "prf_defs.h" + +#if (WX_AIRSYNC_CFG) + + +#include +#include +#include +#include +#include +#include "epb_MmBp.h" +#include "app_airsync_prf.h" + +#define CMD_NULL 0 +#define CMD_AUTH 1 +#define CMD_INIT 2 +#define CMD_SENDDAT 3 + +#define DEVICE_TYPE "gh_b57f1be552dd" +#define DEVICE_ID "gh_b57f1be552dd_8ecc3b117f8c05112638289b0952c797" //"wechat_dialog" +#define PROTO_VERSION 0x010004 +#define AUTH_PROTO 1 + +#define MAC_ADDRESS_LENGTH 6 + +//#define EAM_md5AndNoEnrypt 1 +#define EAM_md5AndAesEnrypt 1 +//#define EAM_macNoEncrypt 2 + +#define DEVICE_KEY {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f}; + +#ifdef EAM_macNoEncrypt + #define AUTH_METHOD EAM_macNoEncrypt + #define MD5_TYPE_AND_ID_LENGTH 0 + #define CIPHER_TEXT_LENGTH 0 +#endif + +#ifdef EAM_md5AndAesEnrypt + #define AUTH_METHOD EAM_md5AndAesEnrypt + #define MD5_TYPE_AND_ID_LENGTH 16 + #define CIPHER_TEXT_LENGTH 16 +#endif +#ifdef EAM_md5AndNoEnrypt + #define AUTH_METHOD EAM_md5AndNoEnrypt + #define MD5_TYPE_AND_ID_LENGTH 16 + #define CIPHER_TEXT_LENGTH 0 +#endif + +#define CHALLENAGE_LENGTH 4 + +#define MPBLEDEMO2_MAGICCODE_H 0xfe +#define MPBLEDEMO2_MAGICCODE_L 0xcf +#define MPBLEDEMO2_VERSION 0x01 +#define SEND_HELLO_WECHAT "Hello, WeChat!" + +/* Hardware Resources define */ +#define MPBLEDEMO2_LIGHT 19 +#define MPBLEDEMO2_BUTTON_1 17 + +typedef enum +{ + errorCodeUnpackAuthResp = 0x9990, + errorCodeUnpackInitResp = 0x9991, + errorCodeUnpackSendDataResp = 0x9992, + errorCodeUnpackCtlCmdResp = 0x9993, + errorCodeUnpackRecvDataPush = 0x9994, + errorCodeUnpackSwitchViewPush = 0x9995, + errorCodeUnpackSwitchBackgroundPush = 0x9996, + errorCodeUnpackErrorDecode = 0x9997, +} mpbledemo2UnpackErrorCode; + +typedef enum +{ + errorCodeProduce = 0x9980, +} mpbledemo2PackErrorCode; + + +// command ID between device and vendor server +typedef enum +{ + sendTextReq = 0x01, + + sendTextResp = 0x1001, + openLightPush = 0x2001, + closeLightPush = 0x2002, +} BleDemo2CmdID; + +typedef struct +{ + uint8_t m_magicCode[2]; + uint16_t m_version; + uint16_t m_totalLength; + uint16_t m_cmdid; + uint16_t m_seq; + uint16_t m_errorCode; +} BlueDemoHead; + +typedef struct +{ + int cmd; + CString send_msg; +} mpbledemo2_info; + + typedef struct +{ + bool wechats_switch_state; //公众账号切换到前台的状态 + bool indication_state; + bool auth_state; + bool init_state; + bool auth_send; + bool init_send; + unsigned short send_data_seq; + unsigned short push_data_seq; + unsigned short seq; +}mpbledemo2_state; + +typedef void (*mpbledemo2_handler_func)(uint8_t *ptrData, uint32_t lengthInByte); + +typedef struct +{ + BleDemo2CmdID commandCode; + mpbledemo2_handler_func handler; +} MPBLEDEMO2_RECEIVED_CMD_HANDLER_T; + +extern data_handler mpbledemo2_data_handler; +extern data_handler *m_mpbledemo2_handler; + +extern void mpbledemo2_reset(void); +extern void mpbledemo2_indication_state(bool isEnable); +extern int32_t mpbledemo2_sendData(uint8_t* ptrData, uint32_t lengthInByte); + + +#endif ///WX_AIRSYNC_CFG + +#endif ///__MPBLEDEMO2_H__ + diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/include/wechar_crc.h b/examples/06_bluedroid_demos/components/bluedroid_demos/include/wechar_crc.h new file mode 100644 index 0000000000..9dbe222417 --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/include/wechar_crc.h @@ -0,0 +1,29 @@ +// crc32.h +// WeChat Embedded +// +// Created by harlliu on 14-03-03. +// Copyright 2014 Tencent. All rights reserved. +// + +#ifndef __CRC32_H__ +#define __CRC32_H__ + + +#include "prf_defs.h" +#if (WX_AIRSYNC_CFG) + +#include + +#ifdef __cplusplus +extern "C" { +#endif +uint32_t crc32(uint32_t crc, const uint8_t *buf, int len); + +#ifdef __cplusplus +} +#endif ///__cplusplus + +#endif ///WX_AIRSYNC_CFG + +#endif ///__CRC32_H__ + diff --git a/examples/06_bluedroid_demos/components/bluedroid_demos/include/wechat_aes.h b/examples/06_bluedroid_demos/components/bluedroid_demos/include/wechat_aes.h new file mode 100644 index 0000000000..c663b326c6 --- /dev/null +++ b/examples/06_bluedroid_demos/components/bluedroid_demos/include/wechat_aes.h @@ -0,0 +1,73 @@ +/////////////////////////////////////////////////////////////////////////////// +// 文 件 名：AES.h +// 描 述：AES加密算法 +// 创 建 人：Liangbofu +// 创建日期：2009-07-17 +/////////////////////////////////////////////////////////////////////////////// +#ifndef __WECHAT_AES_H +#define __WECHAT_AES_H + +#include "prf_defs.h" +#if (WX_AIRSYNC_CFG) + +#ifdef __cplusplus + extern "C" { +#endif + +// 以bit为单位的密钥长度，只能为 128，192 和 256 三种 +#define AES_KEY_LENGTH 128 + +// 加解密模式 +#define AES_MODE_ECB 0 // 电子密码本模式（一般模式） +#define AES_MODE_CBC 1 // 密码分组链接模式 +#define AES_MODE AES_MODE_CBC + + +/////////////////////////////////////////////////////////////////////////////// +// 函数名： AES_Init +// 描述： 初始化，在此执行扩展密钥操作。 +// 输入参数： pKey -- 原始密钥，其长度必须为 AES_KEY_LENGTH/8 字节。 +// 输出参数： 无。 +// 返回值： 无。 +/////////////////////////////////////////////////////////////////////////////// +void AES_Init(const void *pKey); + +////////////////////////////////////////////////////////////////////////// +// 函数名： AES_Encrypt +// 描述： 加密数据 +// 输入参数： pPlainText -- 明文，即需加密的数据，其长度为nDataLen字节。 +// nDataLen -- 数据长度，以字节为单位，必须为AES_KEY_LENGTH/8的整倍数。 +// pIV -- 初始化向量，如果使用ECB模式，可设为NULL。 +// 输出参数： pCipherText -- 密文，即由明文加密后的数据，可以与pPlainText相同。 +// 返回值： 无。 +////////////////////////////////////////////////////////////////////////// +void AES_Encrypt(const unsigned char *pPlainText, unsigned char *pCipherText, + unsigned int nDataLen, const unsigned char *pIV); + +////////////////////////////////////////////////////////////////////////// +// 函数名： AES_Decrypt +// 描述： 解密数据 +// 输入参数： pCipherText -- 密文，即需解密的数据，其长度为nDataLen字节。 +// nDataLen -- 数据长度，以字节为单位，必须为AES_KEY_LENGTH/8的整倍数。 +// pIV -- 初始化向量，如果使用ECB模式，可设为NULL。 +// 输出参数： pPlainText -- 明文，即由密文解密后的数据，可以与pCipherText相同。 +// 返回值： 无。 +////////////////////////////////////////////////////////////////////////// +void AES_Decrypt(unsigned char *pPlainText, const unsigned char *pCipherText, + unsigned int nDataLen, const unsigned char *pIV); + +//对数据进行解密操作，成功返回1，失败返回0 +unsigned char app_data_encode_aes(char *input, char *output, unsigned short *slen); +unsigned char app_data_decode_aes(unsigned char *input, char *output, unsigned short *slen); +unsigned int AES_Encrypt_PKCS7(const unsigned char *pPlainText, unsigned char *pCipherText, + unsigned int nDataLen, const unsigned char *pIV); +unsigned int AES_get_length(unsigned int length); +void AES_free(unsigned char* p); +#ifdef __cplusplus + } +#endif ///__cplusplus + +#endif ///WX_AIRSYNC_CFG + +#endif // __WECHAT_AES_H +