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, ¶m, 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, ¶m, 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, ¶m, 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, ¶m, 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, ¶m, 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, ¶m, 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, ¶m, 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, ¶m);
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(¶m.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(¶m.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(¶m.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(¶m.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(¶m.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(¶m.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(¶m.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(¶m.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, ¶m, 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
