BD_ADDR_LEN - syntax, references, description

#define STREAM_TO_BDADDR(a, p) {register int ijk; register UINT8 *pbda = (UINT8 *)a + BD_ADDR_LEN - 1; for (ijk = 0; ijk < BD_ADDR_LEN; ijk++) *pbda-- = *p++;}

bt_types.h:252

#ifndef BD_ADDR_LEN

bt_types.h:676

for (i = BD_ADDR_LEN; i != 0; i--) {

bt_types.h:714

for (i = BD_ADDR_LEN; i != 0; i--) {

bt_types.h:733

memset(bta_dm_search_cb.pending_close_bda, 0, BD_ADDR_LEN);

bta_dm_act.c:6651

memset(bta_dm_search_cb.pending_close_bda, 0, BD_ADDR_LEN);

bta_dm_act.c:6673

!memcmp(p_data->close.remote_bda, bta_dm_search_cb.peer_bdaddr, BD_ADDR_LEN)) {

bta_dm_act.c:6789

memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN);

bta_dm_api.c:831

memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN);

bta_dm_api.c:861

memcpy(p_msg->peer_bda, bd_addr, BD_ADDR_LEN);

bta_dm_api.c:1372

p_cond->srvc_uuid.p_target_addr->bda, BD_ADDR_LEN);

bta_dm_api.c:2459

memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN);

bta_dm_api.c:2779

memcpy(p_msg->bd_addr, bd_addr, BD_ADDR_LEN);

bta_dm_api.c:2813

memcpy(p_msg->address, rand_addr, BD_ADDR_LEN);

bta_dm_api.c:2948

memcpy(p_msg->addr, addr, BD_ADDR_LEN); // Copy the device address to the message

bta_dm_api.c:3010

memcpy(p_msg->bd_addr, addr, BD_ADDR_LEN);

bta_dm_api.c:3095

memcpy(p_msg->bd_addr, addr, BD_ADDR_LEN);

bta_dm_api.c:3133

memcpy(&p_msg->rand_addr, addr, BD_ADDR_LEN);

bta_dm_api.c:3153

memcpy(gattc_data.api_conn.remote_bda, remote_bda, BD_ADDR_LEN);

bta_gattc_act.c:2297

memcpy(p_buf->remote_bda, remote_bda, BD_ADDR_LEN);

bta_gattc_api.c:162

memcpy(p_buf->remote_bda, remote_bda, BD_ADDR_LEN);

bta_gattc_api.c:206

!memcmp(p_clreg->notif_reg[i].remote_bda, bda, BD_ADDR_LEN) &&

bta_gattc_api.c:925

memcpy(p_clreg->notif_reg[i].remote_bda, bda, BD_ADDR_LEN);

bta_gattc_api.c:938

!memcmp(p_clreg->notif_reg[i].remote_bda, bda, BD_ADDR_LEN) &&

bta_gattc_api.c:987

memcpy(p_buf->remote_bda, remote_bda, BD_ADDR_LEN);

bta_gattc_api.c:1029

memcpy(p_buf->remote_bda, remote_bda, BD_ADDR_LEN);

bta_gattc_api.c:1087

if ((p_buf = (tBTA_GATTC_API_LISTEN *) osi_malloc((UINT16)(sizeof(tBTA_GATTC_API_LISTEN) + BD_ADDR_LEN))) != NULL) {

bta_gattc_api.c:1112

memcpy(p_buf->remote_bda, target_bda, BD_ADDR_LEN);

bta_gattc_api.c:1119

if ((p_buf = (tBTA_GATTC_API_LISTEN *) osi_malloc((UINT16)(sizeof(tBTA_GATTC_API_LISTEN) + BD_ADDR_LEN))) != NULL) {

bta_gattc_api.c:1145

memset(p_conn->remote_bda, 0, BD_ADDR_LEN);

bta_gattc_utils.c:918

UINT16 addr[BD_ADDR_LEN] = {0};

bta_gatts_act.c:872

if(memcmp(p_msg->api_send_service_change.remote_bda, addr, BD_ADDR_LEN) != 0) {

bta_gatts_act.c:873

memcpy(bd_addr, p_msg->api_send_service_change.remote_bda, BD_ADDR_LEN);

bta_gatts_act.c:875

memcpy(cb_data.conn.remote_bda, bda, BD_ADDR_LEN);

bta_gatts_act.c:1047

memcpy(p_buf->remote_bda, remote_bda, BD_ADDR_LEN);

bta_gatts_api.c:530

memcpy(p_buf->remote_bda, remote_bda, BD_ADDR_LEN);

bta_gatts_api.c:560

memcpy(p_buf->remote_bda, remote_bda, BD_ADDR_LEN);

bta_gatts_api.c:598

if ((p_buf = (tBTA_GATTS_API_LISTEN *) osi_malloc((UINT16)(sizeof(tBTA_GATTS_API_LISTEN) + BD_ADDR_LEN))) != NULL) {

bta_gatts_api.c:625

memcpy(p_buf->remote_bda, target_bda, BD_ADDR_LEN);

bta_gatts_api.c:633

memcpy(bd_addr.address, remote_addr, BD_ADDR_LEN);

bta_gatts_co.c:183

memcpy(bd_addr.address, remote_addr, BD_ADDR_LEN);

bta_gatts_co.c:204

memcpy(bd_addr.address, remote_addr, BD_ADDR_LEN);

bta_gatts_co.c:225

memcpy(bd_addr.address, remote_addr, BD_ADDR_LEN);

bta_gatts_co.c:246

if (memcmp(p_cb->kdev[i].addr, bd_addr, BD_ADDR_LEN) == 0) {

bta_hh_utils.c:409

memcpy(param.ble_security.ble_key.bd_addr, p_data->ble_key.bd_addr, BD_ADDR_LEN);

btc_dm.c:918

memcpy(param.ble_security.ble_req.bd_addr, p_data->ble_req.bd_addr, BD_ADDR_LEN);

btc_dm.c:984

memcpy(param.ble_security.key_notif.bd_addr, p_data->ble_req.bd_addr, BD_ADDR_LEN);

btc_dm.c:991

memcpy(param.ble_security.ble_req.bd_addr, p_data->ble_req.bd_addr, BD_ADDR_LEN);

btc_dm.c:997

memcpy(param.ble_security.ble_req.bd_addr, p_data->ble_req.bd_addr, BD_ADDR_LEN);

btc_dm.c:1003

memcpy(param.ble_security.ble_req.bd_addr, p_data->ble_req.bd_addr, BD_ADDR_LEN);

btc_dm.c:1009

memcpy(param.ble_security.key_notif.bd_addr, p_data->key_notif.bd_addr, BD_ADDR_LEN);

btc_dm.c:1057

memcpy(param.read_phy.bda, params->read_phy.addr, BD_ADDR_LEN);

btc_gap_ble.c:974

memcpy(param.phy_update.bda, params->phy_update.addr, BD_ADDR_LEN);

btc_gap_ble.c:1116

if (memcmp(invalid_rand_addr_a, rand_addr, BD_ADDR_LEN) != 0 && memcmp(invalid_rand_addr_b, rand_addr, BD_ADDR_LEN) != 0) {

btc_gap_ble.c:1474

if (memcmp(invalid_rand_addr_a, rand_addr, BD_ADDR_LEN) != 0 && memcmp(invalid_rand_addr_b, rand_addr, BD_ADDR_LEN) != 0) {

btc_gap_ble.c:1482

memcpy(param.rmt_srvcs.bda, p_data->p_data->disc_res.bd_addr, BD_ADDR_LEN);

btc_gap_bt.c:402

memcpy(param.rmt_srvcs.bda, p_data->p_data->disc_res.bd_addr, BD_ADDR_LEN);

btc_gap_bt.c:476

memcpy(param.read_rmt_name.bda,result->bd_addr,BD_ADDR_LEN);

btc_gap_bt.c:837

memcpy(param.qos_cmpl.bda,result->rem_bda,BD_ADDR_LEN);

btc_gap_bt.c:865

memcpy(remote_bda, arg->send_service_change.remote_bda, BD_ADDR_LEN);

btc_gatts.c:748

memset(param.register_app.bd_addr, 0, BD_ADDR_LEN);

btc_hd.c:351

memcpy(param.open.bd_addr, bd_addr, BD_ADDR_LEN);

btc_hd.c:463

memset(param.register_app.bd_addr, 0, BD_ADDR_LEN);

btc_hd.c:817

memcpy(param.register_app.bd_addr, p_data->reg_status.bda, BD_ADDR_LEN);

btc_hd.c:819

memcpy(param.open.bd_addr, p_data->conn.bda, BD_ADDR_LEN);

btc_hd.c:852

memcmp(btc_hh_cb.devices[i].bd_addr, bd_addr, BD_ADDR_LEN) == 0) {

btc_hh.c:160

memcmp(btc_hh_cb.devices[i].bd_addr, bd_addr, BD_ADDR_LEN) == 0) {

btc_hh.c:181

if (memcmp(btc_hh_cb.added_devices[i].bd_addr, bd_addr, BD_ADDR_LEN) == 0) {

btc_hh.c:286

if (memcmp(btc_hh_cb.added_devices[i].bd_addr, bd_addr_null, BD_ADDR_LEN) == 0) {

btc_hh.c:291

memcpy(btc_hh_cb.added_devices[i].bd_addr, bd_addr, BD_ADDR_LEN);

btc_hh.c:292

if (memcmp(p_added_dev->bd_addr, bd_addr, BD_ADDR_LEN) == 0) {

btc_hh.c:319

if (memcmp(btc_hh_cb.added_devices[i].bd_addr, arg->connect.bd_addr, BD_ADDR_LEN) == 0) {

btc_hh.c:555

memcpy(btc_hh_cb.pending_conn_address, arg->connect.bd_addr, BD_ADDR_LEN);

btc_hh.c:577

memcpy(param.open.bd_addr, arg->connect.bd_addr, BD_ADDR_LEN);

btc_hh.c:588

if (memcmp(btc_hh_cb.pending_conn_address, arg->unplug.bd_addr, BD_ADDR_LEN) == 0 &&

btc_hh.c:681

memset(btc_hh_cb.pending_conn_address, 0, BD_ADDR_LEN);

btc_hh.c:684

memcpy(param.set_info.bd_addr, arg->set_info.bd_addr, BD_ADDR_LEN);

btc_hh.c:755

memset(btc_hh_cb.pending_conn_address, 0, BD_ADDR_LEN);

btc_hh.c:1270

memcpy(p_dev->bd_addr, p_data->conn.bda, BD_ADDR_LEN);

btc_hh.c:1286

memcpy(param.open.bd_addr, p_data->conn.bda, BD_ADDR_LEN);

btc_hh.c:1311

if (memcmp(btc_hh_cb.added_devices[i].bd_addr, p_data->dev_info.bda, BD_ADDR_LEN) == 0) {

btc_hh.c:1490

memset(btc_hh_cb.added_devices[i].bd_addr, 0, BD_ADDR_LEN);

btc_hh.c:1494

memcpy(param.set_info.bd_addr, p_data->dev_info.bda, BD_ADDR_LEN);

btc_hh.c:1503

memcpy(param.add_dev.bd_addr, p_data->dev_info.bda, BD_ADDR_LEN);

btc_hh.c:1508

memcpy(param.rmv_dev.bd_addr, p_data->dev_info.bda, BD_ADDR_LEN);

btc_hh.c:1516

&& !memcmp(p_bda, p_acl_db->remote_addr, BD_ADDR_LEN)

btm_acl.c:111

memcpy(conn_addr, p_dev_rec->bd_addr, BD_ADDR_LEN);

btm_acl.c:203

memcpy(conn_addr, p_dev_rec->ble.cur_rand_addr, BD_ADDR_LEN);

btm_acl.c:208

memcpy(conn_addr, p_dev_rec->ble.static_addr, BD_ADDR_LEN);

btm_acl.c:213

memcpy (p->remote_addr, bda, BD_ADDR_LEN);

btm_acl.c:276

memcpy(p->conn_addr, &controller_get_interface()->get_address()->address, BD_ADDR_LEN);

btm_acl.c:290

&& (bda && (0 == memcmp(btm_cb.devcb.switch_role_ref_data.remote_bd_addr, bda, BD_ADDR_LEN)))) {

btm_acl.c:403

BD_ADDR_LEN);

btm_acl.c:757

memcpy(p_data->remote_bd_addr, p_bda, BD_ADDR_LEN);

btm_acl.c:1489

if (memcmp (controller_get_interface()->get_address(), addr, BD_ADDR_LEN) == 0) {

btm_acl.c:1681

memcpy (qossu.rem_bda, p->remote_addr, BD_ADDR_LEN);

btm_acl.c:1939

memcpy(btm_cb.devcb.read_tx_pwr_addr, remote_bda, BD_ADDR_LEN);

btm_acl.c:2100

memcpy(results.rem_bda, conn->remote_addr, BD_ADDR_LEN);

btm_acl.c:2176

memcpy (results.rem_bda, p_acl_cb->remote_addr, BD_ADDR_LEN);

btm_acl.c:2258

memcpy(results.rem_bda, btm_cb.devcb.read_tx_pwr_addr, BD_ADDR_LEN);

btm_acl.c:2264

memcpy (results.rem_bda, p_acl_cb->remote_addr, BD_ADDR_LEN);

btm_acl.c:2314

memcpy (results.rem_bda, p_acl_cb->remote_addr, BD_ADDR_LEN);

btm_acl.c:2361

memcpy (btm_cb.connecting_bda, p_dev_rec->bd_addr, BD_ADDR_LEN);

btm_acl.c:2509

memcmp (bda, btm_cb.connecting_bda, BD_ADDR_LEN) != 0) {

btm_acl.c:2564

memcpy (btm_cb.connecting_bda, p_dev_rec->bd_addr, BD_ADDR_LEN);

btm_acl.c:2568

memcpy (esco_data.bd_addr, bda, BD_ADDR_LEN);

btm_acl.c:2711

memcpy (p_dev_rec->bd_addr, bd_addr, BD_ADDR_LEN);

btm_ble.c:97

memcpy (p_dev_rec->ble.pseudo_addr, bd_addr, BD_ADDR_LEN);

btm_ble.c:128

memcpy(local_conn_addr, p_acl->conn_addr, BD_ADDR_LEN);

btm_ble.c:295

memcpy(conn_addr, p->active_remote_addr, BD_ADDR_LEN);

btm_ble.c:355

memcpy(conn_addr, pseudo_addr, BD_ADDR_LEN);

btm_ble.c:360

memcpy(oob.peer_oob_data.addr_rcvd_from.bda, bd_addr, BD_ADDR_LEN);

btm_ble.c:533

if (memcmp(p_dev_rec->bd_addr, remote_bda, BD_ADDR_LEN) == 0 &&

btm_ble.c:703

memcmp(p_dev_rec->ble.pseudo_addr, remote_bda, BD_ADDR_LEN) == 0) {

btm_ble.c:704

} else if (memcmp(p_dev_rec->ble.pseudo_addr, remote_bda, BD_ADDR_LEN) == 0) {

btm_ble.c:707

memset(remote_bda, 0, BD_ADDR_LEN);

btm_ble.c:740

memcpy(remote_bda, p_dev_rec->bd_addr, BD_ADDR_LEN);

btm_ble.c:746

memcpy(remote_bda, p_dev_rec->bd_addr, BD_ADDR_LEN);

btm_ble.c:749

memset(remote_bda, 0, BD_ADDR_LEN);

btm_ble.c:751

memcpy(remote_bda, p_dev_rec->ble.pseudo_addr, BD_ADDR_LEN);

btm_ble.c:757

memcpy(p_rec->ble.static_addr, p_keys->pid_key.static_addr, BD_ADDR_LEN);

btm_ble.c:1319

memcpy(p_rec->bd_addr, p_keys->pid_key.static_addr, BD_ADDR_LEN);

btm_ble.c:1324

memcpy(match_rec->ble.cur_rand_addr, bda, BD_ADDR_LEN);

btm_ble.c:1927

memcpy(bda, match_rec->ble.pseudo_addr, BD_ADDR_LEN);

btm_ble.c:1930

memcpy(bda, match_rec->bd_addr, BD_ADDR_LEN);

btm_ble.c:1932

memcpy(p_dev_rec->ble.pseudo_addr, bda, BD_ADDR_LEN);

btm_ble.c:1997

memcpy(p_dev_rec->ble.cur_rand_addr, bda, BD_ADDR_LEN);

btm_ble.c:2010

if (memcmp(local_rpa, dummy_bda, BD_ADDR_LEN)) {

btm_ble.c:2051

memcpy (btm_cb.pairing_bda, bd_addr, BD_ADDR_LEN);

btm_ble.c:2219

if (memcmp(bd_addr, btm_cb.pairing_bda, BD_ADDR_LEN) == 0) {

btm_ble.c:2268

memset (btm_cb.pairing_bda, 0xff, BD_ADDR_LEN);

btm_ble.c:2269

memcpy(cb_params.read_phy.addr, bd_addr, BD_ADDR_LEN);

btm_ble_5_gap.c:228

if (memcmp(invalid_rand_addr_a, rand_addr, BD_ADDR_LEN) == 0

btm_ble_5_gap.c:311

|| memcmp(invalid_rand_addr_b, rand_addr, BD_ADDR_LEN) == 0) {

btm_ble_5_gap.c:312

if (memcmp(invalid_rand_addr_a, rand_addr, BD_ADDR_LEN) == 0

btm_ble_5_gap.c:318

|| memcmp(invalid_rand_addr_b, rand_addr, BD_ADDR_LEN) == 0) {

btm_ble_5_gap.c:319

memcpy(cb_params.read_phy.addr, p_lcb->remote_bd_addr, BD_ADDR_LEN);

btm_ble_5_gap.c:895

memcpy(cb_params.phy_update.addr, p_lcb->remote_bd_addr, BD_ADDR_LEN);

btm_ble_5_gap.c:1212

memcpy(p_cb->resolvale_addr, p_cb->private_addr, BD_ADDR_LEN);

btm_ble_addr.c:64

if (memcmp(p_dev_rec->ble.pseudo_addr, dummy_bda, BD_ADDR_LEN) == 0) {

btm_ble_addr.c:278

memcpy(p_dev_rec->ble.pseudo_addr, new_pseudo_addr, BD_ADDR_LEN);

btm_ble_addr.c:279

memcpy(p_mgnt_cb->random_bda, random_bda, BD_ADDR_LEN);

btm_ble_addr.c:401

memcpy(bd_addr, p_dev_rec->ble.pseudo_addr, BD_ADDR_LEN);

btm_ble_addr.c:481

memcpy(random_pseudo, p_dev_rec->ble.static_addr, BD_ADDR_LEN);

btm_ble_addr.c:511

if (memcmp(dummy_bda, rpa, BD_ADDR_LEN) == 0) {

btm_ble_addr.c:537

memcpy(p_sec_rec->ble.cur_rand_addr, rpa, BD_ADDR_LEN);

btm_ble_addr.c:544

memcpy(p_acl->active_remote_addr, p_sec_rec->ble.static_addr, BD_ADDR_LEN);

btm_ble_addr.c:571

memcpy(p_acl->active_remote_addr, rpa, BD_ADDR_LEN);

btm_ble_addr.c:574

memcpy(p_acl->active_remote_addr, rpa, BD_ADDR_LEN);

btm_ble_addr.c:578

if (memcmp(local_rpa, dummy_bda, BD_ADDR_LEN)) {

btm_ble_addr.c:608

memcpy(p->conn_addr, local_rpa, BD_ADDR_LEN);

btm_ble_addr.c:609

memcpy(p->conn_addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, BD_ADDR_LEN);

btm_ble_addr.c:611

memcpy(p->conn_addr, &controller_get_interface()->get_address()->address, BD_ADDR_LEN);

btm_ble_addr.c:615

if (memcmp(&btm_ble_adv_filt_cb.cur_filter_target.bda, &na_bda, BD_ADDR_LEN) == 0) {

btm_ble_adv_filter.c:321

memcmp(p_le_bda->bda, p_addr_filter->bd_addr, BD_ADDR_LEN) == 0) {

btm_ble_adv_filter.c:380

if (memcmp(na_bda, p_addr_filter->bd_addr, BD_ADDR_LEN) == 0) {

btm_ble_adv_filter.c:402

memcpy(p_addr_filter->bd_addr, bd_addr, BD_ADDR_LEN);

btm_ble_adv_filter.c:403

memcmp(p_bd_addr->bda, p_addr_filter->bd_addr, BD_ADDR_LEN) == 0))) {

btm_ble_adv_filter.c:432

if (p_dev_op->in_use && p_dev_op->addr_type == addr_type && !memcmp(p_dev_op->bd_addr, bd_addr, BD_ADDR_LEN)) {

btm_ble_bgconn.c:253

memcpy(p_dev_op->bd_addr, bd_addr, BD_ADDR_LEN);

btm_ble_bgconn.c:264

if(p_dev_rec && memcmp(invalid_rand_addr_b, p_dev_rec->ble.static_addr, BD_ADDR_LEN) != 0) {

btm_ble_bgconn.c:296

memcpy(bd_addr, p_dev_rec->ble.static_addr, BD_ADDR_LEN);

btm_ble_bgconn.c:297

if(memcmp(invalid_rand_addr_a, bd_addr, BD_ADDR_LEN) != 0

btm_ble_bgconn.c:310

&& memcmp(invalid_rand_addr_b, bd_addr, BD_ADDR_LEN) != 0){

btm_ble_bgconn.c:311

uint8_t null_addr[BD_ADDR_LEN] = {0};

btm_ble_gap.c:391

if ((p_cb->evt_type == 0x01 || p_cb->evt_type == 0x04) && memcmp(p_addr_ptr, null_addr, BD_ADDR_LEN) == 0) {

btm_ble_gap.c:392

memset(p_cb->addr_mgnt_cb.resolvale_addr, 0, BD_ADDR_LEN);

btm_ble_gap.c:897

memcpy(bda, p_cb->resolvale_addr, BD_ADDR_LEN);

btm_ble_gap.c:955

memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, bda, BD_ADDR_LEN);

btm_ble_gap.c:983

memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr, rand_addr, BD_ADDR_LEN);

btm_ble_gap.c:998

memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr, BD_ADDR_LEN);

btm_ble_gap.c:1014

memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.resolvale_addr, BD_ADDR_LEN);

btm_ble_gap.c:1020

memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.resolvale_addr, BD_ADDR_LEN);

btm_ble_gap.c:1033

memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr, BD_ADDR_LEN);

btm_ble_gap.c:1052

memcpy(match_rec->ble.cur_rand_addr, bda, BD_ADDR_LEN);

btm_ble_gap.c:1190

memcpy(bda, match_rec->bd_addr, BD_ADDR_LEN);

btm_ble_gap.c:1193

memcpy(bda, match_rec->ble.pseudo_addr, BD_ADDR_LEN);

btm_ble_gap.c:1196

memcpy(p_peer_addr_ptr, p_dev_rec->ble.static_addr, BD_ADDR_LEN);

btm_ble_gap.c:1390

memcpy(p_peer_addr_ptr, p_cb->direct_bda.bda, BD_ADDR_LEN);

btm_ble_gap.c:1403

memcpy(p_peer_addr_ptr, p_dev_rec->ble.static_addr, BD_ADDR_LEN);

btm_ble_gap.c:1418

uint8_t device_info_array[1 + 4 + BD_ADDR_LEN] = {0};

btm_ble_gap.c:1861

bt_rcopy(&device_info_array[5], device_info, BD_ADDR_LEN);

btm_ble_gap.c:1870

status = BTM_VendorSpecificCommand(HCI_VENDOR_BLE_UPDATE_DUPLICATE_EXCEPTIONAL_LIST, 1 + 4 + BD_ADDR_LEN, device_info_array, NULL);

btm_ble_gap.c:1889

memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, rand_addr, BD_ADDR_LEN);

btm_ble_gap.c:2027

memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr, rand_addr, BD_ADDR_LEN);

btm_ble_gap.c:2028

memset(btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr, 0, BD_ADDR_LEN);

btm_ble_gap.c:2056

memcpy(addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, BD_ADDR_LEN);

btm_ble_gap.c:2079

memcpy(addr, &controller_get_interface()->get_address()->address, BD_ADDR_LEN);

btm_ble_gap.c:2082

memset(addr, 0, BD_ADDR_LEN);

btm_ble_gap.c:2085

memcpy(p_inq->remname_bda, remote_bda, BD_ADDR_LEN);

btm_ble_gap.c:2904

memset(p_inq->remname_bda, 0, BD_ADDR_LEN);

btm_ble_gap.c:2934

if(memcmp(bda, p_le_inq_cb->adv_addr, BD_ADDR_LEN) != 0) {

btm_ble_gap.c:3109

memcpy(p_le_inq_cb->adv_addr, bda, BD_ADDR_LEN);

btm_ble_gap.c:3111

memcmp(bda, p_cond->filter_cond.bdaddr_cond, BD_ADDR_LEN) != 0) {

btm_ble_gap.c:3173

memcpy(temp_bda, bda, BD_ADDR_LEN);

btm_ble_gap.c:3603

memcpy(p_dev_rec->ble.current_addr, temp_bda, BD_ADDR_LEN);

btm_ble_gap.c:3622

if(memcmp(null_bda, p_le_inq_cb->adv_addr, BD_ADDR_LEN) == 0) {

btm_ble_gap.c:3656