1. Remove the bond_device global variable.
2. Fix bond_device add cause memory exception
3. Modify the code location.
4. modify thread security
5. remove esp_ble_clear_bond_device_list() API
6. modify esp_ble_get_gond_device_list() to return list immediately, rather than wait event.
7. modify the gatt_security_server demo to show how to remove all the bonded devices.
8. fix some code bugs may cause something error.
#include "bt_trace.h"
#include "btc_manage.h"
#include "btc_gap_ble.h"
+#include "btc_ble_storage.h"
esp_err_t esp_ble_gap_register_callback(esp_gap_ble_cb_t callback)
== BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
}
-esp_err_t esp_ble_clear_bond_device_list(void)
+int esp_ble_get_bond_device_num(void)
{
- btc_msg_t msg;
- msg.sig = BTC_SIG_API_CALL;
- msg.pid = BTC_PID_GAP_BLE;
- msg.act = BTC_GAP_BLE_CLEAR_BOND_DEV_EVT;
+ ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED);
- return (btc_transfer_context(&msg, NULL, 0, NULL)
- == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
+ return btc_storage_get_num_ble_bond_devices();
}
-esp_err_t esp_ble_get_bond_device_list(void)
+esp_err_t esp_ble_get_bond_device_list(int *dev_num, esp_ble_bond_dev_t *dev_list)
{
- btc_msg_t msg;
- msg.sig = BTC_SIG_API_CALL;
- msg.pid = BTC_PID_GAP_BLE;
- msg.act = BTC_GAP_BLE_GET_BOND_DEV_EVT;
+ int ret;
+ int dev_num_total;
- return (btc_transfer_context(&msg, NULL, 0, NULL)
- == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
+ if (dev_num == NULL || dev_list == NULL) {
+ return ESP_ERR_INVALID_ARG;
+ }
+
+ ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED);
+
+ dev_num_total = btc_storage_get_num_ble_bond_devices();
+ if (*dev_num > dev_num_total) {
+ *dev_num = dev_num_total;
+ }
+
+ ret = btc_storage_get_bonded_ble_devices_list(dev_list, *dev_num);
+
+ return (ret == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
}
esp_err_t esp_ble_gap_disconnect(esp_bd_addr_t remote_device)
ESP_GAP_BLE_SET_PKT_LENGTH_COMPLETE_EVT, /*!< When set pkt lenght complete, the event comes */
ESP_GAP_BLE_SET_LOCAL_PRIVACY_COMPLETE_EVT, /*!< When Enable/disable privacy on the local device complete, the event comes */
ESP_GAP_BLE_REMOVE_BOND_DEV_COMPLETE_EVT, /*!< When remove the bond device complete, the event comes */
- ESP_GAP_BLE_CLEAR_BOND_DEV_COMPLETE_EVT, /*!< When clear the bond device clear complete, the event comes */
- ESP_GAP_BLE_GET_BOND_DEV_COMPLETE_EVT, /*!< When get the bond device list complete, the event comes */
ESP_GAP_BLE_EVT_MAX,
} esp_gap_ble_cb_event_t;
esp_bt_status_t status; /*!< Indicate the remove bond device operation success status */
esp_bd_addr_t bd_addr; /*!< The device address which has been remove from the bond list */
}remove_bond_dev_cmpl; /*!< Event parameter of ESP_GAP_BLE_REMOVE_BOND_DEV_COMPLETE_EVT */
- /**
- * @brief ESP_GAP_BLE_CLEAR_BOND_DEV_COMPLETE_EVT
- */
- struct ble_clear_bond_dev_cmpl_evt_param {
- esp_bt_status_t status; /*!< Indicate the clear bond device operation success status */
- }clear_bond_dev_cmpl; /*!< Event parameter of ESP_GAP_BLE_CLEAR_BOND_DEV_COMPLETE_EVT */
- /**
- * @brief ESP_GAP_BLE_GET_BOND_DEV_COMPLETE_EVT
- */
- struct ble_get_bond_dev_cmpl_evt_param {
- esp_bt_status_t status; /*!< Indicate the get bond device operation success status */
- uint8_t dev_num; /*!< Indicate the get number device in the bond list */
- esp_ble_bond_dev_t *bond_dev; /*!< the pointer to the bond device Structure */
- }get_bond_dev_cmpl; /*!< Event parameter of ESP_GAP_BLE_GET_BOND_DEV_COMPLETE_EVT */
} esp_ble_gap_cb_param_t;
/**
esp_err_t esp_ble_remove_bond_device(esp_bd_addr_t bd_addr);
/**
-* @brief Removes all of the device from the security database list of
-* peer device. It manages unpairing event while connected.
+* @brief Get the device number from the security database list of peer device.
+* It will return the device bonded number immediately.
*
-* @return - ESP_OK : success
-* - other : failed
+* @return - >= 0 : bonded devices number.
+* - < 0 : failed
*
*/
-esp_err_t esp_ble_clear_bond_device_list(void);
+int esp_ble_get_bond_device_num(void);
+
/**
* @brief Get the device from the security database list of peer device.
-* It will return the device bonded information from the ESP_GAP_BLE_GET_BOND_DEV_COMPLETE_EVT event.
+* It will return the device bonded information immediately.
+* @param[inout] dev_num: Indicate the dev_list array(buffer) size as input.
+* If dev_num is large enough, it means the actual number as output.
+* Suggest that dev_num value equal to esp_ble_get_bond_device_num().
*
-* @return - ESP_OK : success
-* - other : failed
+* @param[out] dev_list: an array(buffer) of `esp_ble_bond_dev_t` type. Use for storing the bonded devices address.
+* The dev_list should be allocated by who call this API.
+* @return - ESP_OK : success
+* - other : failed
*
*/
-esp_err_t esp_ble_get_bond_device_list(void);
+esp_err_t esp_ble_get_bond_device_list(int *dev_num, esp_ble_bond_dev_t *dev_list);
/**
* @brief This function is to disconnect the physical connection of the peer device
#if (SMP_INCLUDED == TRUE)
-btc_dm_pairing_cb_t pairing_cb;
-btc_dm_local_key_cb_t ble_local_key_cb;
-btc_bonded_devices_t bonded_devices;
-
-
-/*******************************************************************************
-**
-** Function btc_storage_load_bonded_devices
-**
-** Description btc storage API - Loads all the bonded devices from NVRAM
-** and adds to the BTA.
-** Additionally, this API also invokes the adaper_properties_cb
-** and remote_device_properties_cb for each of the bonded devices.
-**
-** Returns BT_STATUS_SUCCESS if successful, BT_STATUS_FAIL otherwise
-**
-*******************************************************************************/
-bt_status_t btc_storage_load_bonded_ble_devices(void)
-{
- bt_status_t status;
- status = btc_in_fetch_bonded_ble_devices(1);
- LOG_DEBUG("Storage load rslt %d\n", status);
- return status;
-}
-
-bt_status_t btc_in_fetch_bonded_ble_devices(int add)
+static void _btc_storage_save(void)
{
- bt_status_t status = BT_STATUS_FAIL;
- int device_type = 0;
- for (const btc_config_section_iter_t *iter = btc_config_section_begin(); iter != btc_config_section_end();
- iter = btc_config_section_next(iter)) {
- const char *name = btc_config_section_name(iter);
- if (!string_is_bdaddr(name) ||
- !btc_config_get_int(name, BTC_LE_DEV_TYPE, &device_type) ||
- ((device_type & BT_DEVICE_TYPE_BLE) != BT_DEVICE_TYPE_BLE)) {
- continue;
- }
- LOG_DEBUG("%s, name = %s", __func__, name);
- if (btc_in_fetch_bonded_ble_device(name, add, &bonded_devices) != BT_STATUS_SUCCESS) {
- LOG_DEBUG("Remote device:%s, no link key or ble key found", name);
- } else {
- status = BT_STATUS_SUCCESS;
- }
- }
+ const btc_config_section_iter_t *iter = btc_config_section_begin();
- return status;
-}
+ while (iter != btc_config_section_end()) {
+ //store the next iter, if remove section, then will not loss the point
-bt_status_t btc_get_bonded_ble_devices_list(esp_ble_bond_dev_t *bond_dev)
-{
- bt_bdaddr_t bd_addr;
- int device_type = 0;
- char buffer[sizeof(tBTM_LE_KEY_VALUE)] = {0};
- for (const btc_config_section_iter_t *iter = btc_config_section_begin(); iter != btc_config_section_end();
- iter = btc_config_section_next(iter)) {
- const char *name = btc_config_section_name(iter);
- if (!string_is_bdaddr(name) ||
- !btc_config_get_int(name, BTC_LE_DEV_TYPE, &device_type) ||
- ((device_type & BT_DEVICE_TYPE_BLE) != BT_DEVICE_TYPE_BLE)) {
+ const char *section = btc_config_section_name(iter);
+ if (!string_is_bdaddr(section)) {
+ iter = btc_config_section_next(iter);
continue;
}
- string_to_bdaddr(name, &bd_addr);
- memcpy(bond_dev->bd_addr, bd_addr.address, sizeof(bt_bdaddr_t));
- //resolve the peer device long term key
- if (btc_storage_get_ble_bonding_key(&bd_addr, BTM_LE_KEY_PENC, buffer, sizeof(tBTM_LE_PENC_KEYS))
- == BT_STATUS_SUCCESS) {
- bond_dev->bond_key.key_mask |= ESP_BLE_ENC_KEY_MASK;
- memcpy(&bond_dev->bond_key.penc_key, buffer, sizeof(tBTM_LE_PENC_KEYS));
- }
- //resolve the peer device csrk
- if (btc_storage_get_ble_bonding_key(&bd_addr, BTM_LE_KEY_PCSRK, buffer, sizeof(tBTM_LE_PCSRK_KEYS))
- == BT_STATUS_SUCCESS) {
- bond_dev->bond_key.key_mask |= ESP_BLE_CSR_KEY_MASK;
- memcpy(&bond_dev->bond_key.pcsrk_key, buffer, sizeof(tBTM_LE_PCSRK_KEYS));
- }
- //resolve the peer device irk
- if (btc_storage_get_ble_bonding_key(&bd_addr, BTM_LE_KEY_PID, buffer, sizeof(tBTM_LE_PID_KEYS))
- == BT_STATUS_SUCCESS) {
- bond_dev->bond_key.key_mask |= ESP_BLE_ID_KEY_MASK;
- memcpy(&bond_dev->bond_key.pid_key, buffer, sizeof(tBTM_LE_PID_KEYS));
+ if (!btc_config_exist(section, BTC_BLE_STORAGE_DEV_TYPE_STR) &&
+ !btc_config_exist(section, BTC_BLE_STORAGE_ADDR_TYPE_STR) &&
+ !btc_config_exist(section, BTC_BLE_STORAGE_LINK_KEY_STR) &&
+ !btc_config_exist(section, BTC_BLE_STORAGE_LE_KEY_PENC_STR) &&
+ !btc_config_exist(section, BTC_BLE_STORAGE_LE_KEY_PID_STR) &&
+ !btc_config_exist(section, BTC_BLE_STORAGE_LE_KEY_PCSRK_STR) &&
+ !btc_config_exist(section, BTC_BLE_STORAGE_LE_KEY_LENC_STR) &&
+ !btc_config_exist(section, BTC_BLE_STORAGE_LE_KEY_LCSRK_STR)) {
+ iter = btc_config_section_next(iter);
+ btc_config_remove_section(section);
+ continue;
}
- //serch for the next bond device
- bond_dev++;
- }
-
- return BT_STATUS_SUCCESS;
-}
-
-void btc_dm_remove_ble_bonding_keys(void)
-{
- bt_bdaddr_t bd_addr;
- LOG_DEBUG("%s\n",__func__);
-
- bdcpy(bd_addr.address, pairing_cb.bd_addr);
- btc_storage_remove_ble_bonding_keys(&bd_addr);
-}
-
-void btc_save_ble_bonding_keys(void)
-{
- bt_bdaddr_t bd_addr;
-
- bdcpy(bd_addr.address, pairing_cb.bd_addr);
- bdstr_t bdstr;
- bdaddr_to_string(&bd_addr, bdstr, sizeof(bdstr));
- btc_config_set_int(bdstr, BTC_LE_DEV_TYPE, BT_DEVICE_TYPE_BLE);
- LOG_DEBUG("%s, penc = %d, pid = %d", __func__, pairing_cb.ble.is_penc_key_rcvd, pairing_cb.ble.is_pid_key_rcvd);
- if (pairing_cb.ble.is_penc_key_rcvd) {
- btc_storage_add_ble_bonding_key(&bd_addr,
- (char *) &pairing_cb.ble.penc_key,
- BTM_LE_KEY_PENC,
- sizeof(tBTM_LE_PENC_KEYS));
- }
-
- if (pairing_cb.ble.is_pid_key_rcvd) {
- btc_storage_add_ble_bonding_key(&bd_addr,
- (char *) &pairing_cb.ble.pid_key,
- BTM_LE_KEY_PID,
- sizeof(tBTM_LE_PID_KEYS));
- }
-
-
- if (pairing_cb.ble.is_pcsrk_key_rcvd) {
- btc_storage_add_ble_bonding_key(&bd_addr,
- (char *) &pairing_cb.ble.pcsrk_key,
- BTM_LE_KEY_PCSRK,
- sizeof(tBTM_LE_PCSRK_KEYS));
- }
-
-
- if (pairing_cb.ble.is_lenc_key_rcvd) {
- btc_storage_add_ble_bonding_key(&bd_addr,
- (char *) &pairing_cb.ble.lenc_key,
- BTM_LE_KEY_LENC,
- sizeof(tBTM_LE_LENC_KEYS));
- }
- if (pairing_cb.ble.is_lcsrk_key_rcvd) {
- btc_storage_add_ble_bonding_key(&bd_addr,
- (char *) &pairing_cb.ble.lcsrk_key,
- BTM_LE_KEY_LCSRK,
- sizeof(tBTM_LE_LCSRK_KEYS));
+ iter = btc_config_section_next(iter);
}
- if (pairing_cb.ble.is_lidk_key_rcvd) {
- btc_storage_add_ble_bonding_key(&bd_addr,
- NULL,
- BTM_LE_KEY_LID,
- 0);
- }
+ btc_config_flush();
}
-static void btc_read_le_key(const uint8_t key_type, const size_t key_len, bt_bdaddr_t bd_addr,
- const uint8_t addr_type, const bool add_key, bool *device_added, bool *key_found)
+void btc_storage_save(void)
{
- assert(device_added);
- assert(key_found);
-
- char buffer[100];
- memset(buffer, 0, sizeof(buffer));
- if (btc_storage_get_ble_bonding_key(&bd_addr, key_type, buffer, key_len) == BT_STATUS_SUCCESS) {
- if (add_key) {
- BD_ADDR bta_bd_addr;
- bdcpy(bta_bd_addr, bd_addr.address);
-
- if (!*device_added) {
- BTA_DmAddBleDevice(bta_bd_addr, addr_type, BT_DEVICE_TYPE_BLE);
- *device_added = true;
- }
-
- char bd_str[20] = {0};
- LOG_DEBUG("%s() Adding key type %d for %s", __func__,
- key_type, bdaddr_to_string(&bd_addr, bd_str, sizeof(bd_str)));
- BTA_DmAddBleKey(bta_bd_addr, (tBTA_LE_KEY_VALUE *)buffer, key_type);
- }
-
- *key_found = true;
- }
+ btc_config_lock();
+ _btc_storage_save();
+ btc_config_unlock();
}
-bt_status_t btc_storage_add_ble_bonding_key(bt_bdaddr_t *remote_bd_addr,
+static bt_status_t _btc_storage_add_ble_bonding_key(bt_bdaddr_t *remote_bd_addr,
char *key,
uint8_t key_type,
uint8_t key_length)
bdstr_t bdstr;
bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bdstr));
const char* name;
+
switch (key_type) {
case BTM_LE_KEY_PENC:
- name = "LE_KEY_PENC";
+ name = BTC_BLE_STORAGE_LE_KEY_PENC_STR;
break;
case BTM_LE_KEY_PID:
- name = "LE_KEY_PID";
+ name = BTC_BLE_STORAGE_LE_KEY_PID_STR;
break;
case BTM_LE_KEY_PCSRK:
- name = "LE_KEY_PCSRK";
+ name = BTC_BLE_STORAGE_LE_KEY_PCSRK_STR;
break;
case BTM_LE_KEY_LENC:
- name = "LE_KEY_LENC";
+ name = BTC_BLE_STORAGE_LE_KEY_LENC_STR;
break;
case BTM_LE_KEY_LCSRK:
- name = "LE_KEY_LCSRK";
+ name = BTC_BLE_STORAGE_LE_KEY_LCSRK_STR;
break;
case BTM_LE_KEY_LID:
- name = "LE_KEY_LID";
+ name = BTC_BLE_STORAGE_LE_KEY_LID_STR;
break;
default:
return BT_STATUS_FAIL;
}
int ret = btc_config_set_bin(bdstr, name, (const uint8_t *)key, key_length);
- btc_config_save();
+ _btc_storage_save();
return ret ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
}
+bt_status_t btc_storage_add_ble_bonding_key(bt_bdaddr_t *remote_bd_addr,
+ char *key,
+ uint8_t key_type,
+ uint8_t key_length)
+{
+ bt_status_t ret;
+
+ btc_config_lock();
+ ret = _btc_storage_add_ble_bonding_key(remote_bd_addr, key, key_type, key_length);
+ btc_config_unlock();
+
+ return ret;
+}
/*******************************************************************************
**
** BT_STATUS_FAIL otherwise
**
*******************************************************************************/
-bt_status_t btc_storage_get_ble_bonding_key(bt_bdaddr_t *remote_bd_addr,
+static bt_status_t _btc_storage_get_ble_bonding_key(bt_bdaddr_t *remote_bd_addr,
uint8_t key_type,
char *key_value,
int key_length)
const char* name;
switch (key_type) {
case BTM_LE_KEY_PENC:
- name = "LE_KEY_PENC";
+ name = BTC_BLE_STORAGE_LE_KEY_PENC_STR;
break;
case BTM_LE_KEY_PID:
- name = "LE_KEY_PID";
+ name = BTC_BLE_STORAGE_LE_KEY_PID_STR;
break;
case BTM_LE_KEY_PCSRK:
- name = "LE_KEY_PCSRK";
+ name = BTC_BLE_STORAGE_LE_KEY_PCSRK_STR;
break;
case BTM_LE_KEY_LENC:
- name = "LE_KEY_LENC";
+ name = BTC_BLE_STORAGE_LE_KEY_LENC_STR;
break;
case BTM_LE_KEY_LCSRK:
- name = "LE_KEY_LCSRK";
+ name = BTC_BLE_STORAGE_LE_KEY_LCSRK_STR;
break;
case BTM_LE_KEY_LID:
- name = "LE_KEY_LID";
+ name = BTC_BLE_STORAGE_LE_KEY_LID_STR;
default:
return BT_STATUS_FAIL;
}
}
-bool btc_storage_compare_address_key_value(bt_bdaddr_t *remote_bd_addr,
- uint8_t key_type, void *key_value, int key_length)
+bt_status_t btc_storage_get_ble_bonding_key(bt_bdaddr_t *remote_bd_addr,
+ uint8_t key_type,
+ char *key_value,
+ int key_length)
{
- bdstr_t bdstr;
- bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bdstr));
- char *key_type_str;
- switch (key_type) {
- case BTM_LE_KEY_PENC:
- key_type_str = "LE_KEY_PENC";
- break;
- case BTM_LE_KEY_PID:
- key_type_str = "LE_KEY_PID";
- break;
- case BTM_LE_KEY_PCSRK:
- key_type_str = "LE_KEY_PCSRK";
- break;
- case BTM_LE_KEY_LENC:
- key_type_str = "LE_KEY_LENC";
- break;
- case BTM_LE_KEY_LCSRK:
- key_type_str = "LE_KEY_LCSRK";
- break;
- case BTM_LE_KEY_LID:
- key_type_str = "LE_KEY_LID";
- default:
- return false;
- }
+ bt_status_t ret;
- return btc_compare_address_key_value(bdstr, key_type_str, key_value, key_length);
-}
+ btc_config_lock();
+ ret = _btc_storage_get_ble_bonding_key(remote_bd_addr, key_type, key_value, key_length);
+ btc_config_unlock();
+ return ret;
+}
/*******************************************************************************
**
** BT_STATUS_FAIL otherwise
**
*******************************************************************************/
-bt_status_t btc_storage_remove_ble_bonding_keys(bt_bdaddr_t *remote_bd_addr)
+static bt_status_t _btc_storage_remove_ble_bonding_keys(bt_bdaddr_t *remote_bd_addr)
{
+ int ret = 1;
bdstr_t bdstr;
bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bdstr));
+
BTIF_TRACE_DEBUG(" %s in bd addr:%s",__FUNCTION__, bdstr);
- int ret = 1;
- if (btc_config_exist(bdstr, BTC_LE_DEV_TYPE)) {
- ret &= btc_config_remove(bdstr, BTC_LE_DEV_TYPE);
+
+ if (btc_config_exist(bdstr, BTC_BLE_STORAGE_ADDR_TYPE_STR)) {
+ ret &= btc_config_remove(bdstr, BTC_BLE_STORAGE_ADDR_TYPE_STR);
}
- if (btc_config_exist(bdstr, "LE_KEY_PENC")) {
- ret &= btc_config_remove(bdstr, "LE_KEY_PENC");
+ if (btc_config_exist(bdstr, BTC_BLE_STORAGE_LE_KEY_PENC_STR)) {
+ ret &= btc_config_remove(bdstr, BTC_BLE_STORAGE_LE_KEY_PENC_STR);
}
- if (btc_config_exist(bdstr, "LE_KEY_PID")) {
- ret &= btc_config_remove(bdstr, "LE_KEY_PID");
+ if (btc_config_exist(bdstr, BTC_BLE_STORAGE_LE_KEY_PID_STR)) {
+ ret &= btc_config_remove(bdstr, BTC_BLE_STORAGE_LE_KEY_PID_STR);
}
- if (btc_config_exist(bdstr, "LE_KEY_PCSRK")) {
- ret &= btc_config_remove(bdstr, "LE_KEY_PCSRK");
+ if (btc_config_exist(bdstr, BTC_BLE_STORAGE_LE_KEY_PCSRK_STR)) {
+ ret &= btc_config_remove(bdstr, BTC_BLE_STORAGE_LE_KEY_PCSRK_STR);
}
- if (btc_config_exist(bdstr, "LE_KEY_LENC")) {
- ret &= btc_config_remove(bdstr, "LE_KEY_LENC");
+ if (btc_config_exist(bdstr, BTC_BLE_STORAGE_LE_KEY_LENC_STR)) {
+ ret &= btc_config_remove(bdstr, BTC_BLE_STORAGE_LE_KEY_LENC_STR);
}
- if (btc_config_exist(bdstr, "LE_KEY_LCSRK")) {
- ret &= btc_config_remove(bdstr, "LE_KEY_LCSRK");
+ if (btc_config_exist(bdstr, BTC_BLE_STORAGE_LE_KEY_LCSRK_STR)) {
+ ret &= btc_config_remove(bdstr, BTC_BLE_STORAGE_LE_KEY_LCSRK_STR);
}
- //remove the address information after delete the ble key.
- ret = btc_config_remove_section(bdstr);
- btc_config_save();
+ //here don't remove section, because config_save will check it
+ _btc_storage_save();
return ret ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
}
-bt_status_t btc_storage_clear_bond_devices(void)
+bt_status_t btc_storage_remove_ble_bonding_keys(bt_bdaddr_t *remote_bd_addr)
{
- bt_bdaddr_t bd_addr;
- int device_type = 0;
- for (const btc_config_section_iter_t *iter = btc_config_section_begin(); iter != btc_config_section_end();
- iter = btc_config_section_next(iter)) {
- const char *name = btc_config_section_name(iter);
- if (!string_is_bdaddr(name) &&
- !btc_config_get_int(name, BTC_LE_DEV_TYPE, &device_type) &&
- ((device_type & BT_DEVICE_TYPE_BLE) != BT_DEVICE_TYPE_BLE)) {
- continue;
- }
+ bt_status_t ret;
- string_to_bdaddr(name, &bd_addr);
- //remove the ble bonding keys from the config and then save the config to the flash
- if (btc_storage_remove_ble_bonding_keys(&bd_addr) != BT_STATUS_SUCCESS) {
- LOG_ERROR("%s, remove bonding key faild", __func__);
- return BT_STATUS_FAIL;
- }
- // the bonded_devices Structure record the devices which has been added to the BTM layer global variable
- for (int i = 0; i < bonded_devices.num_devices; i++) {
- //if the address is equal to the record device address, remove it from the BTM layer global variable
- if (!memcmp(bd_addr.address, bonded_devices.devices[i].address, sizeof(bt_bdaddr_t))) {
- BD_ADDR bta_addr;
- memcpy(bta_addr, bd_addr.address, sizeof(BD_ADDR));
- if(BTA_DmRemoveDevice(bta_addr) != BTA_SUCCESS) {
- LOG_ERROR("%s, remove device faild", __func__);
- return BT_STATUS_FAIL;
- }
- }
- }
- }
+ btc_config_lock();
+ ret = _btc_storage_remove_ble_bonding_keys(remote_bd_addr);
+ btc_config_unlock();
- return BT_STATUS_SUCCESS;
+ return ret;
}
/*******************************************************************************
** BT_STATUS_FAIL otherwise
**
*******************************************************************************/
-bt_status_t btc_storage_add_ble_local_key(char *key,
+static bt_status_t _btc_storage_add_ble_local_key(char *key,
uint8_t key_type,
uint8_t key_length)
{
const char* name;
switch (key_type) {
case BTC_LE_LOCAL_KEY_IR:
- name = "LE_LOCAL_KEY_IR";
+ name = BTC_BLE_STORAGE_LE_LOCAL_KEY_IR_STR;
break;
case BTC_LE_LOCAL_KEY_IRK:
- name = "LE_LOCAL_KEY_IRK";
+ name = BTC_BLE_STORAGE_LE_LOCAL_KEY_IRK_STR;
break;
case BTC_LE_LOCAL_KEY_DHK:
- name = "LE_LOCAL_KEY_DHK";
+ name = BTC_BLE_STORAGE_LE_LOCAL_KEY_DHK_STR;
break;
case BTC_LE_LOCAL_KEY_ER:
- name = "LE_LOCAL_KEY_ER";
+ name = BTC_BLE_STORAGE_LE_LOCAL_KEY_ER_STR;
break;
default:
return BT_STATUS_FAIL;
}
- int ret = btc_config_set_bin("Adapter", name, (const uint8_t *)key, key_length);
- btc_config_save();
+
+ int ret = btc_config_set_bin(BTC_BLE_STORAGE_LOCAL_ADAPTER_STR, name, (const uint8_t *)key, key_length);
+ _btc_storage_save();
return ret ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
}
+bt_status_t btc_storage_add_ble_local_key(char *key,
+ uint8_t key_type,
+ uint8_t key_length)
+{
+ bt_status_t ret;
+
+ btc_config_lock();
+ ret = _btc_storage_add_ble_local_key(key, key_type, key_length);
+ btc_config_unlock();
+
+ return ret;
+}
+
/*******************************************************************************
**
** Function btc_storage_get_ble_local_key
** BT_STATUS_FAIL otherwise
**
*******************************************************************************/
-bt_status_t btc_storage_get_ble_local_key(uint8_t key_type,
+static bt_status_t _btc_storage_get_ble_local_key(uint8_t key_type,
char *key_value,
int key_length)
{
const char* name;
switch (key_type) {
case BTC_LE_LOCAL_KEY_IR:
- name = "LE_LOCAL_KEY_IR";
+ name = BTC_BLE_STORAGE_LE_LOCAL_KEY_IR_STR;
break;
case BTC_LE_LOCAL_KEY_IRK:
- name = "LE_LOCAL_KEY_IRK";
+ name = BTC_BLE_STORAGE_LE_LOCAL_KEY_IRK_STR;
break;
case BTC_LE_LOCAL_KEY_DHK:
- name = "LE_LOCAL_KEY_DHK";
+ name = BTC_BLE_STORAGE_LE_LOCAL_KEY_DHK_STR;
break;
case BTC_LE_LOCAL_KEY_ER:
- name = "LE_LOCAL_KEY_ER";
+ name = BTC_BLE_STORAGE_LE_LOCAL_KEY_ER_STR;
break;
default:
return BT_STATUS_FAIL;
}
size_t length = key_length;
- int ret = btc_config_get_bin("Adapter", name, (uint8_t *)key_value, &length);
+
+ int ret = btc_config_get_bin(BTC_BLE_STORAGE_LOCAL_ADAPTER_STR, name, (uint8_t *)key_value, &length);
+
return ret ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
}
+bt_status_t btc_storage_get_ble_local_key(uint8_t key_type,
+ char *key_value,
+ int key_length)
+{
+ bt_status_t ret;
+
+ btc_config_lock();
+ ret = _btc_storage_get_ble_local_key(key_type, key_value, key_length);
+ btc_config_unlock();
+
+ return ret;
+}
+
/*******************************************************************************
**
** Function btc_storage_remove_ble_local_keys
** BT_STATUS_FAIL otherwise
**
*******************************************************************************/
-bt_status_t btc_storage_remove_ble_local_keys(void)
+static bt_status_t _btc_storage_remove_ble_local_keys(void)
{
int ret = 1;
- if (btc_config_exist("Adapter", "LE_LOCAL_KEY_IR")) {
- ret &= btc_config_remove("Adapter", "LE_LOCAL_KEY_IR");
+
+ if (btc_config_exist(BTC_BLE_STORAGE_LOCAL_ADAPTER_STR, BTC_BLE_STORAGE_LE_LOCAL_KEY_IR_STR)) {
+ ret &= btc_config_remove(BTC_BLE_STORAGE_LOCAL_ADAPTER_STR, BTC_BLE_STORAGE_LE_LOCAL_KEY_IR_STR);
+ }
+ if (btc_config_exist(BTC_BLE_STORAGE_LOCAL_ADAPTER_STR, BTC_BLE_STORAGE_LE_LOCAL_KEY_IRK_STR)) {
+ ret &= btc_config_remove(BTC_BLE_STORAGE_LOCAL_ADAPTER_STR, BTC_BLE_STORAGE_LE_LOCAL_KEY_IRK_STR);
+ }
+ if (btc_config_exist(BTC_BLE_STORAGE_LOCAL_ADAPTER_STR, BTC_BLE_STORAGE_LE_LOCAL_KEY_DHK_STR)) {
+ ret &= btc_config_remove(BTC_BLE_STORAGE_LOCAL_ADAPTER_STR, BTC_BLE_STORAGE_LE_LOCAL_KEY_DHK_STR);
+ }
+ if (btc_config_exist(BTC_BLE_STORAGE_LOCAL_ADAPTER_STR, BTC_BLE_STORAGE_LE_LOCAL_KEY_ER_STR)) {
+ ret &= btc_config_remove(BTC_BLE_STORAGE_LOCAL_ADAPTER_STR, BTC_BLE_STORAGE_LE_LOCAL_KEY_ER_STR);
+ }
+ _btc_storage_save();
+
+ return ret ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
+}
+
+bt_status_t btc_storage_remove_ble_local_keys(void)
+{
+ bt_status_t ret;
+
+ btc_config_lock();
+ ret = _btc_storage_remove_ble_local_keys();
+ btc_config_unlock();
+
+ return ret;
+}
+
+bool _btc_storage_compare_address_key_value(bt_bdaddr_t *remote_bd_addr,
+ uint8_t key_type, void *key_value, int key_length)
+{
+ bdstr_t bdstr;
+ bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bdstr));
+ char *key_type_str;
+ switch (key_type) {
+ case BTM_LE_KEY_PENC:
+ key_type_str = BTC_BLE_STORAGE_LE_KEY_PENC_STR;
+ break;
+ case BTM_LE_KEY_PID:
+ key_type_str = BTC_BLE_STORAGE_LE_KEY_PID_STR;
+ break;
+ case BTM_LE_KEY_PCSRK:
+ key_type_str = BTC_BLE_STORAGE_LE_KEY_PCSRK_STR;
+ break;
+ case BTM_LE_KEY_LENC:
+ key_type_str = BTC_BLE_STORAGE_LE_KEY_LENC_STR;
+ break;
+ case BTM_LE_KEY_LCSRK:
+ key_type_str = BTC_BLE_STORAGE_LE_KEY_LCSRK_STR;
+ break;
+ case BTM_LE_KEY_LID:
+ key_type_str = BTC_BLE_STORAGE_LE_KEY_LID_STR;
+ default:
+ return false;
+ }
+
+ return btc_compare_address_key_value(bdstr, key_type_str, key_value, key_length);
+}
+
+bool btc_storage_compare_address_key_value(bt_bdaddr_t *remote_bd_addr,
+ uint8_t key_type, void *key_value, int key_length)
+{
+ bool ret;
+
+ btc_config_lock();
+ ret = _btc_storage_compare_address_key_value(remote_bd_addr, key_type, key_value, key_length);
+ btc_config_unlock();
+
+ return ret;
+}
+
+static bt_status_t _btc_storage_set_ble_dev_type(bt_bdaddr_t *bd_addr, bool flush)
+{
+ bool ret = 1;
+ bdstr_t bdstr;
+ uint32_t dev_type = 0;
+
+ bdaddr_to_string(bd_addr, bdstr, sizeof(bdstr));
+
+ btc_config_get_int(bdstr, BTC_BLE_STORAGE_DEV_TYPE_STR, (int *)&dev_type);
+ ret = btc_config_set_int(bdstr, BTC_BLE_STORAGE_DEV_TYPE_STR, BT_DEVICE_TYPE_BLE|dev_type);
+ if (ret == false) {
+ return BT_STATUS_FAIL;
+ }
+
+ if (flush) {
+ _btc_storage_save();
+ }
+
+ return BT_STATUS_SUCCESS;
+}
+
+bt_status_t btc_storage_set_ble_dev_type(bt_bdaddr_t *bd_addr, bool flush)
+{
+ bt_status_t ret;
+
+ btc_config_lock();
+ ret = _btc_storage_set_ble_dev_type(bd_addr, flush);
+ btc_config_unlock();
+
+ return ret;
+}
+
+static bool _btc_storage_get_ble_dev_type(bt_bdaddr_t *bd_addr)
+{
+ bool ret = 1;
+ bdstr_t bdstr;
+ uint32_t dev_type = 0;
+
+ bdaddr_to_string(bd_addr, bdstr, sizeof(bdstr));
+
+ BTIF_TRACE_DEBUG(" %s in bd addr:%s",__FUNCTION__, bdstr);
+
+ ret = btc_config_get_int(bdstr, BTC_BLE_STORAGE_DEV_TYPE_STR, (int *)&dev_type);
+ if (ret == false) {
+ return false;
}
- if (btc_config_exist("Adapter", "LE_LOCAL_KEY_IRK")) {
- ret &= btc_config_remove("Adapter", "LE_LOCAL_KEY_IRK");
+
+ return (dev_type & BT_DEVICE_TYPE_BLE);
+}
+
+bool btc_storage_get_ble_dev_type(bt_bdaddr_t *bd_addr)
+{
+ bt_status_t ret;
+
+ btc_config_lock();
+ ret = _btc_storage_get_ble_dev_type(bd_addr);
+ btc_config_unlock();
+
+ return ret;
+}
+
+
+static bt_status_t _btc_storage_remove_ble_dev_type(bt_bdaddr_t *remote_bd_addr, bool flush)
+{
+ bool ret = true;
+ bdstr_t bdstr;
+ uint32_t dev_type = 0;
+
+ bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bdstr));
+
+ BTIF_TRACE_DEBUG(" %s in bd addr:%s",__FUNCTION__, bdstr);
+
+ ret = btc_config_get_int(bdstr, BTC_BLE_STORAGE_DEV_TYPE_STR, (int *)&dev_type);
+ if (ret == false) {
+ //cannot find the key, just return SUCCESS, indicate already removed
+ return BT_STATUS_SUCCESS;
}
- if (btc_config_exist("Adapter", "LE_LOCAL_KEY_DHK")) {
- ret &= btc_config_remove("Adapter", "LE_LOCAL_KEY_DHK");
+
+ if (dev_type == BT_DEVICE_TYPE_DUMO) {
+ ret = btc_config_set_int(bdstr, BTC_BLE_STORAGE_DEV_TYPE_STR, BT_DEVICE_TYPE_BREDR);
+ } else if (dev_type == BT_DEVICE_TYPE_BLE) {
+ ret = btc_config_remove(bdstr, BTC_BLE_STORAGE_DEV_TYPE_STR);
}
- if (btc_config_exist("Adapter", "LE_LOCAL_KEY_ER")) {
- ret &= btc_config_remove("Adapter", "LE_LOCAL_KEY_ER");
+
+ if (ret == false) {
+ return BT_STATUS_FAIL;
}
- btc_config_save();
+
+ if (flush) {
+ _btc_storage_save();
+ }
+
+ return BT_STATUS_SUCCESS;
+}
+
+bt_status_t btc_storage_remove_ble_dev_type(bt_bdaddr_t *remote_bd_addr, bool flush)
+{
+ bt_status_t ret;
+
+ btc_config_lock();
+ ret = _btc_storage_remove_ble_dev_type(remote_bd_addr, flush);
+ btc_config_unlock();
+
+ return ret;
+}
+
+static bt_status_t _btc_storage_set_remote_addr_type(bt_bdaddr_t *remote_bd_addr, uint8_t addr_type, bool flush)
+{
+ int ret;
+ bdstr_t bdstr;
+
+ bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bdstr_t));
+ ret = btc_config_set_int(bdstr, BTC_BLE_STORAGE_ADDR_TYPE_STR, (int)addr_type);
+ if (ret == false) {
+ return BT_STATUS_FAIL;
+ }
+
+ if (flush) {
+ _btc_storage_save();
+ }
+
+ return BT_STATUS_SUCCESS;
+}
+
+bt_status_t btc_storage_set_remote_addr_type(bt_bdaddr_t *remote_bd_addr, uint8_t addr_type, bool flush)
+{
+ bt_status_t ret;
+
+ btc_config_lock();
+ ret = _btc_storage_set_remote_addr_type(remote_bd_addr, addr_type, flush);
+ btc_config_unlock();
+
+ return ret;
+}
+
+static bt_status_t _btc_storage_remove_remote_addr_type(bt_bdaddr_t *remote_bd_addr, bool flush)
+{
+ bool ret = true;
+ bdstr_t bdstr;
+ uint32_t dev_type = 0;
+
+ bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bdstr));
+
+ ret = btc_config_get_int(bdstr, BTC_BLE_STORAGE_ADDR_TYPE_STR, (int *)&dev_type);
+ if (ret == false) {
+ //cannot find the key, just return SUCCESS, indicate already removed
+ return BT_STATUS_SUCCESS;
+ }
+
+ ret = btc_config_remove(bdstr, BTC_BLE_STORAGE_ADDR_TYPE_STR);
+ if (ret == false) {
+ return BT_STATUS_FAIL;
+ }
+
+ if (flush) {
+ _btc_storage_save();
+ }
+
+ return BT_STATUS_SUCCESS;
+}
+
+bt_status_t btc_storage_remove_remote_addr_type(bt_bdaddr_t *remote_bd_addr, bool flush)
+{
+ bt_status_t ret;
+
+ btc_config_lock();
+ ret = _btc_storage_remove_remote_addr_type(remote_bd_addr, flush);
+ btc_config_unlock();
+
+ return ret;
+}
+
+static bt_status_t _btc_storage_get_remote_addr_type(bt_bdaddr_t *remote_bd_addr,
+ int*addr_type)
+{
+ bdstr_t bdstr;
+ bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bdstr));
+ int ret = btc_config_get_int(bdstr, BTC_BLE_STORAGE_ADDR_TYPE_STR, addr_type);
return ret ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
}
+bt_status_t btc_storage_get_remote_addr_type(bt_bdaddr_t *remote_bd_addr,
+ int*addr_type)
+{
+ bt_status_t ret;
+
+ btc_config_lock();
+ ret = _btc_storage_get_remote_addr_type(remote_bd_addr, addr_type);
+ btc_config_unlock();
+
+ return ret;
+}
+
+static void _btc_read_le_key(const uint8_t key_type, const size_t key_len, bt_bdaddr_t bd_addr,
+ const uint8_t addr_type, const bool add_key, bool *device_added, bool *key_found)
+{
+ assert(device_added);
+ assert(key_found);
+
+ char buffer[100];
+ memset(buffer, 0, sizeof(buffer));
+
+ bt_status_t ret = _btc_storage_get_ble_bonding_key(&bd_addr, key_type, buffer, key_len);
+
+ if (ret == BT_STATUS_SUCCESS) {
+ if (add_key) {
+ BD_ADDR bta_bd_addr;
+ bdcpy(bta_bd_addr, bd_addr.address);
+
+ if (!*device_added) {
+ BTA_DmAddBleDevice(bta_bd_addr, addr_type, BT_DEVICE_TYPE_BLE);
+ *device_added = true;
+ }
+
+ char bd_str[20] = {0};
+ LOG_DEBUG("%s() Adding key type %d for %s", __func__,
+ key_type, bdaddr_to_string(&bd_addr, bd_str, sizeof(bd_str)));
+ BTA_DmAddBleKey(bta_bd_addr, (tBTA_LE_KEY_VALUE *)buffer, key_type);
+ }
-bt_status_t btc_in_fetch_bonded_ble_device(const char *remote_bd_addr, int add,
- btc_bonded_devices_t *p_bonded_devices)
+ *key_found = true;
+ }
+}
+static bt_status_t _btc_storage_in_fetch_bonded_ble_device(const char *remote_bd_addr, int add)
{
- int device_type;
+ uint32_t device_type;
int addr_type;
bt_bdaddr_t bd_addr;
BD_ADDR bta_bd_addr;
bool device_added = false;
bool key_found = false;
- if (!btc_config_get_int(remote_bd_addr, BTC_LE_DEV_TYPE, &device_type)) {
+ if (!btc_config_get_int(remote_bd_addr, BTC_BLE_STORAGE_DEV_TYPE_STR, (int *)&device_type)) {
LOG_ERROR("%s, device_type = %x", __func__, device_type);
return BT_STATUS_FAIL;
}
string_to_bdaddr(remote_bd_addr, &bd_addr);
bdcpy(bta_bd_addr, bd_addr.address);
- if (btc_storage_get_remote_addr_type(&bd_addr, &addr_type) != BT_STATUS_SUCCESS) {
+ if (_btc_storage_get_remote_addr_type(&bd_addr, &addr_type) != BT_STATUS_SUCCESS) {
addr_type = BLE_ADDR_PUBLIC;
- btc_storage_set_remote_addr_type(&bd_addr, BLE_ADDR_PUBLIC);
+ _btc_storage_set_remote_addr_type(&bd_addr, BLE_ADDR_PUBLIC, true);
}
- btc_read_le_key(BTM_LE_KEY_PENC, sizeof(tBTM_LE_PENC_KEYS),
+ _btc_read_le_key(BTM_LE_KEY_PENC, sizeof(tBTM_LE_PENC_KEYS),
bd_addr, addr_type, add, &device_added, &key_found);
- btc_read_le_key(BTM_LE_KEY_PID, sizeof(tBTM_LE_PID_KEYS),
+ _btc_read_le_key(BTM_LE_KEY_PID, sizeof(tBTM_LE_PID_KEYS),
bd_addr, addr_type, add, &device_added, &key_found);
- btc_read_le_key(BTM_LE_KEY_LID, sizeof(tBTM_LE_PID_KEYS),
+ _btc_read_le_key(BTM_LE_KEY_LID, sizeof(tBTM_LE_PID_KEYS),
bd_addr, addr_type, add, &device_added, &key_found);
- btc_read_le_key(BTM_LE_KEY_PCSRK, sizeof(tBTM_LE_PCSRK_KEYS),
+ _btc_read_le_key(BTM_LE_KEY_PCSRK, sizeof(tBTM_LE_PCSRK_KEYS),
bd_addr, addr_type, add, &device_added, &key_found);
- btc_read_le_key(BTM_LE_KEY_LENC, sizeof(tBTM_LE_LENC_KEYS),
+ _btc_read_le_key(BTM_LE_KEY_LENC, sizeof(tBTM_LE_LENC_KEYS),
bd_addr, addr_type, add, &device_added, &key_found);
- btc_read_le_key(BTM_LE_KEY_LCSRK, sizeof(tBTM_LE_LCSRK_KEYS),
+ _btc_read_le_key(BTM_LE_KEY_LCSRK, sizeof(tBTM_LE_LCSRK_KEYS),
bd_addr, addr_type, add, &device_added, &key_found);
- // Fill in the bonded devices
- if (device_added)
- {
- memcpy(&p_bonded_devices->devices[p_bonded_devices->num_devices++],
- &bd_addr, sizeof(bt_bdaddr_t));
- }
-
if (key_found) {
return BT_STATUS_SUCCESS;
}
return BT_STATUS_FAIL;
}
-bt_status_t btc_storage_set_remote_addr_type(bt_bdaddr_t *remote_bd_addr,
- uint8_t addr_type)
+static bt_status_t btc_storage_in_fetch_bonded_ble_devices(int add)
{
- bdstr_t bdstr;
- bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bt_bdaddr_t));
- int ret = btc_config_set_int(bdstr, "AddrType", (int)addr_type);
- btc_config_save();
- return ret ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
+ bt_status_t status = BT_STATUS_FAIL;
+ uint32_t device_type = 0;
+
+ btc_config_lock();
+ for (const btc_config_section_iter_t *iter = btc_config_section_begin(); iter != btc_config_section_end();
+ iter = btc_config_section_next(iter)) {
+ const char *name = btc_config_section_name(iter);
+
+ if (!string_is_bdaddr(name) ||
+ !btc_config_get_int(name, BTC_BLE_STORAGE_DEV_TYPE_STR, (int *)&device_type) ||
+ ((device_type & BT_DEVICE_TYPE_BLE) != BT_DEVICE_TYPE_BLE)) {
+ continue;
+ }
+ LOG_DEBUG("%s, name = %s", __func__, name);
+ if (_btc_storage_in_fetch_bonded_ble_device(name, add) != BT_STATUS_SUCCESS) {
+ LOG_DEBUG("Remote device:%s, no link key or ble key found", name);
+ } else {
+ status = BT_STATUS_SUCCESS;
+ }
+ }
+ btc_config_unlock();
+
+ return status;
}
/*******************************************************************************
**
-** Function btc_storage_get_remote_addr_type
+** Function btc_storage_load_bonded_devices
**
-** Description btc storage API - Fetches the remote addr type
+** Description btc storage API - Loads all the bonded devices from NVRAM
+** and adds to the BTA.
+** Additionally, this API also invokes the adaper_properties_cb
+** and remote_device_properties_cb for each of the bonded devices.
**
-** Returns BT_STATUS_SUCCESS if the fetch was successful,
-** BT_STATUS_FAIL otherwise
+** Returns BT_STATUS_SUCCESS if successful, BT_STATUS_FAIL otherwise
**
*******************************************************************************/
-bt_status_t btc_storage_get_remote_addr_type(bt_bdaddr_t *remote_bd_addr,
- int*addr_type)
+bt_status_t btc_storage_load_bonded_ble_devices(void)
{
- bdstr_t bdstr;
- bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bdstr));
- int ret = btc_config_get_int(bdstr, "AddrType", addr_type);
- return ret ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
+ bt_status_t status;
+ status = btc_storage_in_fetch_bonded_ble_devices(1);
+ LOG_DEBUG("Storage load rslt %d\n", status);
+ return status;
}
-int btc_storage_get_num_ble_bond_devices(void)
+bt_status_t btc_storage_get_bonded_ble_devices_list(esp_ble_bond_dev_t *bond_dev, int dev_num)
{
- int num_dev = 0;
- int device_type = 0;
+ bt_bdaddr_t bd_addr;
+ uint32_t device_type = 0;
+ char buffer[sizeof(tBTM_LE_KEY_VALUE)] = {0};
+
+ btc_config_lock();
for (const btc_config_section_iter_t *iter = btc_config_section_begin(); iter != btc_config_section_end();
iter = btc_config_section_next(iter)) {
+
+ if (dev_num-- <= 0) {
+ break;
+ }
+
const char *name = btc_config_section_name(iter);
- if (!string_is_bdaddr(name) &&
- !btc_config_get_int(name, BTC_LE_DEV_TYPE, &device_type) &&
- device_type != BT_DEVICE_TYPE_BLE) {
+
+ if (!string_is_bdaddr(name) ||
+ !btc_config_get_int(name, BTC_BLE_STORAGE_DEV_TYPE_STR, (int *)&device_type) ||
+ !(device_type & BT_DEVICE_TYPE_BLE)) {
continue;
}
- num_dev++;
+ string_to_bdaddr(name, &bd_addr);
+ memcpy(bond_dev->bd_addr, bd_addr.address, sizeof(bt_bdaddr_t));
+ //resolve the peer device long term key
+ if (_btc_storage_get_ble_bonding_key(&bd_addr, BTM_LE_KEY_PENC, buffer, sizeof(tBTM_LE_PENC_KEYS)) == BT_STATUS_SUCCESS) {
+ bond_dev->bond_key.key_mask |= ESP_BLE_ENC_KEY_MASK;
+ memcpy(&bond_dev->bond_key.penc_key, buffer, sizeof(tBTM_LE_PENC_KEYS));
+ }
+ //resolve the peer device csrk
+ if (_btc_storage_get_ble_bonding_key(&bd_addr, BTM_LE_KEY_PCSRK, buffer, sizeof(tBTM_LE_PCSRK_KEYS)) == BT_STATUS_SUCCESS) {
+ bond_dev->bond_key.key_mask |= ESP_BLE_CSR_KEY_MASK;
+ memcpy(&bond_dev->bond_key.pcsrk_key, buffer, sizeof(tBTM_LE_PCSRK_KEYS));
+ }
+ //resolve the peer device irk
+ if (_btc_storage_get_ble_bonding_key(&bd_addr, BTM_LE_KEY_PID, buffer, sizeof(tBTM_LE_PID_KEYS)) == BT_STATUS_SUCCESS) {
+ bond_dev->bond_key.key_mask |= ESP_BLE_ID_KEY_MASK;
+ memcpy(&bond_dev->bond_key.pid_key, buffer, sizeof(tBTM_LE_PID_KEYS));
+ }
+ //serch for the next bond device
+ bond_dev++;
}
+ btc_config_unlock();
- return num_dev;
+ return BT_STATUS_SUCCESS;
}
-void btc_dm_load_ble_local_keys(void)
+int btc_storage_get_num_ble_bond_devices(void)
{
- memset(&ble_local_key_cb, 0, sizeof(btc_dm_local_key_cb_t));
-
- if (btc_storage_get_ble_local_key(BTC_LE_LOCAL_KEY_ER,(char*)&ble_local_key_cb.er[0],
- BT_OCTET16_LEN)== BT_STATUS_SUCCESS) {
- ble_local_key_cb.is_er_rcvd = TRUE;
- LOG_DEBUG("%s BLE ER key loaded",__func__ );
- }
+ int num_dev = 0;
+ uint32_t device_type = 0;
- if ((btc_storage_get_ble_local_key(BTC_LE_LOCAL_KEY_IR,(char*)&ble_local_key_cb.id_keys.ir[0],
- BT_OCTET16_LEN)== BT_STATUS_SUCCESS )&&
- (btc_storage_get_ble_local_key(BTC_LE_LOCAL_KEY_IRK, (char*)&ble_local_key_cb.id_keys.irk[0],
- BT_OCTET16_LEN)== BT_STATUS_SUCCESS)&&
- (btc_storage_get_ble_local_key(BTC_LE_LOCAL_KEY_DHK,(char*)&ble_local_key_cb.id_keys.dhk[0],
- BT_OCTET16_LEN)== BT_STATUS_SUCCESS)) {
- ble_local_key_cb.is_id_keys_rcvd = TRUE;
- LOG_DEBUG("%s BLE ID keys loaded", __func__);
- }
+ btc_config_lock();
+ for (const btc_config_section_iter_t *iter = btc_config_section_begin(); iter != btc_config_section_end();
+ iter = btc_config_section_next(iter)) {
+ const char *name = btc_config_section_name(iter);
+ if (!string_is_bdaddr(name) ||
+ !btc_config_get_int(name, BTC_BLE_STORAGE_DEV_TYPE_STR, (int *)&device_type) ||
+ !(device_type & BT_DEVICE_TYPE_BLE)) {
+ continue;
+ }
-}
-void btc_dm_get_ble_local_keys(tBTA_DM_BLE_LOCAL_KEY_MASK *p_key_mask, BT_OCTET16 er,
- tBTA_BLE_LOCAL_ID_KEYS *p_id_keys)
-{
- if (ble_local_key_cb.is_er_rcvd ) {
- memcpy(&er[0], &ble_local_key_cb.er[0], sizeof(BT_OCTET16));
- *p_key_mask |= BTA_BLE_LOCAL_KEY_TYPE_ER;
+ num_dev++;
}
+ btc_config_unlock();
- if (ble_local_key_cb.is_id_keys_rcvd) {
- memcpy(&p_id_keys->ir[0], &ble_local_key_cb.id_keys.ir[0], sizeof(BT_OCTET16));
- memcpy(&p_id_keys->irk[0], &ble_local_key_cb.id_keys.irk[0], sizeof(BT_OCTET16));
- memcpy(&p_id_keys->dhk[0], &ble_local_key_cb.id_keys.dhk[0], sizeof(BT_OCTET16));
- *p_key_mask |= BTA_BLE_LOCAL_KEY_TYPE_ID;
- }
- LOG_DEBUG("%s *p_key_mask=0x%02x",__func__, *p_key_mask);
+ return num_dev;
}
-
#endif ///SMP_INCLUDED == TRUE
static const period_ms_t CONFIG_SETTLE_PERIOD_MS = 3000;
static void btc_key_value_to_string(uint8_t *key_vaule, char *value_str, int key_length);
-
-// TODO(zachoverflow): Move these two functions out, because they are too specific for this file
-// {grumpy-cat/no, monty-python/you-make-me-sad}
-bool btc_get_device_type(const BD_ADDR bd_addr, int *p_device_type)
-{
- if (p_device_type == NULL) {
- return FALSE;
- }
-
- bt_bdaddr_t bda;
- bdcpy(bda.address, bd_addr);
-
- bdstr_t bd_addr_str;
- bdaddr_to_string(&bda, bd_addr_str, sizeof(bd_addr_str));
-
- if (!btc_config_get_int(bd_addr_str, BTC_LE_DEV_TYPE, p_device_type)) {
- return FALSE;
- }
-
- LOG_DEBUG("%s: Device [%s] type %d\n", __FUNCTION__, bd_addr_str, *p_device_type);
- return TRUE;
-}
-
-bool btc_get_address_type(const BD_ADDR bd_addr, int *p_addr_type)
-{
- if (p_addr_type == NULL) {
- return FALSE;
- }
-
- bt_bdaddr_t bda;
- bdcpy(bda.address, bd_addr);
-
- bdstr_t bd_addr_str;
- bdaddr_to_string(&bda, bd_addr_str, sizeof(bd_addr_str));
-
- if (!btc_config_get_int(bd_addr_str, "AddrType", p_addr_type)) {
- return FALSE;
- }
-
- LOG_DEBUG("%s: Device [%s] address type %d\n", __FUNCTION__, bd_addr_str, *p_addr_type);
- return TRUE;
-}
-
static osi_mutex_t lock; // protects operations on |config|.
static config_t *config;
return false;
}
btc_key_value_to_string((uint8_t *)key_value, value_str, key_length);
- osi_mutex_lock(&lock, OSI_MUTEX_MAX_TIMEOUT);
if ((status = config_has_key_in_section(config, key_type, value_str)) == true) {
config_remove_section(config, section);
}
- osi_mutex_unlock(&lock);
return status;
}
assert(config != NULL);
assert(section != NULL);
- osi_mutex_lock(&lock, OSI_MUTEX_MAX_TIMEOUT);
- bool ret = config_has_section(config, section);
- osi_mutex_unlock(&lock);
-
- return ret;
+ return config_has_section(config, section);
}
bool btc_config_exist(const char *section, const char *key)
assert(section != NULL);
assert(key != NULL);
- osi_mutex_lock(&lock, OSI_MUTEX_MAX_TIMEOUT);
- bool ret = config_has_key(config, section, key);
- osi_mutex_unlock(&lock);
-
- return ret;
+ return config_has_key(config, section, key);
}
bool btc_config_get_int(const char *section, const char *key, int *value)
assert(key != NULL);
assert(value != NULL);
- osi_mutex_lock(&lock, OSI_MUTEX_MAX_TIMEOUT);
bool ret = config_has_key(config, section, key);
if (ret) {
*value = config_get_int(config, section, key, *value);
}
- osi_mutex_unlock(&lock);
return ret;
}
assert(section != NULL);
assert(key != NULL);
- osi_mutex_lock(&lock, OSI_MUTEX_MAX_TIMEOUT);
config_set_int(config, section, key, value);
- osi_mutex_unlock(&lock);
return true;
}
assert(value != NULL);
assert(size_bytes != NULL);
- osi_mutex_lock(&lock, OSI_MUTEX_MAX_TIMEOUT);
const char *stored_value = config_get_string(config, section, key, NULL);
- osi_mutex_unlock(&lock);
if (!stored_value) {
return false;
assert(key != NULL);
assert(value != NULL);
- osi_mutex_lock(&lock, OSI_MUTEX_MAX_TIMEOUT);
config_set_string(config, section, key, value, false);
- osi_mutex_unlock(&lock);
return true;
}
assert(value != NULL);
assert(length != NULL);
- osi_mutex_lock(&lock, OSI_MUTEX_MAX_TIMEOUT);
const char *value_str = config_get_string(config, section, key, NULL);
- osi_mutex_unlock(&lock);
if (!value_str) {
return false;
assert(section != NULL);
assert(key != NULL);
- osi_mutex_lock(&lock, OSI_MUTEX_MAX_TIMEOUT);
const char *value_str = config_get_string(config, section, key, NULL);
- osi_mutex_unlock(&lock);
if (!value_str) {
return 0;
str[(i * 2) + 1] = lookup[value[i] & 0x0F];
}
- osi_mutex_lock(&lock, OSI_MUTEX_MAX_TIMEOUT);
config_set_string(config, section, key, str, false);
- osi_mutex_unlock(&lock);
osi_free(str);
return true;
return config_section_name((const config_section_node_t *)section);
}
+
+
bool btc_config_remove(const char *section, const char *key)
{
assert(config != NULL);
assert(section != NULL);
assert(key != NULL);
- osi_mutex_lock(&lock, OSI_MUTEX_MAX_TIMEOUT);
- bool ret = config_remove_key(config, section, key);
- osi_mutex_unlock(&lock);
-
- return ret;
+ return config_remove_key(config, section, key);
}
bool btc_config_remove_section(const char *section)
assert(config != NULL);
assert(section != NULL);
- osi_mutex_lock(&lock, OSI_MUTEX_MAX_TIMEOUT);
- bool ret = config_remove_section(config, section);
- osi_mutex_unlock(&lock);
-
- return ret;
-}
-
-void btc_config_save(void)
-{
- assert(config != NULL);
- // Garbage collection process: the config file accumulates
- // cached information about remote devices during regular
- // inquiry scans. We remove some of these junk entries
- // so the file doesn't grow indefinitely. We have to take care
- // to make sure we don't remove information about bonded
- // devices (hence the check for link keys).
- static const size_t CACHE_MAX = 256;
- const char *keys[CACHE_MAX];
- size_t num_keys = 0;
- size_t total_candidates = 0;
-
- osi_mutex_lock(&lock, OSI_MUTEX_MAX_TIMEOUT);
- for (const config_section_node_t *snode = config_section_begin(config); snode != config_section_end(config); snode = config_section_next(snode)) {
- const char *section = config_section_name(snode);
- if (!string_is_bdaddr(section)) {
- continue;
- }
-
- if (config_has_key(config, section, "LinkKey") ||
- config_has_key(config, section, "LE_KEY_PENC") ||
- config_has_key(config, section, "LE_KEY_PID") ||
- config_has_key(config, section, "LE_KEY_PCSRK") ||
- config_has_key(config, section, "LE_KEY_LENC") ||
- config_has_key(config, section, "LE_KEY_LCSRK")) {
- continue;
- }
-
- if (num_keys < CACHE_MAX) {
- keys[num_keys++] = section;
- }
-
- ++total_candidates;
- }
-
- if (total_candidates > CACHE_MAX * 2)
- while (num_keys > 0) {
- config_remove_section(config, keys[--num_keys]);
- }
- config_save(config, CONFIG_FILE_PATH);
- osi_mutex_unlock(&lock);
+ return config_remove_section(config, section);
}
void btc_config_flush(void)
{
assert(config != NULL);
- osi_mutex_lock(&lock, OSI_MUTEX_MAX_TIMEOUT);
+
config_save(config, CONFIG_FILE_PATH);
- osi_mutex_unlock(&lock);
}
int btc_config_clear(void)
{
assert(config != NULL);
-
- osi_mutex_lock(&lock, OSI_MUTEX_MAX_TIMEOUT);
config_free(config);
config = config_new_empty();
if (config == NULL) {
- osi_mutex_unlock(&lock);
return false;
}
int ret = config_save(config, CONFIG_FILE_PATH);
- osi_mutex_unlock(&lock);
return ret;
}
+void btc_config_lock(void)
+{
+ osi_mutex_lock(&lock, OSI_MUTEX_MAX_TIMEOUT);
+}
+
+void btc_config_unlock(void)
+{
+ osi_mutex_unlock(&lock);
+}
+
** Static variables
******************************************************************************/
static tBTA_SERVICE_MASK btc_enabled_services = 0;
+#if (SMP_INCLUDED == TRUE)
+static btc_dm_pairing_cb_t pairing_cb;
+static btc_dm_local_key_cb_t ble_local_key_cb;
+#endif
+
/******************************************************************************
** Static functions
******************************************************************************/
}
#if (SMP_INCLUDED == TRUE)
+void btc_dm_load_ble_local_keys(void)
+{
+ memset(&ble_local_key_cb, 0, sizeof(btc_dm_local_key_cb_t));
+
+ if (btc_storage_get_ble_local_key(BTC_LE_LOCAL_KEY_ER,(char*)&ble_local_key_cb.er[0],
+ BT_OCTET16_LEN)== BT_STATUS_SUCCESS) {
+ ble_local_key_cb.is_er_rcvd = TRUE;
+ LOG_DEBUG("%s BLE ER key loaded",__func__ );
+ }
+
+ if ((btc_storage_get_ble_local_key(BTC_LE_LOCAL_KEY_IR,(char*)&ble_local_key_cb.id_keys.ir[0],
+ BT_OCTET16_LEN)== BT_STATUS_SUCCESS )&&
+ (btc_storage_get_ble_local_key(BTC_LE_LOCAL_KEY_IRK, (char*)&ble_local_key_cb.id_keys.irk[0],
+ BT_OCTET16_LEN)== BT_STATUS_SUCCESS)&&
+ (btc_storage_get_ble_local_key(BTC_LE_LOCAL_KEY_DHK,(char*)&ble_local_key_cb.id_keys.dhk[0],
+ BT_OCTET16_LEN)== BT_STATUS_SUCCESS)) {
+ ble_local_key_cb.is_id_keys_rcvd = TRUE;
+ LOG_DEBUG("%s BLE ID keys loaded", __func__);
+ }
+
+}
+void btc_dm_get_ble_local_keys(tBTA_DM_BLE_LOCAL_KEY_MASK *p_key_mask, BT_OCTET16 er,
+ tBTA_BLE_LOCAL_ID_KEYS *p_id_keys)
+{
+ if (ble_local_key_cb.is_er_rcvd ) {
+ memcpy(&er[0], &ble_local_key_cb.er[0], sizeof(BT_OCTET16));
+ *p_key_mask |= BTA_BLE_LOCAL_KEY_TYPE_ER;
+ }
+
+ if (ble_local_key_cb.is_id_keys_rcvd) {
+ memcpy(&p_id_keys->ir[0], &ble_local_key_cb.id_keys.ir[0], sizeof(BT_OCTET16));
+ memcpy(&p_id_keys->irk[0], &ble_local_key_cb.id_keys.irk[0], sizeof(BT_OCTET16));
+ memcpy(&p_id_keys->dhk[0], &ble_local_key_cb.id_keys.dhk[0], sizeof(BT_OCTET16));
+ *p_key_mask |= BTA_BLE_LOCAL_KEY_TYPE_ID;
+ }
+ LOG_DEBUG("%s *p_key_mask=0x%02x",__func__, *p_key_mask);
+}
+
+
+static void btc_dm_remove_ble_bonding_keys(void)
+{
+ bt_bdaddr_t bd_addr;
+ LOG_DEBUG("%s\n",__func__);
+
+ bdcpy(bd_addr.address, pairing_cb.bd_addr);
+
+ btc_storage_remove_remote_addr_type(&bd_addr, false);
+ btc_storage_remove_ble_dev_type(&bd_addr, false);
+ btc_storage_remove_ble_bonding_keys(&bd_addr);
+}
+
+static void btc_dm_save_ble_bonding_keys(void)
+{
+ bt_bdaddr_t bd_addr;
+
+ bdcpy(bd_addr.address, pairing_cb.bd_addr);
+
+ btc_storage_set_ble_dev_type(&bd_addr, false);
+ LOG_DEBUG("%s, penc = %d, pid = %d", __func__, pairing_cb.ble.is_penc_key_rcvd, pairing_cb.ble.is_pid_key_rcvd);
+ if (pairing_cb.ble.is_penc_key_rcvd) {
+ btc_storage_add_ble_bonding_key(&bd_addr,
+ (char *) &pairing_cb.ble.penc_key,
+ BTM_LE_KEY_PENC,
+ sizeof(tBTM_LE_PENC_KEYS));
+ }
+
+ if (pairing_cb.ble.is_pid_key_rcvd) {
+ btc_storage_add_ble_bonding_key(&bd_addr,
+ (char *) &pairing_cb.ble.pid_key,
+ BTM_LE_KEY_PID,
+ sizeof(tBTM_LE_PID_KEYS));
+ }
+
+
+ if (pairing_cb.ble.is_pcsrk_key_rcvd) {
+ btc_storage_add_ble_bonding_key(&bd_addr,
+ (char *) &pairing_cb.ble.pcsrk_key,
+ BTM_LE_KEY_PCSRK,
+ sizeof(tBTM_LE_PCSRK_KEYS));
+ }
+
+
+ if (pairing_cb.ble.is_lenc_key_rcvd) {
+ btc_storage_add_ble_bonding_key(&bd_addr,
+ (char *) &pairing_cb.ble.lenc_key,
+ BTM_LE_KEY_LENC,
+ sizeof(tBTM_LE_LENC_KEYS));
+ }
+
+ if (pairing_cb.ble.is_lcsrk_key_rcvd) {
+ btc_storage_add_ble_bonding_key(&bd_addr,
+ (char *) &pairing_cb.ble.lcsrk_key,
+ BTM_LE_KEY_LCSRK,
+ sizeof(tBTM_LE_LCSRK_KEYS));
+ }
+
+ if (pairing_cb.ble.is_lidk_key_rcvd) {
+ btc_storage_add_ble_bonding_key(&bd_addr,
+ NULL,
+ BTM_LE_KEY_LID,
+ 0);
+ }
+}
+
static void btc_dm_ble_auth_cmpl_evt (tBTA_DM_AUTH_CMPL *p_auth_cmpl)
{
/* Save link key, if not temporary */
(pairing_cb.bd_addr[0] << 24) + (pairing_cb.bd_addr[1] << 16) + (pairing_cb.bd_addr[2] << 8) + pairing_cb.bd_addr[3],
(pairing_cb.bd_addr[4] << 8) + pairing_cb.bd_addr[5]);
if (btc_storage_get_remote_addr_type(&bdaddr, &addr_type) != BT_STATUS_SUCCESS) {
- btc_storage_set_remote_addr_type(&bdaddr, p_auth_cmpl->addr_type);
+ btc_storage_set_remote_addr_type(&bdaddr, p_auth_cmpl->addr_type, true);
}
/* check the irk has been save in the flash or not, if the irk has already save, means that the peer device has bonding
before. */
btc_storage_compare_address_key_value(&bdaddr, BTM_LE_KEY_PID,
(void *)&pairing_cb.ble.pid_key, sizeof(tBTM_LE_PID_KEYS));
}
- btc_save_ble_bonding_keys();
+ btc_dm_save_ble_bonding_keys();
} else {
/*Map the HCI fail reason to bt status */
switch (p_auth_cmpl->fail_reason) {
memcpy(bd_addr.address, p_data->link_down.bd_addr, sizeof(BD_ADDR));
btm_set_bond_type_dev(p_data->link_down.bd_addr, BOND_TYPE_UNKNOWN);
//remove the bonded key in the config and nvs flash.
- //btc_storage_remove_ble_bonding_keys(&bd_addr);
+ btc_storage_remove_ble_dev_type(&bd_addr, false);
+ btc_storage_remove_remote_addr_type(&bd_addr, false);
+ btc_storage_remove_ble_bonding_keys(&bd_addr);
ble_msg.act = ESP_GAP_BLE_REMOVE_BOND_DEV_COMPLETE_EVT;
param.remove_bond_dev_cmpl.status = (p_data->link_down.status == HCI_SUCCESS) ? ESP_BT_STATUS_SUCCESS : ESP_BT_STATUS_FAIL;
memcpy(param.remove_bond_dev_cmpl.bd_addr, p_data->link_down.bd_addr, sizeof(BD_ADDR));
bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bdstr));
LOG_DEBUG("add to storage: Remote device:%s\n", bdstr);
- int ret = btc_config_set_int(bdstr, "LinkKeyType", (int)key_type);
- ret &= btc_config_set_int(bdstr, "PinLength", (int)pin_length);
- ret &= btc_config_set_bin(bdstr, "LinkKey", link_key, sizeof(LINK_KEY));
+ btc_config_lock();
+ int ret = btc_config_set_int(bdstr, BTC_STORAGE_LINK_KEY_TYPE_STR, (int)key_type);
+ ret &= btc_config_set_int(bdstr, BTC_STORAGE_PIN_LENGTH_STR, (int)pin_length);
+ ret &= btc_config_set_bin(bdstr, BTC_STORAGE_LINK_KEY_STR, link_key, sizeof(LINK_KEY));
/* write bonded info immediately */
btc_config_flush();
+ btc_config_unlock();
+
LOG_DEBUG("Storage add rslt %d\n", ret);
return ret ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
}
{
BOOLEAN bt_linkkey_file_found = FALSE;
+ btc_config_lock();
for (const btc_config_section_iter_t *iter = btc_config_section_begin(); iter != btc_config_section_end(); iter = btc_config_section_next(iter)) {
const char *name = btc_config_section_name(iter);
if (!string_is_bdaddr(name)) {
LOG_DEBUG("Remote device:%s\n", name);
LINK_KEY link_key;
size_t size = sizeof(link_key);
- if (btc_config_get_bin(name, "LinkKey", link_key, &size)) {
+ if (btc_config_get_bin(name, BTC_STORAGE_LINK_KEY_STR, link_key, &size)) {
int linkkey_type;
- if (btc_config_get_int(name, "LinkKeyType", &linkkey_type)) {
- //int pin_len;
- //btc_config_get_int(name, "PinLength", &pin_len))
+ if (btc_config_get_int(name, BTC_STORAGE_LINK_KEY_TYPE_STR, &linkkey_type)) {
bt_bdaddr_t bd_addr;
string_to_bdaddr(name, &bd_addr);
if (add) {
DEV_CLASS dev_class = {0, 0, 0};
int cod;
int pin_length = 0;
- if (btc_config_get_int(name, "DevClass", &cod)) {
+ if (btc_config_get_int(name, BTC_STORAGE_DEV_CLASS_STR, &cod)) {
uint2devclass((UINT32)cod, dev_class);
}
- btc_config_get_int(name, "PinLength", &pin_length);
+ btc_config_get_int(name, BTC_STORAGE_PIN_LENGTH_STR, &pin_length);
#if (SMP_INCLUDED == TRUE)
BTA_DmAddDevice(bd_addr.address, dev_class, link_key, 0, 0,
(UINT8)linkkey_type, 0, pin_length);
LOG_DEBUG("Remote device:%s, no link key\n", name);
}
}
+ btc_config_unlock();
+
return BT_STATUS_SUCCESS;
}
{
bdstr_t bdstr;
bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bdstr));
+ int ret = 1;
LOG_DEBUG("Add to storage: Remote device:%s\n", bdstr);
- int ret = 1;
- if (btc_config_exist(bdstr, "LinkKeyType")) {
- ret &= btc_config_remove(bdstr, "LinkKeyType");
+ btc_config_lock();
+ if (btc_config_exist(bdstr, BTC_STORAGE_LINK_KEY_TYPE_STR)) {
+ ret &= btc_config_remove(bdstr, BTC_STORAGE_LINK_KEY_TYPE_STR);
}
- if (btc_config_exist(bdstr, "PinLength")) {
- ret &= btc_config_remove(bdstr, "PinLength");
+ if (btc_config_exist(bdstr, BTC_STORAGE_PIN_LENGTH_STR)) {
+ ret &= btc_config_remove(bdstr, BTC_STORAGE_PIN_LENGTH_STR);
}
- if (btc_config_exist(bdstr, "LinkKey")) {
- ret &= btc_config_remove(bdstr, "LinkKey");
+ if (btc_config_exist(bdstr, BTC_STORAGE_LINK_KEY_STR)) {
+ ret &= btc_config_remove(bdstr, BTC_STORAGE_LINK_KEY_STR);
}
/* write bonded info immediately */
btc_config_flush();
+ btc_config_unlock();
+
return ret ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
}
#define BTC_LE_LOCAL_KEY_DHK (1<<2)
#define BTC_LE_LOCAL_KEY_ER (1<<3)
+#define BTC_BLE_STORAGE_DEV_TYPE_STR "DevType"
+#define BTC_BLE_STORAGE_ADDR_TYPE_STR "AddrType"
+#define BTC_BLE_STORAGE_LINK_KEY_STR "LinkKey"
+#define BTC_BLE_STORAGE_LE_KEY_PENC_STR "LE_KEY_PENC"
+#define BTC_BLE_STORAGE_LE_KEY_PID_STR "LE_KEY_PID"
+#define BTC_BLE_STORAGE_LE_KEY_PCSRK_STR "LE_KEY_PCSRK"
+#define BTC_BLE_STORAGE_LE_KEY_LENC_STR "LE_KEY_LENC"
+#define BTC_BLE_STORAGE_LE_KEY_LID_STR "LE_KEY_LID"
+#define BTC_BLE_STORAGE_LE_KEY_LCSRK_STR "LE_KEY_LCSRK"
+
+#define BTC_BLE_STORAGE_LOCAL_ADAPTER_STR "Adapter"
+#define BTC_BLE_STORAGE_LE_LOCAL_KEY_IR_STR "LE_LOCAL_KEY_IR"
+#define BTC_BLE_STORAGE_LE_LOCAL_KEY_IRK_STR "LE_LOCAL_KEY_IRK"
+#define BTC_BLE_STORAGE_LE_LOCAL_KEY_DHK_STR "LE_LOCAL_KEY_DHK"
+#define BTC_BLE_STORAGE_LE_LOCAL_KEY_ER_STR "LE_LOCAL_KEY_ER"
+
/************************************************************************************
** Local type definitions
************************************************************************************/
-typedef struct
-{
- uint32_t num_devices;
- bt_bdaddr_t devices[BTM_SEC_MAX_DEVICE_RECORDS];
-} btc_bonded_devices_t;
-
-typedef struct
-{
- bool is_penc_key_rcvd;
- tBTM_LE_PENC_KEYS penc_key; /* received peer encryption key */
- bool is_pcsrk_key_rcvd;
- tBTM_LE_PCSRK_KEYS pcsrk_key; /* received peer device SRK */
- bool is_pid_key_rcvd;
- tBTM_LE_PID_KEYS pid_key; /* peer device ID key */
- bool is_lenc_key_rcvd;
- tBTM_LE_LENC_KEYS lenc_key; /* local encryption reproduction keys LTK = = d1(ER,DIV,0)*/
- bool is_lcsrk_key_rcvd;
- tBTM_LE_LCSRK_KEYS lcsrk_key; /* local device CSRK = d1(ER,DIV,1)*/
- bool is_lidk_key_rcvd; /* local identity key received */
-} btc_dm_ble_cb_t;
-
-typedef struct
-{
- bt_bdaddr_t static_bdaddr;
- BD_ADDR bd_addr;
- btc_dm_ble_cb_t ble;
-} btc_dm_pairing_cb_t;
-
-typedef struct
-{
- uint8_t ir[BT_OCTET16_LEN];
- uint8_t irk[BT_OCTET16_LEN];
- uint8_t dhk[BT_OCTET16_LEN];
-}btc_dm_local_key_id_t;
-
-typedef struct
-{
- bool is_er_rcvd;
- uint8_t er[BT_OCTET16_LEN];
- bool is_id_keys_rcvd;
- btc_dm_local_key_id_t id_keys; /* ID kyes */
-}btc_dm_local_key_cb_t;
-
typedef struct
{
BT_OCTET16 sp_c;
} btc_dm_oob_cb_t;
-extern btc_dm_pairing_cb_t pairing_cb;
-extern btc_dm_local_key_cb_t ble_local_key_cb;
-extern btc_bonded_devices_t bonded_devices;
+void btc_storage_save(void);
-bt_status_t btc_storage_load_bonded_ble_devices(void);
-
-bt_status_t btc_get_bonded_ble_devices_list(esp_ble_bond_dev_t *bond_dev);
+bt_status_t btc_storage_add_ble_bonding_key( bt_bdaddr_t *remote_bd_addr, char *key, uint8_t key_type, uint8_t key_length);
-bt_status_t btc_in_fetch_bonded_ble_devices(int add);
+bt_status_t btc_storage_get_ble_bonding_key(bt_bdaddr_t *remote_bd_addr, uint8_t key_type, char *key_value, int key_length);
-void btc_dm_remove_ble_bonding_keys(void);
+bt_status_t btc_storage_remove_ble_bonding_keys(bt_bdaddr_t *remote_bd_addr);
-bt_status_t btc_storage_add_ble_bonding_key( bt_bdaddr_t *remote_bd_addr,
- char *key,
- uint8_t key_type,
- uint8_t key_length);
+bool btc_storage_compare_address_key_value(bt_bdaddr_t *remote_bd_addr, uint8_t key_type, void *key_value, int key_length);
-bool btc_compare_le_key_value(const uint8_t key_type, const size_t key_len, const tBTA_LE_KEY_VALUE *key_vaule,
- bt_bdaddr_t bd_addr);
+bt_status_t btc_storage_add_ble_local_key(char *key, uint8_t key_type, uint8_t key_length);
-void btc_save_ble_bonding_keys(void);
+bt_status_t btc_storage_remove_ble_local_keys(void);
-bt_status_t btc_in_fetch_bonded_ble_device(const char *remote_bd_addr, int add,
- btc_bonded_devices_t *p_bonded_devices);
+bt_status_t btc_storage_get_ble_local_key(uint8_t key_type, char *key_value, int key_len);
-bt_status_t btc_storage_get_ble_bonding_key(bt_bdaddr_t *remote_bd_addr,
- uint8_t key_type,
- char *key_value,
- int key_length);
+bt_status_t btc_storage_get_remote_addr_type(bt_bdaddr_t *remote_bd_addr, int *addr_type);
-bool btc_storage_compare_address_key_value(bt_bdaddr_t *remote_bd_addr,
- uint8_t key_type, void *key_value, int key_length);
-bt_status_t btc_storage_add_ble_local_key(char *key,
- uint8_t key_type,
- uint8_t key_length);
+bt_status_t btc_storage_set_remote_addr_type(bt_bdaddr_t *remote_bd_addr, uint8_t addr_type, bool flush);
-bt_status_t btc_storage_remove_ble_bonding_keys(bt_bdaddr_t *remote_bd_addr);
+bt_status_t btc_storage_remove_remote_addr_type(bt_bdaddr_t *remote_bd_addr, bool flush);
-bt_status_t btc_storage_clear_bond_devices(void);
+bt_status_t btc_storage_set_ble_dev_type(bt_bdaddr_t *bd_addr, bool flush);
-bt_status_t btc_storage_remove_ble_local_keys(void);
+bt_status_t btc_storage_remove_ble_dev_type(bt_bdaddr_t *remote_bd_addr, bool flush);
-bt_status_t btc_storage_get_ble_local_key(uint8_t key_type,
- char *key_value,
- int key_len);
+bt_status_t btc_storage_load_bonded_ble_devices(void);
-bt_status_t btc_storage_get_remote_addr_type(bt_bdaddr_t *remote_bd_addr,
- int *addr_type);
+bt_status_t btc_storage_get_bonded_ble_devices_list(esp_ble_bond_dev_t *bond_dev, int dev_num);
int btc_storage_get_num_ble_bond_devices(void);
-bt_status_t btc_storage_set_remote_addr_type(bt_bdaddr_t *remote_bd_addr,
- uint8_t addr_type);
-
-void btc_dm_load_ble_local_keys(void);
-
-void btc_dm_get_ble_local_keys(tBTA_DM_BLE_LOCAL_KEY_MASK *p_key_mask, BT_OCTET16 er,
- tBTA_BLE_LOCAL_ID_KEYS *p_id_keys);
#endif ///SMP_INCLUDED == TRUE
-#endif ///__BTC_BLE_STORAGE_H__
\ No newline at end of file
+#endif ///__BTC_BLE_STORAGE_H__
#include "bt_types.h"
-#define BTC_LE_DEV_TYPE "DevType"
-
typedef struct btc_config_section_iter_t btc_config_section_iter_t;
bool btc_config_init(void);
const btc_config_section_iter_t *btc_config_section_next(const btc_config_section_iter_t *section);
const char *btc_config_section_name(const btc_config_section_iter_t *section);
-void btc_config_save(void);
void btc_config_flush(void);
int btc_config_clear(void);
bool btc_compare_address_key_value(const char *section, char *key_type, void *key_value, int key_length);
bool btc_get_device_type(const BD_ADDR bd_addr, int *p_device_type);
+void btc_config_lock(void);
+void btc_config_unlock(void);
+
#endif
tBTA_DM_SEC sec;
} btc_dm_sec_args_t;
+typedef struct
+{
+ bool is_penc_key_rcvd;
+ tBTM_LE_PENC_KEYS penc_key; /* received peer encryption key */
+ bool is_pcsrk_key_rcvd;
+ tBTM_LE_PCSRK_KEYS pcsrk_key; /* received peer device SRK */
+ bool is_pid_key_rcvd;
+ tBTM_LE_PID_KEYS pid_key; /* peer device ID key */
+ bool is_lenc_key_rcvd;
+ tBTM_LE_LENC_KEYS lenc_key; /* local encryption reproduction keys LTK = = d1(ER,DIV,0)*/
+ bool is_lcsrk_key_rcvd;
+ tBTM_LE_LCSRK_KEYS lcsrk_key; /* local device CSRK = d1(ER,DIV,1)*/
+ bool is_lidk_key_rcvd; /* local identity key received */
+} btc_dm_ble_cb_t;
+
+typedef struct
+{
+ bt_bdaddr_t static_bdaddr;
+ BD_ADDR bd_addr;
+ btc_dm_ble_cb_t ble;
+} btc_dm_pairing_cb_t;
+
+typedef struct
+{
+ uint8_t ir[BT_OCTET16_LEN];
+ uint8_t irk[BT_OCTET16_LEN];
+ uint8_t dhk[BT_OCTET16_LEN];
+} btc_dm_local_key_id_t;
+
+typedef struct
+{
+ bool is_er_rcvd;
+ uint8_t er[BT_OCTET16_LEN];
+ bool is_id_keys_rcvd;
+ btc_dm_local_key_id_t id_keys; /* ID kyes */
+} btc_dm_local_key_cb_t;
+
+
+
// void btc_dm_call_handler(btc_msg_t *msg);
void btc_dm_sec_evt(tBTA_DM_SEC_EVT event, tBTA_DM_SEC *data);
void btc_dm_sec_cb_handler(btc_msg_t *msg);
bt_status_t btc_dm_enable_service(tBTA_SERVICE_ID service_id);
bt_status_t btc_dm_disable_service(tBTA_SERVICE_ID service_id);
+#if (SMP_INCLUDED == TRUE)
+void btc_dm_load_ble_local_keys(void);
+
+void btc_dm_get_ble_local_keys(tBTA_DM_BLE_LOCAL_KEY_MASK *p_key_mask, BT_OCTET16 er,
+ tBTA_BLE_LOCAL_ID_KEYS *p_id_keys);
+#endif
+
#endif /* __BTC_DM_H__ */
#include "bt_defs.h"
#include "bt_types.h"
+
+#define BTC_STORAGE_DEV_CLASS_STR "DevClass"
+#define BTC_STORAGE_LINK_KEY_STR "LinkKey" /* same as the ble */
+#define BTC_STORAGE_LINK_KEY_TYPE_STR "LinkKeyType"
+#define BTC_STORAGE_PIN_LENGTH_STR "PinLength"
+
/*******************************************************************************
**
** Function btc_storage_add_bonded_device
#include "esp_bt_defs.h"
#include "esp_gap_ble_api.h"
#include "btc_ble_storage.h"
+#include "btc_dm.h"
static tBTA_BLE_ADV_DATA gl_bta_adv_data;
static tBTA_BLE_ADV_DATA gl_bta_scan_rsp_data;
}
}
-#if (SMP_INCLUDED)
-static void btc_ble_remove_bond_device(esp_bt_status_t status)
-{
- int ret;
- esp_ble_gap_cb_param_t param;
- btc_msg_t msg;
- param.remove_bond_dev_cmpl.status = status;
- msg.sig = BTC_SIG_API_CB;
- msg.pid = BTC_PID_GAP_BLE;
- msg.act = ESP_GAP_BLE_REMOVE_BOND_DEV_COMPLETE_EVT;
-
- ret = btc_transfer_context(&msg, ¶m,
- sizeof(esp_ble_gap_cb_param_t), NULL);
-
- if (ret != BT_STATUS_SUCCESS) {
- LOG_ERROR("%s btc_transfer_context failed", __func__);
- }
-}
-
-static void btc_ble_clear_bond_device(void)
-{
- int ret;
- esp_ble_gap_cb_param_t param;
- btc_msg_t msg;
- ret = btc_storage_clear_bond_devices();
- param.clear_bond_dev_cmpl.status = ret;
- msg.sig = BTC_SIG_API_CB;
- msg.pid = BTC_PID_GAP_BLE;
- msg.act = ESP_GAP_BLE_CLEAR_BOND_DEV_COMPLETE_EVT;
-
- ret = btc_transfer_context(&msg, ¶m,
- sizeof(esp_ble_gap_cb_param_t), NULL);
-
- if (ret != BT_STATUS_SUCCESS) {
- LOG_ERROR("%s btc_transfer_context failed", __func__);
- }
-
-}
-
-static void btc_ble_get_bond_device_list(void)
-{
- int ret;
- esp_ble_gap_cb_param_t param;
- esp_ble_bond_dev_t *bond_dev;
- btc_msg_t msg;
- int num_dev = btc_storage_get_num_ble_bond_devices();
- bond_dev = (esp_ble_bond_dev_t *)osi_malloc(sizeof(esp_ble_bond_dev_t)*num_dev);
-
- param.get_bond_dev_cmpl.status = btc_get_bonded_ble_devices_list(bond_dev);
- param.get_bond_dev_cmpl.dev_num = num_dev;
- param.get_bond_dev_cmpl.bond_dev = bond_dev;
- msg.sig = BTC_SIG_API_CB;
- msg.pid = BTC_PID_GAP_BLE;
- msg.act = ESP_GAP_BLE_GET_BOND_DEV_COMPLETE_EVT;
-
- ret = btc_transfer_context(&msg, ¶m, sizeof(esp_ble_gap_cb_param_t), btc_gap_ble_cb_deep_copy);
-
- if (ret != BT_STATUS_SUCCESS) {
- LOG_ERROR("%s btc_transfer_context failed", __func__);
- }
- // release the buffer after used.
- osi_free(bond_dev);
-}
-#endif /* #if (SMP_INCLUDED) */
-
static void btc_ble_config_local_privacy(bool privacy_enable, tBTA_SET_LOCAL_PRIVACY_CBACK *set_local_privacy_cback)
{
BTA_DmBleConfigLocalPrivacy(privacy_enable, set_local_privacy_cback);
void btc_gap_ble_cb_deep_copy(btc_msg_t *msg, void *p_dest, void *p_src)
{
switch (msg->act) {
- case ESP_GAP_BLE_GET_BOND_DEV_COMPLETE_EVT: {
- esp_ble_gap_cb_param_t *src = (esp_ble_gap_cb_param_t *)p_src;
- esp_ble_gap_cb_param_t *dst = (esp_ble_gap_cb_param_t *)p_dest;
- uint16_t length = 0;
- if (src->get_bond_dev_cmpl.bond_dev) {
- length = (src->get_bond_dev_cmpl.dev_num)*sizeof(esp_ble_bond_dev_t);
- dst->get_bond_dev_cmpl.bond_dev = (esp_ble_bond_dev_t *)osi_malloc(length);
- if (dst->get_bond_dev_cmpl.bond_dev != NULL) {
- memcpy(dst->get_bond_dev_cmpl.bond_dev, src->get_bond_dev_cmpl.bond_dev, length);
- } else {
- LOG_ERROR("%s %d no mem", __func__, msg->act);
- }
- }
- break;
- }
default:
LOG_ERROR("%s, Unhandled deep copy %d\n", __func__, msg->act);
break;
{
LOG_DEBUG("%s", __func__);
switch (msg->act) {
- case ESP_GAP_BLE_GET_BOND_DEV_COMPLETE_EVT: {
- esp_ble_bond_dev_t *bond_dev = ((esp_ble_gap_cb_param_t *)msg->arg)->get_bond_dev_cmpl.bond_dev;
- if (bond_dev) {
- osi_free(bond_dev);
- }
- break;
- }
default:
LOG_DEBUG("Unhandled deep free %d", msg->act);
break;
}
case BTC_GAP_BLE_REMOVE_BOND_DEV_EVT: {
BD_ADDR bd_addr;
- bt_bdaddr_t bt_addr;
memcpy(bd_addr, arg->remove_bond_device.bd_addr, sizeof(BD_ADDR));
- memcpy(bt_addr.address, arg->remove_bond_device.bd_addr, sizeof(bt_bdaddr_t));
- LOG_DEBUG("BTC_GAP_BLE_REMOVE_BOND_DEV_EVT");
- if (btc_storage_remove_ble_bonding_keys(&bt_addr) == BT_STATUS_SUCCESS) {
- BTA_DmRemoveDevice(bd_addr);
- } else {
- LOG_ERROR("remove device failed: the address[%x:%x:%x:%x:%x:%x] didn't in the bonding list", bd_addr[0], bd_addr[1], bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5]);
- btc_ble_remove_bond_device(ESP_BT_STATUS_FAIL);
- }
+ BTA_DmRemoveDevice(bd_addr);
break;
}
- case BTC_GAP_BLE_CLEAR_BOND_DEV_EVT:
- btc_ble_clear_bond_device();
- break;
- case BTC_GAP_BLE_GET_BOND_DEV_EVT:
- btc_ble_get_bond_device_list();
- break;
#endif ///SMP_INCLUDED == TRUE
case BTC_GAP_BLE_DISCONNECT_EVT:
btc_ble_disconnect(arg->disconnect.remote_device);
BTC_GAP_BLE_CONFIRM_REPLY_EVT,
BTC_GAP_BLE_DISCONNECT_EVT,
BTC_GAP_BLE_REMOVE_BOND_DEV_EVT,
- BTC_GAP_BLE_CLEAR_BOND_DEV_EVT,
- BTC_GAP_BLE_GET_BOND_DEV_EVT,
} btc_gap_ble_act_t;
/* btc_ble_gap_args_t */
#include "bta_sys.h"
#include "bta_dm_co.h"
#include "bta_dm_ci.h"
-#include "btc_ble_storage.h"
+#include "btc_dm.h"
#if (defined(BTIF_INCLUDED) && BTIF_INCLUDED == TRUE)
#include "bt_utils.h"
#if (BTM_OOB_INCLUDED == TRUE)
return key_str;
}
+static void show_bonded_devices(void)
+{
+ int dev_num = esp_ble_get_bond_device_num();
+
+ esp_ble_bond_dev_t *dev_list = (esp_ble_bond_dev_t *)malloc(sizeof(esp_ble_bond_dev_t) * dev_num);
+ esp_ble_get_bond_device_list(&dev_num, dev_list);
+ ESP_LOGI(GATTS_TABLE_TAG, "Bonded devices number : %d\n", dev_num);
+
+ ESP_LOGI(GATTS_TABLE_TAG, "Bonded devices list : %d\n", dev_num);
+ for (int i = 0; i < dev_num; i++) {
+ esp_log_buffer_hex(GATTS_TABLE_TAG, (void *)dev_list[i].bd_addr, sizeof(esp_bd_addr_t));
+ }
+
+ free(dev_list);
+}
+
+static void __attribute__((unused)) remove_all_bonded_devices(void)
+{
+ int dev_num = esp_ble_get_bond_device_num();
+
+ esp_ble_bond_dev_t *dev_list = (esp_ble_bond_dev_t *)malloc(sizeof(esp_ble_bond_dev_t) * dev_num);
+ esp_ble_get_bond_device_list(&dev_num, dev_list);
+ for (int i = 0; i < dev_num; i++) {
+ esp_ble_remove_bond_device(dev_list[i].bd_addr);
+ }
+
+ free(dev_list);
+}
+
static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param)
{
ESP_LOGV(GATTS_TABLE_TAG, "GAP_EVT, event %d\n", event);
(bd_addr[4] << 8) + bd_addr[5]);
ESP_LOGI(GATTS_TABLE_TAG, "address type = %d", param->ble_security.auth_cmpl.addr_type);
ESP_LOGI(GATTS_TABLE_TAG, "pair status = %s",param->ble_security.auth_cmpl.success ? "success" : "fail");
+ show_bonded_devices();
break;
}
case ESP_GAP_BLE_REMOVE_BOND_DEV_COMPLETE_EVT: {
- ESP_LOGI(GATTS_TABLE_TAG, "ESP_GAP_BLE_REMOVE_BOND_DEV_COMPLETE_EVT status = %d", param->remove_bond_dev_cmpl.status);
- break;
- }
- case ESP_GAP_BLE_CLEAR_BOND_DEV_COMPLETE_EVT: {
- ESP_LOGI(GATTS_TABLE_TAG, "ESP_GAP_BLE_CLEAR_BOND_DEV_COMPLETE_EVT status = %d", param->clear_bond_dev_cmpl.status);
- break;
- }
- case ESP_GAP_BLE_GET_BOND_DEV_COMPLETE_EVT: {
- ESP_LOGI(GATTS_TABLE_TAG, "ESP_GAP_BLE_GET_BOND_DEV_COMPLETE_EVT status = %d, num = %d", param->get_bond_dev_cmpl.status, param->get_bond_dev_cmpl.dev_num);
- esp_ble_bond_dev_t *bond_dev = param->get_bond_dev_cmpl.bond_dev;
- for(int i = 0; i < param->get_bond_dev_cmpl.dev_num; i++) {
- ESP_LOGI(GATTS_TABLE_TAG, "mask = %x", bond_dev[i].bond_key.key_mask);
- esp_log_buffer_hex(GATTS_TABLE_TAG, (void *)bond_dev[i].bd_addr, sizeof(esp_bd_addr_t));
- }
+ ESP_LOGD(GATTS_TABLE_TAG, "ESP_GAP_BLE_REMOVE_BOND_DEV_COMPLETE_EVT status = %d", param->remove_bond_dev_cmpl.status);
+ ESP_LOGI(GATTS_TABLE_TAG, "ESP_GAP_BLE_REMOVE_BOND_DEV");
+ ESP_LOGI(GATTS_TABLE_TAG, "-----ESP_GAP_BLE_REMOVE_BOND_DEV----");
+ esp_log_buffer_hex(GATTS_TABLE_TAG, (void *)param->remove_bond_dev_cmpl.bd_addr, sizeof(esp_bd_addr_t));
+ ESP_LOGI(GATTS_TABLE_TAG, "------------------------------------");
break;
}
case ESP_GAP_BLE_SET_LOCAL_PRIVACY_COMPLETE_EVT:
esp_ble_gap_set_security_param(ESP_BLE_SM_SET_INIT_KEY, &init_key, sizeof(uint8_t));
esp_ble_gap_set_security_param(ESP_BLE_SM_SET_RSP_KEY, &rsp_key, sizeof(uint8_t));
+ /* Just show how to clear all the bonded devices
+ * Delay 30s, clear all the bonded devices
+ *
+ * vTaskDelay(30000 / portTICK_PERIOD_MS);
+ * remove_all_bonded_devices();
+ */
}
projects / esp-idf / commitdiff