1 /*
2  * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
3  *
4  * SPDX-License-Identifier: Apache-2.0
5  */
6 
7 #include "common/bt_target.h"
8 #include <stdlib.h>
9 #include <string.h>
10 #include "btc/btc_common.h"
11 #include "btc/btc_dm.h"
12 #include "btc/btc_main.h"
13 #include "btc/btc_util.h"
14 #include "common/bt_trace.h"
15 #include "common/bt_target.h"
16 #include "btc/btc_storage.h"
17 #include "btc/btc_ble_storage.h"
18 #include "btc_gap_ble.h"
19 #include "btm_int.h"
20 #include "bta/bta_api.h"
21 #include "bta/bta_gatt_api.h"
22 #include "osi/allocator.h"
23 #include "btc/btc_manage.h"
24 
25 
26 #if (BTC_GAP_BT_INCLUDED == TRUE)
27 #include "btc_gap_bt.h"
28 #endif /* BTC_GAP_BT_INCLUDED == TRUE */
29 /******************************************************************************
30 **  Constants & Macros
31 ******************************************************************************/
32 #define BTA_SERVICE_ID_TO_SERVICE_MASK(id)       (1 << (id))
33 
34 /******************************************************************************
35 **  Static variables
36 ******************************************************************************/
37 #if BTC_DYNAMIC_MEMORY == FALSE
38 btc_dm_cb_t btc_dm_cb = {0};
39 #else
40 btc_dm_cb_t *btc_dm_cb_ptr;
41 #endif
42 
43 /******************************************************************************
44 **  Static functions
45 ******************************************************************************/
46 /******************************************************************************
47 **  Externs
48 ******************************************************************************/
49 #if BTC_AV_INCLUDED
50 extern bt_status_t btc_av_source_execute_service(BOOLEAN b_enable);
51 extern bt_status_t btc_av_sink_execute_service(BOOLEAN b_enable);
52 #endif
53 #if BTC_HF_INCLUDED
54 extern bt_status_t btc_hf_execute_service(BOOLEAN b_enable);
55 #endif
56 #if BTC_HF_CLIENT_INCLUDED
57 extern bt_status_t btc_hf_client_execute_service(BOOLEAN b_enable);
58 #endif
59 /******************************************************************************
60 **  Functions
61 ******************************************************************************/
btc_dm_sec_arg_deep_free(btc_msg_t * msg)62 static void btc_dm_sec_arg_deep_free(btc_msg_t *msg)
63 {
64     btc_dm_sec_args_t *arg = (btc_dm_sec_args_t *)(msg->arg);
65     if (msg->act == BTA_DM_BLE_KEY_EVT) {
66         osi_free(arg->sec.ble_key.p_key_value);
67     }
68 }
69 
btc_dm_sec_arg_deep_copy(btc_msg_t * msg,void * dst,void * src)70 void btc_dm_sec_arg_deep_copy(btc_msg_t *msg, void *dst, void *src)
71 {
72     tBTA_DM_SEC *dst_dm_sec = (tBTA_DM_SEC *)dst;
73     tBTA_DM_SEC *src_dm_sec = (tBTA_DM_SEC *)src;
74 
75     if (!src_dm_sec) {
76         return;
77     }
78 
79     assert(dst_dm_sec);
80     memcpy(dst_dm_sec, src_dm_sec, sizeof(tBTA_DM_SEC));
81 
82     if (msg->act == BTA_DM_BLE_KEY_EVT) {
83         dst_dm_sec->ble_key.p_key_value = osi_malloc(sizeof(tBTM_LE_KEY_VALUE));
84         assert(src_dm_sec->ble_key.p_key_value);
85         assert(dst_dm_sec->ble_key.p_key_value);
86         memcpy(dst_dm_sec->ble_key.p_key_value, src_dm_sec->ble_key.p_key_value, sizeof(tBTM_LE_KEY_VALUE));
87     }
88 }
89 
90 /*******************************************************************************
91 **
92 ** Function         btc_dm_evt
93 **
94 ** Description      Switches context from BTE to BTC for all DM events
95 **
96 ** Returns          void
97 **
98 *******************************************************************************/
99 
btc_dm_sec_evt(tBTA_DM_SEC_EVT event,tBTA_DM_SEC * data)100 void btc_dm_sec_evt(tBTA_DM_SEC_EVT event, tBTA_DM_SEC *data)
101 {
102     btc_msg_t msg = {0};
103 
104     msg.sig = BTC_SIG_API_CB;
105     msg.pid = BTC_PID_DM_SEC;
106     msg.act = event;
107 
108     btc_transfer_context(&msg, (btc_dm_sec_args_t *)data,
109                             data == NULL ? 0 : sizeof(btc_dm_sec_args_t),
110                             btc_dm_sec_arg_deep_copy, btc_dm_sec_arg_deep_free);
111 }
112 
btc_enable_bluetooth_evt(tBTA_STATUS status)113 static void btc_enable_bluetooth_evt(tBTA_STATUS status)
114 {
115     if (status == BTA_SUCCESS) {
116         future_ready(*btc_main_get_future_p(BTC_MAIN_ENABLE_FUTURE), FUTURE_SUCCESS);
117     } else {
118         future_ready(*btc_main_get_future_p(BTC_MAIN_ENABLE_FUTURE), FUTURE_FAIL);
119     }
120 }
121 
btc_disable_bluetooth_evt(void)122 static void btc_disable_bluetooth_evt(void)
123 {
124     BTC_TRACE_DEBUG("%s", __FUNCTION__);
125 
126     future_ready(*btc_main_get_future_p(BTC_MAIN_DISABLE_FUTURE), FUTURE_SUCCESS);
127 }
128 
129 #if (SMP_INCLUDED == TRUE)
130 #if (BLE_INCLUDED == TRUE)
btc_dm_load_ble_local_keys(void)131 void btc_dm_load_ble_local_keys(void)
132 {
133     memset(&btc_dm_cb.ble_local_key_cb, 0, sizeof(btc_dm_local_key_cb_t));
134 
135     if (btc_storage_get_ble_local_key(BTC_LE_LOCAL_KEY_ER,(char*)&btc_dm_cb.ble_local_key_cb.er[0],
136                                       BT_OCTET16_LEN)== BT_STATUS_SUCCESS) {
137         btc_dm_cb.ble_local_key_cb.is_er_rcvd = TRUE;
138         BTC_TRACE_DEBUG("%s BLE ER key loaded",__func__ );
139     }
140 
141     if ((btc_storage_get_ble_local_key(BTC_LE_LOCAL_KEY_IR,(char*)&btc_dm_cb.ble_local_key_cb.id_keys.ir[0],
142                                        BT_OCTET16_LEN)== BT_STATUS_SUCCESS )&&
143             (btc_storage_get_ble_local_key(BTC_LE_LOCAL_KEY_IRK, (char*)&btc_dm_cb.ble_local_key_cb.id_keys.irk[0],
144                                            BT_OCTET16_LEN)== BT_STATUS_SUCCESS)&&
145             (btc_storage_get_ble_local_key(BTC_LE_LOCAL_KEY_DHK,(char*)&btc_dm_cb.ble_local_key_cb.id_keys.dhk[0],
146                                            BT_OCTET16_LEN)== BT_STATUS_SUCCESS)) {
147         btc_dm_cb.ble_local_key_cb.is_id_keys_rcvd = TRUE;
148         BTC_TRACE_DEBUG("%s BLE ID keys loaded", __func__);
149     }
150 
151 }
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)152 void btc_dm_get_ble_local_keys(tBTA_DM_BLE_LOCAL_KEY_MASK *p_key_mask, BT_OCTET16 er,
153                                tBTA_BLE_LOCAL_ID_KEYS *p_id_keys)
154 {
155     if (btc_dm_cb.ble_local_key_cb.is_er_rcvd ) {
156         memcpy(&er[0], &btc_dm_cb.ble_local_key_cb.er[0], sizeof(BT_OCTET16));
157         *p_key_mask |= BTA_BLE_LOCAL_KEY_TYPE_ER;
158     }
159 
160     if (btc_dm_cb.ble_local_key_cb.is_id_keys_rcvd) {
161         memcpy(&p_id_keys->ir[0], &btc_dm_cb.ble_local_key_cb.id_keys.ir[0], sizeof(BT_OCTET16));
162         memcpy(&p_id_keys->irk[0],  &btc_dm_cb.ble_local_key_cb.id_keys.irk[0], sizeof(BT_OCTET16));
163         memcpy(&p_id_keys->dhk[0],  &btc_dm_cb.ble_local_key_cb.id_keys.dhk[0], sizeof(BT_OCTET16));
164         *p_key_mask |= BTA_BLE_LOCAL_KEY_TYPE_ID;
165     }
166     BTC_TRACE_DEBUG("%s  *p_key_mask=0x%02x",__func__,   *p_key_mask);
167 }
168 
169 
btc_dm_remove_ble_bonding_keys(void)170 static void btc_dm_remove_ble_bonding_keys(void)
171 {
172     bt_bdaddr_t bd_addr;
173     BTC_TRACE_DEBUG("%s\n",__func__);
174 
175     bdcpy(bd_addr.address, btc_dm_cb.pairing_cb.bd_addr);
176 
177     btc_storage_remove_gatt_cl_supp_feat(&bd_addr);
178     btc_storage_remove_gatt_db_hash(&bd_addr);
179     btc_storage_remove_remote_addr_type(&bd_addr, false);
180     btc_storage_remove_ble_dev_auth_mode(&bd_addr, false);
181     btc_storage_remove_ble_dev_type(&bd_addr, false);
182     btc_storage_remove_ble_bonding_keys(&bd_addr);
183 }
184 
185 #if BLE_SMP_BOND_NVS_FLASH
btc_dm_save_ble_bonding_keys(void)186 static void btc_dm_save_ble_bonding_keys(void)
187 {
188     if (!(btc_dm_cb.pairing_cb.ble.is_penc_key_rcvd || btc_dm_cb.pairing_cb.ble.is_pid_key_rcvd || btc_dm_cb.pairing_cb.ble.is_pcsrk_key_rcvd ||
189         btc_dm_cb.pairing_cb.ble.is_lenc_key_rcvd || btc_dm_cb.pairing_cb.ble.is_lcsrk_key_rcvd || btc_dm_cb.pairing_cb.ble.is_lidk_key_rcvd)) {
190         return;
191     }
192     bt_bdaddr_t bd_addr;
193 
194     bdcpy(bd_addr.address, btc_dm_cb.pairing_cb.bd_addr);
195 
196     btc_storage_set_ble_dev_type(&bd_addr, false);
197     BTC_TRACE_DEBUG("%s, penc = %d, pid = %d", __func__, btc_dm_cb.pairing_cb.ble.is_penc_key_rcvd, btc_dm_cb.pairing_cb.ble.is_pid_key_rcvd);
198     if (btc_dm_cb.pairing_cb.ble.is_penc_key_rcvd) {
199         btc_storage_add_ble_bonding_key(&bd_addr,
200                                         (char *) &btc_dm_cb.pairing_cb.ble.penc_key,
201                                         BTM_LE_KEY_PENC,
202                                         sizeof(tBTM_LE_PENC_KEYS));
203         btc_dm_cb.pairing_cb.ble.is_penc_key_rcvd = false;
204     }
205 
206     if (btc_dm_cb.pairing_cb.ble.is_pid_key_rcvd) {
207         btc_storage_add_ble_bonding_key(&bd_addr,
208                                         (char *) &btc_dm_cb.pairing_cb.ble.pid_key,
209                                         BTM_LE_KEY_PID,
210                                         sizeof(tBTM_LE_PID_KEYS));
211         btc_dm_cb.pairing_cb.ble.is_pid_key_rcvd = false;
212     }
213 
214 
215     if (btc_dm_cb.pairing_cb.ble.is_pcsrk_key_rcvd) {
216         btc_storage_add_ble_bonding_key(&bd_addr,
217                                         (char *) &btc_dm_cb.pairing_cb.ble.pcsrk_key,
218                                         BTM_LE_KEY_PCSRK,
219                                         sizeof(tBTM_LE_PCSRK_KEYS));
220         btc_dm_cb.pairing_cb.ble.is_pcsrk_key_rcvd = false;
221     }
222 
223 
224     if (btc_dm_cb.pairing_cb.ble.is_lenc_key_rcvd) {
225         btc_storage_add_ble_bonding_key(&bd_addr,
226                                         (char *) &btc_dm_cb.pairing_cb.ble.lenc_key,
227                                         BTM_LE_KEY_LENC,
228                                         sizeof(tBTM_LE_LENC_KEYS));
229         btc_dm_cb.pairing_cb.ble.is_lenc_key_rcvd = false;
230     }
231 
232     if (btc_dm_cb.pairing_cb.ble.is_lcsrk_key_rcvd) {
233         btc_storage_add_ble_bonding_key(&bd_addr,
234                                         (char *) &btc_dm_cb.pairing_cb.ble.lcsrk_key,
235                                         BTM_LE_KEY_LCSRK,
236                                         sizeof(tBTM_LE_LCSRK_KEYS));
237         btc_dm_cb.pairing_cb.ble.is_lcsrk_key_rcvd = false;
238     }
239 
240     if (btc_dm_cb.pairing_cb.ble.is_lidk_key_rcvd) {
241         btc_storage_add_ble_bonding_key(&bd_addr,
242                                         NULL,
243                                         BTM_LE_KEY_LID,
244                                         0);
245         btc_dm_cb.pairing_cb.ble.is_lidk_key_rcvd = false;
246     }
247 }
248 #endif
249 
btc_dm_ble_auth_cmpl_evt(tBTA_DM_AUTH_CMPL * p_auth_cmpl)250 static void btc_dm_ble_auth_cmpl_evt (tBTA_DM_AUTH_CMPL *p_auth_cmpl)
251 {
252     /* Save link key, if not temporary */
253     BTC_TRACE_DEBUG("%s, status = %d", __func__, p_auth_cmpl->success);
254     bt_status_t status = BT_STATUS_FAIL;
255     bt_bdaddr_t bdaddr;
256     bdcpy(bdaddr.address, p_auth_cmpl->bd_addr);
257     bdcpy(btc_dm_cb.pairing_cb.bd_addr, p_auth_cmpl->bd_addr);
258 
259     if (p_auth_cmpl->success) {
260         status = BT_STATUS_SUCCESS;
261         BTC_TRACE_DEBUG ("%s, -  p_auth_cmpl->bd_addr: %08x%04x", __func__,
262                              (p_auth_cmpl->bd_addr[0] << 24) + (p_auth_cmpl->bd_addr[1] << 16) + (p_auth_cmpl->bd_addr[2] << 8) + p_auth_cmpl->bd_addr[3],
263                              (p_auth_cmpl->bd_addr[4] << 8) + p_auth_cmpl->bd_addr[5]);
264 
265         // Check if need to save BLE keys
266         if((p_auth_cmpl->auth_mode & SMP_AUTH_GEN_BOND) == 0) {
267             return;
268         }
269 
270 #if BLE_SMP_BOND_NVS_FLASH
271         int addr_type;
272 
273         if (btc_dm_cb.pairing_cb.ble.is_pid_key_rcvd) {
274             // delete unused section in NVS
275             btc_storage_remove_unused_sections(p_auth_cmpl->bd_addr, &btc_dm_cb.pairing_cb.ble.pid_key);
276         }
277 
278         if (btc_storage_get_remote_addr_type(&bdaddr, &addr_type) != BT_STATUS_SUCCESS) {
279             btc_storage_set_remote_addr_type(&bdaddr, p_auth_cmpl->addr_type, true);
280         }
281         btc_storage_set_ble_dev_auth_mode(&bdaddr, p_auth_cmpl->auth_mode, true);
282         btc_dm_save_ble_bonding_keys();
283 #endif
284     } else {
285         /*Map the HCI fail reason  to  bt status  */
286         switch (p_auth_cmpl->fail_reason) {
287         case BTA_DM_AUTH_SMP_PAIR_AUTH_FAIL:
288         case BTA_DM_AUTH_SMP_CONFIRM_VALUE_FAIL:
289             btc_dm_remove_ble_bonding_keys();
290             status = BT_STATUS_AUTH_FAILURE;
291             break;
292         case BTA_DM_AUTH_SMP_PAIR_NOT_SUPPORT:
293             status = BT_STATUS_AUTH_REJECTED;
294             break;
295         default:
296             btc_dm_remove_ble_bonding_keys();
297             status =  BT_STATUS_FAIL;
298             break;
299         }
300 
301     }
302 
303 #if (CONFIG_BT_STACK_NO_LOG)
304     (void) status;
305 #endif
306     BTC_TRACE_DEBUG("%s, authentication status = %x", __func__, status);
307     return;
308 
309 }
310 #endif  ///BLE_INCLUDED == TRUE
311 #endif ///SMP_INCLUDED == TRUE
312 
btc_dm_link_up_evt(tBTA_DM_LINK_UP * p_link_up)313 static void btc_dm_link_up_evt(tBTA_DM_LINK_UP *p_link_up)
314 {
315     BD_ADDR bd_addr;
316     bt_bdaddr_t bt_bdaddr;
317 
318 
319     if (p_link_up->sc_downgrade == 1) {
320         memcpy(bt_bdaddr.address, p_link_up->bd_addr, sizeof(BD_ADDR));
321         if (btc_storage_remove_bonded_device(&bt_bdaddr) == BT_STATUS_SUCCESS) {
322             memcpy(bd_addr, p_link_up->bd_addr, sizeof(BD_ADDR));
323             if (BTA_DmRemoveDevice(bd_addr, BT_TRANSPORT_BR_EDR) == BTA_SUCCESS) {
324                 BTC_TRACE_EVENT(" %s() Bonding information removed.", __FUNCTION__);
325             } else {
326                 BTC_TRACE_ERROR(" %s() BTA_DmRemoveDevice error", __FUNCTION__);
327             }
328         } else {
329             BTC_TRACE_ERROR(" %s() btc_storage_remove_bonded_device error", __FUNCTION__);
330         }
331     }
332 }
333 
btc_dm_auth_cmpl_evt(tBTA_DM_AUTH_CMPL * p_auth_cmpl)334 static void btc_dm_auth_cmpl_evt (tBTA_DM_AUTH_CMPL *p_auth_cmpl)
335 {
336     /* Save link key, if not temporary */
337     bt_bdaddr_t bd_addr;
338     bt_status_t status;
339     BTC_TRACE_DEBUG("%s: bond state success %d, present %d, type%d\n", __func__, p_auth_cmpl->success,
340               p_auth_cmpl->key_present, p_auth_cmpl->key_type);
341 
342     bdcpy(bd_addr.address, p_auth_cmpl->bd_addr);
343     if ( (p_auth_cmpl->success == TRUE) && (p_auth_cmpl->key_present) ) {
344 #if 0
345         if ((p_auth_cmpl->key_type < HCI_LKEY_TYPE_DEBUG_COMB) ||
346                 (p_auth_cmpl->key_type == HCI_LKEY_TYPE_AUTH_COMB) ||
347                 (p_auth_cmpl->key_type == HCI_LKEY_TYPE_CHANGED_COMB) ||
348                 (p_auth_cmpl->key_type == HCI_LKEY_TYPE_AUTH_COMB_P_256)
349            )
350 #endif
351             if (1) {
352                 bt_status_t ret __attribute__((unused));
353                 BTC_TRACE_DEBUG("%s: Storing link key. key_type=0x%x",
354                           __FUNCTION__, p_auth_cmpl->key_type);
355                 ret = btc_storage_add_bonded_device(&bd_addr,
356                                                     p_auth_cmpl->key, p_auth_cmpl->key_type,
357                                                     16, p_auth_cmpl->sc_support);
358                 BTC_ASSERTC(ret == BT_STATUS_SUCCESS, "storing link key failed", ret);
359             } else {
360                 BTC_TRACE_DEBUG("%s: Temporary key. Not storing. key_type=0x%x",
361                           __FUNCTION__, p_auth_cmpl->key_type);
362             }
363     }
364 
365     // Skip SDP for certain  HID Devices
366     if (p_auth_cmpl->success) {
367         status = BT_STATUS_SUCCESS;
368     } else {
369         // Map the HCI fail reason  to  bt status
370         switch (p_auth_cmpl->fail_reason) {
371         case HCI_ERR_PAGE_TIMEOUT:
372             BTC_TRACE_WARNING("%s() - Pairing timeout; retrying () ...", __FUNCTION__);
373             return;
374         /* Fall-through */
375         case HCI_ERR_CONNECTION_TOUT:
376             status =  BT_STATUS_RMT_DEV_DOWN;
377             break;
378 
379         case HCI_ERR_PAIRING_NOT_ALLOWED:
380             status = BT_STATUS_AUTH_REJECTED;
381             break;
382 
383         case HCI_ERR_LMP_RESPONSE_TIMEOUT:
384             status =  BT_STATUS_AUTH_FAILURE;
385             break;
386 
387         /* map the auth failure codes, so we can retry pairing if necessary */
388         case HCI_ERR_AUTH_FAILURE:
389         case HCI_ERR_KEY_MISSING:
390             btc_storage_remove_bonded_device(&bd_addr);
391         case HCI_ERR_HOST_REJECT_SECURITY:
392         case HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE:
393         case HCI_ERR_UNIT_KEY_USED:
394         case HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED:
395         case HCI_ERR_INSUFFCIENT_SECURITY:
396         case HCI_ERR_PEER_USER:
397         case HCI_ERR_UNSPECIFIED:
398             BTC_TRACE_ERROR(" %s() Authentication fail reason %d",
399                       __FUNCTION__, p_auth_cmpl->fail_reason);
400             /* if autopair attempts are more than 1, or not attempted */
401             status =  BT_STATUS_AUTH_FAILURE;
402             break;
403         default:
404             status =  BT_STATUS_FAIL;
405             break;
406         }
407     }
408 #if (BTC_GAP_BT_INCLUDED == TRUE)
409     esp_bt_gap_cb_param_t param;
410     bt_status_t ret;
411     btc_msg_t *msg;
412 
413     msg = (btc_msg_t *)osi_malloc(sizeof(btc_msg_t) + sizeof(esp_bt_gap_cb_param_t));
414     if (msg == NULL) {
415         BTC_TRACE_ERROR("%s malloc fail", __func__);
416         return;
417     }
418     msg->sig = BTC_SIG_API_CB;
419     msg->pid = BTC_PID_GAP_BT;
420     msg->act = BTC_GAP_BT_AUTH_CMPL_EVT;
421     param.auth_cmpl.stat = status;
422     memcpy(param.auth_cmpl.bda, p_auth_cmpl->bd_addr, ESP_BD_ADDR_LEN);
423     memcpy(param.auth_cmpl.device_name, p_auth_cmpl->bd_name, ESP_BT_GAP_MAX_BDNAME_LEN + 1);
424     memcpy(msg->arg, &param, sizeof(esp_bt_gap_cb_param_t));
425 
426     ret = btc_inter_profile_call(msg);
427     osi_free(msg);
428 
429     if (ret != BT_STATUS_SUCCESS) {
430         BTC_TRACE_ERROR("%s btc_inter_profile_call failed\n", __func__);
431     }
432 
433 #endif /// BTC_GAP_BT_INCLUDED == TRUE
434     (void) status;
435 }
436 
btc_dm_pin_req_evt(tBTA_DM_PIN_REQ * p_pin_req)437 static void btc_dm_pin_req_evt(tBTA_DM_PIN_REQ *p_pin_req)
438 {
439 #if (BTC_GAP_BT_INCLUDED == TRUE)
440     esp_bt_gap_cb_param_t param;
441     bt_status_t ret;
442     btc_msg_t *msg;
443 
444     msg = (btc_msg_t *)osi_malloc(sizeof(btc_msg_t) + sizeof(esp_bt_gap_cb_param_t));
445     if (msg == NULL) {
446         BTC_TRACE_ERROR("%s malloc fail", __func__);
447         return;
448     }
449     msg->sig = BTC_SIG_API_CB;
450     msg->pid = BTC_PID_GAP_BT;
451     msg->act = BTC_GAP_BT_PIN_REQ_EVT;
452     param.pin_req.min_16_digit = p_pin_req->min_16_digit;
453     memcpy(param.pin_req.bda, p_pin_req->bd_addr, ESP_BD_ADDR_LEN);
454     memcpy(msg->arg, &param, sizeof(esp_bt_gap_cb_param_t));
455 
456     ret = btc_inter_profile_call(msg);
457     osi_free(msg);
458 
459     if (ret != BT_STATUS_SUCCESS) {
460         BTC_TRACE_ERROR("%s btc_inter_profile_call failed\n", __func__);
461     }
462 #endif /// BTC_GAP_BT_INCLUDED == TRUE
463 }
464 
465 #if (BT_SSP_INCLUDED == TRUE)
btc_dm_sp_cfm_req_evt(tBTA_DM_SP_CFM_REQ * p_cfm_req)466 static void btc_dm_sp_cfm_req_evt(tBTA_DM_SP_CFM_REQ *p_cfm_req)
467 {
468 #if (BTC_GAP_BT_INCLUDED == TRUE)
469     if (p_cfm_req->just_works) {
470         // just work, not show to users.
471         BTA_DmConfirm(p_cfm_req->bd_addr, true);
472         return;
473     }
474 
475     esp_bt_gap_cb_param_t param;
476     bt_status_t ret;
477     btc_msg_t *msg;
478 
479     msg = (btc_msg_t *)osi_malloc(sizeof(btc_msg_t) + sizeof(esp_bt_gap_cb_param_t));
480     if (msg == NULL) {
481         BTC_TRACE_ERROR("%s malloc fail", __func__);
482         return;
483     }
484     msg->sig = BTC_SIG_API_CB;
485     msg->pid = BTC_PID_GAP_BT;
486     msg->act = BTC_GAP_BT_CFM_REQ_EVT;
487     param.cfm_req.num_val = p_cfm_req->num_val;
488     memcpy(param.cfm_req.bda, p_cfm_req->bd_addr, ESP_BD_ADDR_LEN);
489     memcpy(msg->arg, &param, sizeof(esp_bt_gap_cb_param_t));
490 
491     ret = btc_inter_profile_call(msg);
492     osi_free(msg);
493 
494     if (ret != BT_STATUS_SUCCESS) {
495         BTC_TRACE_ERROR("%s btc_inter_profile_call failed\n", __func__);
496     }
497 #endif /// BTC_GAP_BT_INCLUDED == TRUE
498 }
499 
btc_dm_sp_key_notif_evt(tBTA_DM_SP_KEY_NOTIF * p_key_notif)500 static void btc_dm_sp_key_notif_evt(tBTA_DM_SP_KEY_NOTIF *p_key_notif)
501 {
502 #if (BTC_GAP_BT_INCLUDED == TRUE)
503     esp_bt_gap_cb_param_t param;
504     bt_status_t ret;
505     btc_msg_t *msg;
506 
507     msg = (btc_msg_t *)osi_malloc(sizeof(btc_msg_t) + sizeof(esp_bt_gap_cb_param_t));
508     if (msg == NULL) {
509         BTC_TRACE_ERROR("%s malloc fail", __func__);
510         return;
511     }
512     msg->sig = BTC_SIG_API_CB;
513     msg->pid = BTC_PID_GAP_BT;
514     msg->act = BTC_GAP_BT_KEY_NOTIF_EVT;
515     param.key_notif.passkey = p_key_notif->passkey;
516     memcpy(param.key_notif.bda, p_key_notif->bd_addr, ESP_BD_ADDR_LEN);
517     memcpy(msg->arg, &param, sizeof(esp_bt_gap_cb_param_t));
518 
519     ret = btc_inter_profile_call(msg);
520     osi_free(msg);
521 
522     if (ret != BT_STATUS_SUCCESS) {
523         BTC_TRACE_ERROR("%s btc_inter_profile_call failed\n", __func__);
524     }
525 #endif /// BTC_GAP_BT_INCLUDED == TRUE
526 }
527 
btc_dm_sp_key_req_evt(tBTA_DM_SP_KEY_REQ * p_key_req)528 static void btc_dm_sp_key_req_evt(tBTA_DM_SP_KEY_REQ *p_key_req)
529 {
530 #if (BTC_GAP_BT_INCLUDED == TRUE)
531     esp_bt_gap_cb_param_t param;
532     bt_status_t ret;
533     btc_msg_t *msg;
534 
535     msg = (btc_msg_t *)osi_malloc(sizeof(btc_msg_t) + sizeof(esp_bt_gap_cb_param_t));
536     if (msg == NULL) {
537         BTC_TRACE_ERROR("%s malloc fail", __func__);
538         return;
539     }
540     msg->sig = BTC_SIG_API_CB;
541     msg->pid = BTC_PID_GAP_BT;
542     msg->act = BTC_GAP_BT_KEY_REQ_EVT;
543     memcpy(param.key_req.bda, p_key_req->bd_addr, ESP_BD_ADDR_LEN);
544     memcpy(msg->arg, &param, sizeof(esp_bt_gap_cb_param_t));
545 
546     ret = btc_inter_profile_call(msg);
547     osi_free(msg);
548 
549     if (ret != BT_STATUS_SUCCESS) {
550         BTC_TRACE_ERROR("%s btc_inter_profile_call failed\n", __func__);
551     }
552 #endif /// BTC_GAP_BT_INCLUDED == TRUE
553 }
554 #endif /// BT_SSP_INCLUDED == TRUE
555 
btc_dm_dev_unpaired_evt(tBTA_DM_LINK_DOWN * p_link_down)556 static void btc_dm_dev_unpaired_evt(tBTA_DM_LINK_DOWN *p_link_down)
557 {
558     esp_bt_gap_cb_param_t param;
559     BTC_TRACE_DEBUG("%s",__func__);
560     memcpy(param.remove_bond_dev_cmpl.bda, p_link_down->bd_addr, ESP_BD_ADDR_LEN);
561     btm_set_bond_type_dev(p_link_down->bd_addr, BOND_TYPE_UNKNOWN);
562     if (p_link_down->status == HCI_SUCCESS) {
563         //remove the bonded key in the config and nvs flash.
564         param.remove_bond_dev_cmpl.status = btc_storage_remove_bonded_device((bt_bdaddr_t *)param.remove_bond_dev_cmpl.bda);
565     } else {
566         param.remove_bond_dev_cmpl.status = ESP_BT_STATUS_FAIL;
567     }
568 
569 #if (BTC_GAP_BT_INCLUDED == TRUE)
570     bt_status_t ret;
571     btc_msg_t *msg;
572 
573     msg = (btc_msg_t *)osi_malloc(sizeof(btc_msg_t) + sizeof(esp_bt_gap_cb_param_t));
574     if (msg == NULL) {
575         BTC_TRACE_ERROR("%s malloc fail", __func__);
576         return;
577     }
578     msg->sig = BTC_SIG_API_CB;
579     msg->pid = BTC_PID_GAP_BT;
580     msg->act = BTC_GAP_BT_REMOVE_BOND_DEV_COMPLETE_EVT;
581     memcpy(msg->arg, &param, sizeof(esp_bt_gap_cb_param_t));
582 
583     ret = btc_inter_profile_call(msg);
584     osi_free(msg);
585 
586     if (ret != BT_STATUS_SUCCESS) {
587         BTC_TRACE_ERROR("%s btc_inter_profile_call failed\n", __func__);
588     }
589 #endif /// BTC_GAP_BT_INCLUDED == TRUE
590 }
591 
592 
593 #if (BTC_DM_PM_INCLUDED == TRUE)
btc_dm_pm_mode_chg_evt(tBTA_DM_MODE_CHG * p_mode_chg)594 static void btc_dm_pm_mode_chg_evt(tBTA_DM_MODE_CHG *p_mode_chg)
595 {
596     esp_bt_gap_cb_param_t param;
597     bt_status_t ret;
598     btc_msg_t *msg;
599 
600     msg = (btc_msg_t *)osi_malloc(sizeof(btc_msg_t) + sizeof(esp_bt_gap_cb_param_t));
601     if (msg == NULL) {
602         BTC_TRACE_ERROR("%s malloc fail", __func__);
603         return;
604     }
605     msg->sig = BTC_SIG_API_CB;
606     msg->pid = BTC_PID_GAP_BT;
607     msg->act = BTC_GAP_BT_MODE_CHG_EVT;
608     memcpy(param.mode_chg.bda, p_mode_chg->bd_addr, ESP_BD_ADDR_LEN);
609     param.mode_chg.mode = p_mode_chg->mode;
610     param.mode_chg.interval= p_mode_chg->interval;
611     memcpy(msg->arg, &param, sizeof(esp_bt_gap_cb_param_t));
612 
613     ret = btc_inter_profile_call(msg);
614     osi_free(msg);
615 
616     if (ret != BT_STATUS_SUCCESS) {
617         BTC_TRACE_ERROR("%s btc_inter_profile_call failed\n", __func__);
618     }
619 }
620 #endif /// BTC_DM_PM_INCLUDED == TRUE
621 
btc_get_enabled_services_mask(void)622 tBTA_SERVICE_MASK btc_get_enabled_services_mask(void)
623 {
624     return btc_dm_cb.btc_enabled_services;
625 }
626 
btc_clear_services_mask(void)627 void btc_clear_services_mask(void)
628 {
629     btc_dm_cb.btc_enabled_services = 0;
630 }
631 
btc_in_execute_service_request(tBTA_SERVICE_ID service_id,BOOLEAN b_enable)632 static bt_status_t btc_in_execute_service_request(tBTA_SERVICE_ID service_id,
633         BOOLEAN b_enable)
634 {
635     BTC_TRACE_DEBUG("%s service_id: %d\n", __FUNCTION__, service_id);
636     /* Check the service_ID and invoke the profile's BT state changed API */
637     switch (service_id) {
638 #if BTC_AV_INCLUDED
639     case BTA_A2DP_SOURCE_SERVICE_ID:
640         btc_av_source_execute_service(b_enable);
641         break;
642     case BTA_A2DP_SINK_SERVICE_ID:
643         btc_av_sink_execute_service(b_enable);
644         break;
645 #endif
646 #if BTC_HF_INCLUDED
647     case BTA_HFP_SERVICE_ID:
648         btc_hf_execute_service(b_enable);
649         break;
650 #endif /* #if BTC_HF_INCLUDED */
651 #if BTC_HF_CLIENT_INCLUDED
652     case BTA_HFP_HS_SERVICE_ID:
653         btc_hf_client_execute_service(b_enable);
654         break;
655 #endif /* #if BTC_HF_CLIENT_INCLUDED */
656     default:
657         BTC_TRACE_ERROR("%s: Unknown service being enabled\n", __FUNCTION__);
658         return BT_STATUS_FAIL;
659     }
660     return BT_STATUS_SUCCESS;
661 }
662 
btc_dm_execute_service_request(BOOLEAN enable,char * p_param)663 void btc_dm_execute_service_request(BOOLEAN enable, char *p_param)
664 {
665     btc_in_execute_service_request(*((tBTA_SERVICE_ID *)p_param), enable);
666 }
667 
btc_dm_enable_service(tBTA_SERVICE_ID service_id)668 bt_status_t btc_dm_enable_service(tBTA_SERVICE_ID service_id)
669 {
670     tBTA_SERVICE_ID *p_id = &service_id;
671 
672     btc_dm_cb.btc_enabled_services |= (1 << service_id);
673 
674     BTC_TRACE_DEBUG("%s: current services:0x%x", __FUNCTION__, btc_dm_cb.btc_enabled_services);
675 
676     btc_dm_execute_service_request(TRUE, (char *)p_id);
677 
678     return BT_STATUS_SUCCESS;
679 }
680 
btc_dm_disable_service(tBTA_SERVICE_ID service_id)681 bt_status_t btc_dm_disable_service(tBTA_SERVICE_ID service_id)
682 {
683     tBTA_SERVICE_ID *p_id = &service_id;
684 
685     btc_dm_cb.btc_enabled_services &= (tBTA_SERVICE_MASK)(~(1 << service_id));
686 
687     BTC_TRACE_DEBUG("%s: Current Services:0x%x", __FUNCTION__, btc_dm_cb.btc_enabled_services);
688 
689     btc_dm_execute_service_request(FALSE, (char *)p_id);
690 
691     return BT_STATUS_SUCCESS;
692 }
693 
btc_dm_acl_link_stat(tBTA_DM_ACL_LINK_STAT * p_acl_link_stat)694 static void btc_dm_acl_link_stat(tBTA_DM_ACL_LINK_STAT *p_acl_link_stat)
695 {
696 #if (BTC_GAP_BT_INCLUDED == TRUE)
697     esp_bt_gap_cb_param_t param;
698     esp_bt_gap_cb_event_t event = ESP_BT_GAP_EVT_MAX;
699     bt_bdaddr_t bt_addr;
700 
701     switch (p_acl_link_stat->event) {
702     case BTA_ACL_LINK_STAT_CONN_CMPL: {
703         event = ESP_BT_GAP_ACL_CONN_CMPL_STAT_EVT;
704         param.acl_conn_cmpl_stat.stat = btc_hci_to_esp_status(p_acl_link_stat->link_act.conn_cmpl.status);
705         param.acl_conn_cmpl_stat.handle = p_acl_link_stat->link_act.conn_cmpl.handle;
706         memcpy(param.acl_conn_cmpl_stat.bda, p_acl_link_stat->link_act.conn_cmpl.bd_addr, ESP_BD_ADDR_LEN);
707         break;
708     }
709     case BTA_ACL_LINK_STAT_DISCONN_CMPL: {
710         event = ESP_BT_GAP_ACL_DISCONN_CMPL_STAT_EVT;
711         param.acl_disconn_cmpl_stat.reason = btc_hci_to_esp_status(p_acl_link_stat->link_act.disconn_cmpl.reason);
712         param.acl_disconn_cmpl_stat.handle = p_acl_link_stat->link_act.disconn_cmpl.handle;
713         memcpy(param.acl_disconn_cmpl_stat.bda, p_acl_link_stat->link_act.disconn_cmpl.bd_addr, ESP_BD_ADDR_LEN);
714         break;
715     }
716     default: {
717         BTC_TRACE_WARNING("%s: invalid event %x", __FUNCTION__, event);
718         return;
719     }
720     }
721 
722 #if (SMP_INCLUDED == TRUE)
723     if (p_acl_link_stat->event == BTA_ACL_LINK_STAT_CONN_CMPL &&
724         p_acl_link_stat->link_act.conn_cmpl.status == HCI_SUCCESS) {
725         memcpy(bt_addr.address, p_acl_link_stat->link_act.conn_cmpl.bd_addr, sizeof(bt_addr.address));
726         if (btc_storage_update_active_device(&bt_addr)) {
727             BTC_TRACE_EVENT("Device: %02x:%02x:%02x:%02x:%02x:%02x, is not in bond list",
728                             bt_addr.address[0], bt_addr.address[1],
729                             bt_addr.address[2], bt_addr.address[3],
730                             bt_addr.address[4], bt_addr.address[5]);
731         }
732     }
733 #endif  ///SMP_INCLUDED == TRUE
734     esp_bt_gap_cb_t cb = (esp_bt_gap_cb_t)btc_profile_cb_get(BTC_PID_GAP_BT);
735     if (cb) {
736         cb(event, &param);
737     }
738 #endif
739 }
740 
btc_dm_sec_cb_handler(btc_msg_t * msg)741 void btc_dm_sec_cb_handler(btc_msg_t *msg)
742 {
743     btc_dm_sec_args_t *arg = (btc_dm_sec_args_t *)(msg->arg);
744     tBTA_DM_SEC *p_data = &(arg->sec);
745     esp_ble_gap_cb_param_t param = {0};
746     btc_msg_t *ble_msg;
747     bool rsp_app = false;
748     bt_status_t ret = BT_STATUS_SUCCESS;
749 
750     ble_msg = (btc_msg_t *)osi_malloc(sizeof(btc_msg_t) + sizeof(esp_ble_gap_cb_param_t));
751     if (ble_msg == NULL) {
752         BTC_TRACE_ERROR("%s malloc fail", __func__);
753         btc_dm_sec_arg_deep_free(msg);
754         return;
755     }
756     ble_msg->sig = BTC_SIG_API_CB;
757     ble_msg->pid = BTC_PID_GAP_BLE;
758     // tBTA_SERVICE_MASK service_mask;
759     BTC_TRACE_DEBUG("btc_dm_upstreams_cback  ev: %d\n", msg->act);
760 
761     switch (msg->act) {
762     case BTA_DM_ENABLE_EVT: {
763         btc_clear_services_mask();
764 #if (SMP_INCLUDED == TRUE)
765 #if (BLE_INCLUDED == TRUE)
766         btc_storage_delete_duplicate_ble_devices();
767 #endif ///BLE_INCLUDED == TRUE
768         //load the bonding device to the btm layer
769         btc_storage_load_bonded_devices();
770 #endif  ///SMP_INCLUDED == TRUE
771 
772         /* Set initial device name, it can be overwritten later */
773         if (p_data->enable.status == BTA_SUCCESS) {
774             const char *initial_device_name = "ESP32";
775             BTA_DmSetDeviceName(initial_device_name);
776         }
777         btc_enable_bluetooth_evt(p_data->enable.status);
778         break;
779     }
780     case BTA_DM_DISABLE_EVT: {
781         tBTA_SERVICE_MASK service_mask = btc_get_enabled_services_mask();
782         for (int i = 0; i <= BTA_MAX_SERVICE_ID; i++) {
783             if (service_mask &
784                     (tBTA_SERVICE_MASK)(BTA_SERVICE_ID_TO_SERVICE_MASK(i))) {
785                 btc_in_execute_service_request(i, FALSE);
786             }
787         }
788         btc_disable_bluetooth_evt();
789         break;
790     }
791     case BTA_DM_PIN_REQ_EVT:
792         BTC_TRACE_DEBUG("BTA_DM_PIN_REQ_EVT");
793         btc_dm_pin_req_evt(&p_data->pin_req);
794         break;
795     case BTA_DM_AUTH_CMPL_EVT:
796         btc_dm_auth_cmpl_evt(&p_data->auth_cmpl);
797         break;
798     case BTA_DM_BOND_CANCEL_CMPL_EVT:
799         BTC_TRACE_DEBUG("BTA_DM_BOND_CANCEL_CMPL_EVT");
800         break;
801 #if (BT_SSP_INCLUDED == TRUE)
802     case BTA_DM_SP_CFM_REQ_EVT:
803         btc_dm_sp_cfm_req_evt(&p_data->cfm_req);
804         break;
805     case BTA_DM_SP_KEY_NOTIF_EVT:
806         btc_dm_sp_key_notif_evt(&p_data->key_notif);
807         break;
808     case BTA_DM_SP_KEY_REQ_EVT:
809         btc_dm_sp_key_req_evt(&p_data->key_req);
810         break;
811     case BTA_DM_SP_RMT_OOB_EVT:
812         BTC_TRACE_DEBUG("BTA_DM_SP_RMT_OOB_EVT");
813         break;
814     case BTA_DM_SP_KEYPRESS_EVT:
815         BTC_TRACE_DEBUG("BTA_DM_SP_KEYPRESS_EVT");
816         break;
817 #endif ///BT_SSP_INCLUDED == TRUE
818 
819     case BTA_DM_ACL_LINK_STAT_EVT: {
820         btc_dm_acl_link_stat(&p_data->acl_link_stat);
821         break;
822     }
823     case BTA_DM_DEV_UNPAIRED_EVT: {
824         btc_dm_dev_unpaired_evt(&p_data->link_down);
825         break;
826     }
827 #if (BLE_INCLUDED == TRUE)
828     case BTA_DM_BLE_DEV_UNPAIRED_EVT: {
829 #if (SMP_INCLUDED == TRUE)
830         bt_bdaddr_t bd_addr;
831         rsp_app = true;
832         BTC_TRACE_DEBUG("BTA_DM_BLE_DEV_UNPAIRED_EVT");
833         memcpy(bd_addr.address, p_data->link_down.bd_addr, sizeof(BD_ADDR));
834         btm_set_bond_type_dev(p_data->link_down.bd_addr, BOND_TYPE_UNKNOWN);
835         param.remove_bond_dev_cmpl.status = ESP_BT_STATUS_FAIL;
836 
837         if (p_data->link_down.status == HCI_SUCCESS) {
838             //remove the bonded key in the config and nvs flash.
839             btc_storage_remove_gatt_cl_supp_feat(&bd_addr);
840             btc_storage_remove_gatt_db_hash(&bd_addr);
841             btc_storage_remove_ble_dev_type(&bd_addr, false);
842             btc_storage_remove_remote_addr_type(&bd_addr, false);
843             btc_storage_remove_ble_dev_auth_mode(&bd_addr, false);
844             param.remove_bond_dev_cmpl.status = btc_storage_remove_ble_bonding_keys(&bd_addr);
845         }
846         ble_msg->act = ESP_GAP_BLE_REMOVE_BOND_DEV_COMPLETE_EVT;
847         memcpy(param.remove_bond_dev_cmpl.bd_addr, p_data->link_down.bd_addr, sizeof(BD_ADDR));
848 #endif /* #if (SMP_INCLUDED == TRUE) */
849         break;
850     }
851 #endif  ///BLE_INCLUDED == TRUE
852     case BTA_DM_BUSY_LEVEL_EVT:
853 #if (BTC_GAP_BT_INCLUDED == TRUE)
854         {
855         if (p_data->busy_level.level_flags & BTM_BL_INQUIRY_PAGING_MASK) {
856             btc_gap_bt_busy_level_updated(p_data->busy_level.level_flags);
857         }
858         break;
859         }
860 #endif /* BTC_GAP_BT_INCLUDED  == TRUE */
861     case BTA_DM_LINK_DOWN_EVT:
862     case BTA_DM_HW_ERROR_EVT:
863         BTC_TRACE_DEBUG( "btc_dm_sec_cback : unhandled event (%d)\n", msg->act );
864         break;
865     case BTA_DM_LINK_UP_EVT:
866         btc_dm_link_up_evt(&p_data->link_up);
867         break;
868 #if ((BLE_INCLUDED == TRUE) && (SMP_INCLUDED == TRUE))
869     case BTA_DM_BLE_AUTH_CMPL_EVT: {
870         rsp_app = true;
871         ble_msg->act = ESP_GAP_BLE_AUTH_CMPL_EVT;
872         param.ble_security.auth_cmpl.addr_type = p_data->auth_cmpl.addr_type;
873         param.ble_security.auth_cmpl.dev_type = p_data->auth_cmpl.dev_type;
874         param.ble_security.auth_cmpl.key_type = p_data->auth_cmpl.key_type;
875         param.ble_security.auth_cmpl.fail_reason = p_data->auth_cmpl.fail_reason;
876         param.ble_security.auth_cmpl.success = p_data->auth_cmpl.success ? true : false;
877         param.ble_security.auth_cmpl.key_present = p_data->auth_cmpl.key_present;
878         memcpy(param.ble_security.auth_cmpl.bd_addr, p_data->auth_cmpl.bd_addr, sizeof(BD_ADDR));
879         memcpy(param.ble_security.auth_cmpl.key, p_data->auth_cmpl.key, sizeof(LINK_KEY));
880         param.ble_security.auth_cmpl.auth_mode = p_data->auth_cmpl.auth_mode;
881         btc_dm_ble_auth_cmpl_evt(&p_data->auth_cmpl);
882         break;
883     }
884     case BTA_DM_BLE_KEY_EVT: {
885         rsp_app = true;
886         ble_msg->act = ESP_GAP_BLE_KEY_EVT;
887         param.ble_security.ble_key.key_type = p_data->ble_key.key_type;
888         memcpy(param.ble_security.ble_key.bd_addr, p_data->ble_key.bd_addr, BD_ADDR_LEN);
889         switch (p_data->ble_key.key_type) {
890             case BTM_LE_KEY_PENC: {
891                 BTC_TRACE_DEBUG("Rcv BTA_LE_KEY_PENC");
892                 btc_dm_cb.pairing_cb.ble.is_penc_key_rcvd = TRUE;
893                 btc_dm_cb.pairing_cb.ble.penc_key = p_data->ble_key.p_key_value->penc_key;
894                 memcpy(&btc_dm_cb.pairing_cb.ble.penc_key, &p_data->ble_key.p_key_value->penc_key,
895                              sizeof(tBTM_LE_PENC_KEYS));
896                 memcpy(&param.ble_security.ble_key.p_key_value.penc_key,
897                              &p_data->ble_key.p_key_value->penc_key, sizeof(tBTM_LE_PENC_KEYS));
898                 break;
899             }
900             case BTM_LE_KEY_PID: {
901                 BTC_TRACE_DEBUG("Rcv BTA_LE_KEY_PID");
902                 btc_dm_cb.pairing_cb.ble.is_pid_key_rcvd = TRUE;
903                 memcpy(&btc_dm_cb.pairing_cb.ble.pid_key, &p_data->ble_key.p_key_value->pid_key,
904                             sizeof(tBTM_LE_PID_KEYS));
905                 //Note: The memory size of the addr_type in ble_security.ble_key.p_key_value.pid_key is different from that of p_data->ble_key.p_key_value->pid_key.
906                 memcpy(&param.ble_security.ble_key.p_key_value.pid_key.irk,
907                              &p_data->ble_key.p_key_value->pid_key.irk, ESP_BT_OCTET16_LEN);
908                 param.ble_security.ble_key.p_key_value.pid_key.addr_type = p_data->ble_key.p_key_value->pid_key.addr_type;
909                 memcpy(&param.ble_security.ble_key.p_key_value.pid_key.static_addr,
910                              &p_data->ble_key.p_key_value->pid_key.static_addr, ESP_BD_ADDR_LEN);
911                 break;
912             }
913             case BTM_LE_KEY_PCSRK: {
914                 BTC_TRACE_DEBUG("Rcv BTA_LE_KEY_PCSRK");
915                 btc_dm_cb.pairing_cb.ble.is_pcsrk_key_rcvd = TRUE;
916                 memcpy(&btc_dm_cb.pairing_cb.ble.pcsrk_key, &p_data->ble_key.p_key_value->pcsrk_key,
917                              sizeof(tBTM_LE_PCSRK_KEYS));
918                 memcpy(&param.ble_security.ble_key.p_key_value.pcsrk_key,
919                              &p_data->ble_key.p_key_value->pcsrk_key, sizeof(tBTM_LE_PCSRK_KEYS));
920                 break;
921             }
922             case BTM_LE_KEY_LENC: {
923                 BTC_TRACE_DEBUG("Rcv BTA_LE_KEY_LENC");
924                 btc_dm_cb.pairing_cb.ble.is_lenc_key_rcvd = TRUE;
925                 memcpy(&btc_dm_cb.pairing_cb.ble.lenc_key, &p_data->ble_key.p_key_value->lenc_key,
926                             sizeof(tBTM_LE_LENC_KEYS));
927                 memcpy(&param.ble_security.ble_key.p_key_value.lenc_key,
928                              &p_data->ble_key.p_key_value->lenc_key, sizeof(tBTM_LE_LENC_KEYS));
929                 break;
930             }
931             case BTM_LE_KEY_LCSRK: {
932                 BTC_TRACE_DEBUG("Rcv BTA_LE_KEY_LCSRK");
933                 btc_dm_cb.pairing_cb.ble.is_lcsrk_key_rcvd = TRUE;
934                 memcpy(&btc_dm_cb.pairing_cb.ble.lcsrk_key, &p_data->ble_key.p_key_value->lcsrk_key,
935                             sizeof(tBTM_LE_LCSRK_KEYS));
936                 memcpy(&param.ble_security.ble_key.p_key_value.lcsrk_key,
937                              &p_data->ble_key.p_key_value->lcsrk_key, sizeof(tBTM_LE_LCSRK_KEYS));
938                 break;
939             }
940             case BTM_LE_KEY_LID: {
941                 BTC_TRACE_DEBUG("Rcv BTA_LE_KEY_LID");
942                 btc_dm_cb.pairing_cb.ble.is_lidk_key_rcvd =  TRUE;
943                 break;
944             }
945             default:
946                 break;
947         }
948 
949         break;
950     }
951     case BTA_DM_BLE_SEC_REQ_EVT: {
952         rsp_app = true;
953         ble_msg->act = ESP_GAP_BLE_SEC_REQ_EVT;
954         memcpy(param.ble_security.ble_req.bd_addr, p_data->ble_req.bd_addr, BD_ADDR_LEN);
955         break;
956     }
957     case BTA_DM_BLE_PASSKEY_NOTIF_EVT: {
958         rsp_app = true;
959         ble_msg->act = ESP_GAP_BLE_PASSKEY_NOTIF_EVT;
960         param.ble_security.key_notif.passkey = p_data->key_notif.passkey;
961         memcpy(param.ble_security.key_notif.bd_addr, p_data->ble_req.bd_addr, BD_ADDR_LEN);
962         break;
963     }
964     case BTA_DM_BLE_PASSKEY_REQ_EVT: {
965         rsp_app = true;
966         ble_msg->act = ESP_GAP_BLE_PASSKEY_REQ_EVT;
967         memcpy(param.ble_security.ble_req.bd_addr, p_data->ble_req.bd_addr, BD_ADDR_LEN);
968         break;
969     }
970     case BTA_DM_BLE_OOB_REQ_EVT: {
971         rsp_app = true;
972         ble_msg->act = ESP_GAP_BLE_OOB_REQ_EVT;
973         memcpy(param.ble_security.ble_req.bd_addr, p_data->ble_req.bd_addr, BD_ADDR_LEN);
974         break;
975     }
976     case BTA_DM_BLE_SC_OOB_REQ_EVT: {
977         rsp_app = true;
978         ble_msg->act = ESP_GAP_BLE_SC_OOB_REQ_EVT;
979         memcpy(param.ble_security.ble_req.bd_addr, p_data->ble_req.bd_addr, BD_ADDR_LEN);
980         break;
981     }
982     case BTA_DM_BLE_SC_CR_LOC_OOB_EVT: {
983         rsp_app = true;
984         ble_msg->act = ESP_GAP_BLE_SC_CR_LOC_OOB_EVT;
985         memcpy(param.ble_security.oob_data.oob_c, p_data->local_oob_data.local_oob_c, BT_OCTET16_LEN);
986         memcpy(param.ble_security.oob_data.oob_r, p_data->local_oob_data.local_oob_r, BT_OCTET16_LEN);
987         break;
988     }
989     case BTA_DM_BLE_LOCAL_IR_EVT: {
990         rsp_app = true;
991         ble_msg->act = ESP_GAP_BLE_LOCAL_IR_EVT;
992         memcpy(&param.ble_security.ble_id_keys, &p_data->ble_id_keys, sizeof(tBTA_BLE_LOCAL_ID_KEYS));
993         BTC_TRACE_DEBUG("BTA_DM_BLE_LOCAL_IR_EVT. ");
994         btc_dm_cb.ble_local_key_cb.is_id_keys_rcvd = TRUE;
995         memcpy(&btc_dm_cb.ble_local_key_cb.id_keys.irk[0],
996                &p_data->ble_id_keys.irk[0], sizeof(BT_OCTET16));
997         memcpy(&btc_dm_cb.ble_local_key_cb.id_keys.ir[0],
998                &p_data->ble_id_keys.ir[0], sizeof(BT_OCTET16));
999         memcpy(&btc_dm_cb.ble_local_key_cb.id_keys.dhk[0],
1000                &p_data->ble_id_keys.dhk[0], sizeof(BT_OCTET16));
1001         btc_storage_add_ble_local_key( (char *)&btc_dm_cb.ble_local_key_cb.id_keys.irk[0],
1002                                        BTC_LE_LOCAL_KEY_IRK,
1003                                        BT_OCTET16_LEN);
1004         btc_storage_add_ble_local_key( (char *)&btc_dm_cb.ble_local_key_cb.id_keys.ir[0],
1005                                        BTC_LE_LOCAL_KEY_IR,
1006                                        BT_OCTET16_LEN);
1007         btc_storage_add_ble_local_key( (char *)&btc_dm_cb.ble_local_key_cb.id_keys.dhk[0],
1008                                        BTC_LE_LOCAL_KEY_DHK,
1009                                        BT_OCTET16_LEN);
1010         break;
1011     }
1012     case BTA_DM_BLE_LOCAL_ER_EVT: {
1013         rsp_app = true;
1014         ble_msg->act = ESP_GAP_BLE_LOCAL_ER_EVT;
1015         memcpy(&param.ble_security.ble_id_keys, &p_data->ble_id_keys, sizeof(tBTA_BLE_LOCAL_ID_KEYS));
1016         BTC_TRACE_DEBUG("BTA_DM_BLE_LOCAL_ER_EVT. ");
1017         btc_dm_cb.ble_local_key_cb.is_er_rcvd = TRUE;
1018         memcpy(&btc_dm_cb.ble_local_key_cb.er[0], &p_data->ble_er[0], sizeof(BT_OCTET16));
1019         btc_storage_add_ble_local_key( (char *)&btc_dm_cb.ble_local_key_cb.er[0],
1020                                        BTC_LE_LOCAL_KEY_ER,
1021                                        BT_OCTET16_LEN);
1022         break;
1023     }
1024     case BTA_DM_BLE_NC_REQ_EVT: {
1025         rsp_app = true;
1026         ble_msg->act = ESP_GAP_BLE_NC_REQ_EVT;
1027         memcpy(param.ble_security.key_notif.bd_addr, p_data->key_notif.bd_addr, BD_ADDR_LEN);
1028         param.ble_security.key_notif.passkey = p_data->key_notif.passkey;
1029         break;
1030     }
1031 #endif
1032 
1033 #if (BTC_DM_PM_INCLUDED == TRUE)
1034     case BTA_DM_PM_MODE_CHG_EVT:
1035         BTC_TRACE_DEBUG("BTA_DM_PM_MODE_CHG_EVT mode:%d", p_data->mode_chg.mode);
1036         btc_dm_pm_mode_chg_evt(&p_data->mode_chg);
1037         break;
1038 #endif /// BTA_DM_PM_INCLUDED == TRUE
1039 
1040     case BTA_DM_AUTHORIZE_EVT:
1041     case BTA_DM_SIG_STRENGTH_EVT:
1042     case BTA_DM_ROLE_CHG_EVT:
1043         BTC_TRACE_DEBUG( "btc_dm_sec_cback : unhandled event (%d)\n", msg->act );
1044         break;
1045     default:
1046         BTC_TRACE_DEBUG( "btc_dm_sec_cback : unhandled event (%d)\n", msg->act );
1047         break;
1048     }
1049 
1050     if (rsp_app) {
1051         memcpy(ble_msg->arg, &param, sizeof(esp_ble_gap_cb_param_t));
1052         ret = btc_inter_profile_call(ble_msg);
1053 
1054         if (ret != BT_STATUS_SUCCESS) {
1055             BTC_TRACE_ERROR("%s btc_inter_profile_call failed\n", __func__);
1056         }
1057     }
1058     osi_free(ble_msg);
1059     btc_dm_sec_arg_deep_free(msg);
1060 }
1061