Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6c42d4b8 authored by Hui Peng's avatar Hui Peng
Browse files

Replace PRIVATE_ADDRESS with ADDRESS_TO_LOGGABLE_CSTR 

Test: refactoring CL. Existing unit tests still pass
Bug: 174487588
Tag: #security
Change-Id: Ia217b2a4ff9fea5d60491c23303764116ad1e94a
parent 42b9fe08

system/bta/ag/bta_ag_main.cc

+2 −2
Original line number Diff line number Diff line
@@ -728,7 +728,7 @@ void bta_ag_sm_execute(tBTA_AG_SCB* p_scb, uint16_t event, 
  LOG_DEBUG(

      "Execute AG event handle:0x%04x bd_addr:%s state:%s[0x%02x]"

      " event:%s[0x%04x] result:%s[0x%02x]",

      bta_ag_scb_to_idx(p_scb), PRIVATE_ADDRESS(p_scb->peer_addr),

      bta_ag_scb_to_idx(p_scb), ADDRESS_TO_LOGGABLE_CSTR(p_scb->peer_addr),

      bta_ag_state_str(p_scb->state), p_scb->state, bta_ag_evt_str(event),

      event, bta_ag_res_str(data.api_result.result), data.api_result.result);
@@ -739,7 +739,7 @@ void bta_ag_sm_execute(tBTA_AG_SCB* p_scb, uint16_t event, 
        "State changed handle:0x%04x bd_addr:%s "

        "state_change:%s[0x%02x]->%s[0x%02x]"

        " event:%s[0x%04x] result:%s[0x%02x]",

        bta_ag_scb_to_idx(p_scb), PRIVATE_ADDRESS(p_scb->peer_addr),

        bta_ag_scb_to_idx(p_scb), ADDRESS_TO_LOGGABLE_CSTR(p_scb->peer_addr),

        bta_ag_state_str(previous_state), previous_state,

        bta_ag_state_str(p_scb->state), p_scb->state,

        bta_ag_evt_str(previous_event), previous_event,

system/bta/ag/bta_ag_sco.cc

+1 −1
Original line number Diff line number Diff line
@@ -616,7 +616,7 @@ static void bta_ag_sco_event(tBTA_AG_SCB* p_scb, uint8_t event) { 
  tBTA_AG_SCO_CB* p_sco = &bta_ag_cb.sco;

  uint8_t previous_state = p_sco->state;

  LOG_INFO("device:%s index:0x%04x state:%s[%d] event:%s[%d]",

           PRIVATE_ADDRESS(p_scb->peer_addr), p_scb->sco_idx,

           ADDRESS_TO_LOGGABLE_CSTR(p_scb->peer_addr), p_scb->sco_idx,

           bta_ag_sco_state_str(p_sco->state), p_sco->state,

           bta_ag_sco_evt_str(event), event);

system/bta/av/bta_av_aact.cc

+1 −1
Original line number Diff line number Diff line
@@ -1835,7 +1835,7 @@ void bta_av_do_start(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data) { 
  LOG_INFO(

      "A2dp stream start peer:%s sco_occupied:%s av_role:0x%x started:%s "

      "wait:0x%x",

      PRIVATE_ADDRESS(p_scb->PeerAddress()),

      ADDRESS_TO_LOGGABLE_CSTR(p_scb->PeerAddress()),

      logbool(bta_av_cb.sco_occupied).c_str(), p_scb->role,

      logbool(p_scb->started).c_str(), p_scb->wait);

  if (bta_av_cb.sco_occupied) {

system/bta/av/bta_av_main.cc

+6 −6
Original line number Diff line number Diff line
@@ -909,7 +909,7 @@ static void bta_av_sco_chg_cback(tBTA_SYS_CONN_STATUS status, uint8_t id, 
            << ", num_links=" << +id;

  if (id) {

    bta_av_cb.sco_occupied = true;

    LOG_DEBUG("SCO occupied peer:%s status:%s", PRIVATE_ADDRESS(peer_addr),

    LOG_DEBUG("SCO occupied peer:%s status:%s", ADDRESS_TO_LOGGABLE_CSTR(peer_addr),

              bta_sys_conn_status_text(status).c_str());



    if (bta_av_cb.features & BTA_AV_FEAT_NO_SCO_SSPD) {
@@ -932,7 +932,7 @@ static void bta_av_sco_chg_cback(tBTA_SYS_CONN_STATUS status, uint8_t id, 
    }

  } else {

    bta_av_cb.sco_occupied = false;

    LOG_DEBUG("SCO unoccupied peer:%s status:%s", PRIVATE_ADDRESS(peer_addr),

    LOG_DEBUG("SCO unoccupied peer:%s status:%s", ADDRESS_TO_LOGGABLE_CSTR(peer_addr),

              bta_sys_conn_status_text(status).c_str());



    if (bta_av_cb.features & BTA_AV_FEAT_NO_SCO_SSPD) {
@@ -1018,7 +1018,7 @@ bool bta_av_link_role_ok(tBTA_AV_SCB* p_scb, uint8_t bits) { 
  tHCI_ROLE role;

  if (BTM_GetRole(p_scb->PeerAddress(), &role) != BTM_SUCCESS) {

    LOG_WARN("Unable to find link role for device:%s",

             PRIVATE_ADDRESS(p_scb->PeerAddress()));

             ADDRESS_TO_LOGGABLE_CSTR(p_scb->PeerAddress()));

    return true;

  }
@@ -1026,7 +1026,7 @@ bool bta_av_link_role_ok(tBTA_AV_SCB* p_scb, uint8_t bits) { 
    LOG_INFO(

        "Switch link role to central peer:%s bta_handle:0x%x current_role:%s"

        " conn_audio:0x%x bits:%d features:0x%x",

        PRIVATE_ADDRESS(p_scb->PeerAddress()), p_scb->hndl,

        ADDRESS_TO_LOGGABLE_CSTR(p_scb->PeerAddress()), p_scb->hndl,

        RoleText(role).c_str(), bta_av_cb.conn_audio, bits, bta_av_cb.features);

    const tBTM_STATUS status = BTM_SwitchRoleToCentral(p_scb->PeerAddress());

    switch (status) {
@@ -1038,13 +1038,13 @@ bool bta_av_link_role_ok(tBTA_AV_SCB* p_scb, uint8_t bits) { 
        // a result such that a timer will not start to repeatedly

        // try something not possible.

        LOG_ERROR("Link can never role switch to central device:%s",

                  PRIVATE_ADDRESS(p_scb->PeerAddress()));

                  ADDRESS_TO_LOGGABLE_CSTR(p_scb->PeerAddress()));

        break;

      default:

        /* can not switch role on SCB - start the timer on SCB */

        p_scb->wait |= BTA_AV_WAIT_ROLE_SW_RES_START;

        LOG_ERROR("Unable to switch role to central device:%s error:%s",

                  PRIVATE_ADDRESS(p_scb->PeerAddress()),

                  ADDRESS_TO_LOGGABLE_CSTR(p_scb->PeerAddress()),

                  btm_status_text(status).c_str());

        return false;

    }

system/bta/dm/bta_dm_act.cc

+23 −23
Original line number Diff line number Diff line
@@ -647,7 +647,7 @@ void bta_dm_remove_device(const RawAddress& bd_addr) { 
          connected_with_br_edr ? BT_TRANSPORT_BR_EDR : BT_TRANSPORT_LE;

    }

    LOG_INFO("other_address %s with transport %d connected",

             PRIVATE_ADDRESS(other_address), other_transport);

             ADDRESS_TO_LOGGABLE_CSTR(other_address), other_transport);

    /* Take the link down first, and mark the device for removal when

     * disconnected */

    for (int i = 0; i < bta_dm_cb.device_list.count; i++) {
@@ -655,7 +655,7 @@ void bta_dm_remove_device(const RawAddress& bd_addr) { 
      if (peer_device.peer_bdaddr == other_address &&

          peer_device.transport == other_transport) {

        peer_device.conn_state = BTA_DM_UNPAIRING;

        LOG_INFO("Remove ACL of address %s", PRIVATE_ADDRESS(other_address));

        LOG_INFO("Remove ACL of address %s", ADDRESS_TO_LOGGABLE_CSTR(other_address));



        /* Make sure device is not in acceptlist before we disconnect */

        GATT_CancelConnect(0, bd_addr, false);
@@ -745,7 +745,7 @@ void bta_dm_close_acl(const RawAddress& bd_addr, bool remove_dev, 
void bta_dm_bond(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,

                 tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type) {

  LOG_DEBUG("Bonding with peer device:%s type:%s transport:%s type:%s",

            PRIVATE_ADDRESS(bd_addr), AddressTypeText(addr_type).c_str(),

            ADDRESS_TO_LOGGABLE_CSTR(bd_addr), AddressTypeText(addr_type).c_str(),

            bt_transport_text(transport).c_str(),

            DeviceTypeText(device_type).c_str());
@@ -931,7 +931,7 @@ void bta_dm_discover(tBTA_DM_MSG* p_data) { 
  bta_dm_search_cb.name_discover_done = false;



  LOG_INFO("bta_dm_discovery: starting service discovery to %s , transport: %s",

           PRIVATE_ADDRESS(p_data->discover.bd_addr),

           ADDRESS_TO_LOGGABLE_CSTR(p_data->discover.bd_addr),

           bt_transport_text(p_data->discover.transport).c_str());

  bta_dm_discover_device(p_data->discover.bd_addr);

}
@@ -1772,7 +1772,7 @@ static void bta_dm_discover_device(const RawAddress& remote_bd_addr) { 
  if (BTM_IsRemoteNameKnown(remote_bd_addr, transport) &&

      bluetooth::common::init_flags::sdp_skip_rnr_if_known_is_enabled()) {

    LOG_DEBUG("Security record already known skipping read remote name peer:%s",

              PRIVATE_ADDRESS(remote_bd_addr));

              ADDRESS_TO_LOGGABLE_CSTR(remote_bd_addr));

    bta_dm_search_cb.name_discover_done = true;

  }
@@ -1828,7 +1828,7 @@ static void bta_dm_discover_device(const RawAddress& remote_bd_addr) { 
      if (transport == BT_TRANSPORT_LE) {

        if (bta_dm_search_cb.services_to_search & BTA_BLE_SERVICE_MASK) {

          LOG_INFO("bta_dm_discovery: starting GATT discovery on %s",

                   PRIVATE_ADDRESS(bta_dm_search_cb.peer_bdaddr));

                   ADDRESS_TO_LOGGABLE_CSTR(bta_dm_search_cb.peer_bdaddr));

          // set the raw data buffer here

          memset(g_disc_raw_data_buf, 0, sizeof(g_disc_raw_data_buf));

          /* start GATT for service discovery */
@@ -1837,7 +1837,7 @@ static void bta_dm_discover_device(const RawAddress& remote_bd_addr) { 
        }

      } else {

        LOG_INFO("bta_dm_discovery: starting SDP discovery on %s",

                 PRIVATE_ADDRESS(bta_dm_search_cb.peer_bdaddr));

                 ADDRESS_TO_LOGGABLE_CSTR(bta_dm_search_cb.peer_bdaddr));

        bta_dm_search_cb.sdp_results = false;

        bta_dm_find_services(bta_dm_search_cb.peer_bdaddr);

        return;
@@ -2255,7 +2255,7 @@ static void bta_dm_authentication_complete_cback( 
        LOG_WARN(

            "Deleting device record as authentication failed entry:%s "

            "reason:%s",

            PRIVATE_ADDRESS(bd_addr), hci_reason_code_text(reason).c_str());

            ADDRESS_TO_LOGGABLE_CSTR(bd_addr), hci_reason_code_text(reason).c_str());

        break;



      default:
@@ -2432,7 +2432,7 @@ static void handle_role_change(const RawAddress& bd_addr, tHCI_ROLE new_role, 
    LOG_WARN(

        "Unable to find device for role change peer:%s new_role:%s "

        "hci_status:%s",

        PRIVATE_ADDRESS(bd_addr), RoleText(new_role).c_str(),

        ADDRESS_TO_LOGGABLE_CSTR(bd_addr), RoleText(new_role).c_str(),

        hci_error_code_text(hci_status).c_str());

    return;

  }
@@ -2440,7 +2440,7 @@ static void handle_role_change(const RawAddress& bd_addr, tHCI_ROLE new_role, 
  LOG_INFO(

      "Role change callback peer:%s info:0x%x new_role:%s dev count:%d "

      "hci_status:%s",

      PRIVATE_ADDRESS(bd_addr), p_dev->Info(), RoleText(new_role).c_str(),

      ADDRESS_TO_LOGGABLE_CSTR(bd_addr), p_dev->Info(), RoleText(new_role).c_str(),

      bta_dm_cb.device_list.count, hci_error_code_text(hci_status).c_str());



  if (p_dev->Info() & BTA_DM_DI_AV_ACTIVE) {
@@ -2481,18 +2481,18 @@ void BTA_dm_report_role_change(const RawAddress bd_addr, tHCI_ROLE new_role, 
void handle_remote_features_complete(const RawAddress& bd_addr) {

  tBTA_DM_PEER_DEVICE* p_dev = bta_dm_find_peer_device(bd_addr);

  if (!p_dev) {

    LOG_WARN("Unable to find device peer:%s", PRIVATE_ADDRESS(bd_addr));

    LOG_WARN("Unable to find device peer:%s", ADDRESS_TO_LOGGABLE_CSTR(bd_addr));

    return;

  }



  if (controller_get_interface()->supports_sniff_subrating() &&

      acl_peer_supports_sniff_subrating(bd_addr)) {

    LOG_DEBUG("Device supports sniff subrating peer:%s",

              PRIVATE_ADDRESS(bd_addr));

              ADDRESS_TO_LOGGABLE_CSTR(bd_addr));

    p_dev->info = BTA_DM_DI_USE_SSR;

  } else {

    LOG_DEBUG("Device does NOT support sniff subrating peer:%s",

              PRIVATE_ADDRESS(bd_addr));

              ADDRESS_TO_LOGGABLE_CSTR(bd_addr));

  }

}
@@ -2733,7 +2733,7 @@ void bta_dm_rm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id, uint8_t app_id, 


  LOG_DEBUG("BTA Role management callback count:%d status:%s peer:%s",

            bta_dm_cb.cur_av_count, bta_sys_conn_status_text(status).c_str(),

            PRIVATE_ADDRESS(peer_addr));

            ADDRESS_TO_LOGGABLE_CSTR(peer_addr));



  p_dev = bta_dm_find_peer_device(peer_addr);

  if (status == BTA_SYS_CONN_OPEN) {
@@ -3369,35 +3369,35 @@ void bta_dm_encrypt_cback(const RawAddress* bd_addr, tBT_TRANSPORT transport, 
  switch (result) {

    case BTM_SUCCESS:

      LOG_WARN("Encrypted link peer:%s transport:%s status:%s callback:%c",

               PRIVATE_ADDRESS((*bd_addr)),

               ADDRESS_TO_LOGGABLE_CSTR((*bd_addr)),

               bt_transport_text(transport).c_str(),

               btm_status_text(result).c_str(), (p_callback) ? 'T' : 'F');

      break;

    case BTM_WRONG_MODE:

      LOG_WARN(

          "Unable to encrypt link peer:%s transport:%s status:%s callback:%c",

          PRIVATE_ADDRESS((*bd_addr)), bt_transport_text(transport).c_str(),

          ADDRESS_TO_LOGGABLE_CSTR((*bd_addr)), bt_transport_text(transport).c_str(),

          btm_status_text(result).c_str(), (p_callback) ? 'T' : 'F');

      bta_status = BTA_WRONG_MODE;

      break;

    case BTM_NO_RESOURCES:

      LOG_WARN(

          "Unable to encrypt link peer:%s transport:%s status:%s callback:%c",

          PRIVATE_ADDRESS((*bd_addr)), bt_transport_text(transport).c_str(),

          ADDRESS_TO_LOGGABLE_CSTR((*bd_addr)), bt_transport_text(transport).c_str(),

          btm_status_text(result).c_str(), (p_callback) ? 'T' : 'F');

      bta_status = BTA_NO_RESOURCES;

      break;

    case BTM_BUSY:

      LOG_WARN(

          "Unable to encrypt link peer:%s transport:%s status:%s callback:%c",

          PRIVATE_ADDRESS((*bd_addr)), bt_transport_text(transport).c_str(),

          ADDRESS_TO_LOGGABLE_CSTR((*bd_addr)), bt_transport_text(transport).c_str(),

          btm_status_text(result).c_str(), (p_callback) ? 'T' : 'F');

      bta_status = BTA_BUSY;

      break;

    default:

      LOG_ERROR(

          "Failed to encrypt link peer:%s transport:%s status:%s callback:%c",

          PRIVATE_ADDRESS((*bd_addr)), bt_transport_text(transport).c_str(),

          ADDRESS_TO_LOGGABLE_CSTR((*bd_addr)), bt_transport_text(transport).c_str(),

          btm_status_text(result).c_str(), (p_callback) ? 'T' : 'F');

      bta_status = BTA_FAILURE;

      break;
@@ -3419,7 +3419,7 @@ void bta_dm_set_encryption(const RawAddress& bd_addr, tBT_TRANSPORT transport, 
  tBTA_DM_PEER_DEVICE* device = find_connected_device(bd_addr, transport);

  if (device == nullptr) {

    LOG_ERROR("Unable to find active ACL connection device:%s transport:%s",

              PRIVATE_ADDRESS(bd_addr), bt_transport_text(transport).c_str());

              ADDRESS_TO_LOGGABLE_CSTR(bd_addr), bt_transport_text(transport).c_str());

    return;

  }
@@ -3427,7 +3427,7 @@ void bta_dm_set_encryption(const RawAddress& bd_addr, tBT_TRANSPORT transport, 
    LOG_ERROR(

        "Unable to start encryption as already in progress peer:%s "

        "transport:%s",

        PRIVATE_ADDRESS(bd_addr), bt_transport_text(transport).c_str());

        ADDRESS_TO_LOGGABLE_CSTR(bd_addr), bt_transport_text(transport).c_str());

    (*p_callback)(bd_addr, transport, BTA_BUSY);

    return;

  }
@@ -3436,10 +3436,10 @@ void bta_dm_set_encryption(const RawAddress& bd_addr, tBT_TRANSPORT transport, 
                        sec_act) == BTM_CMD_STARTED) {

    device->p_encrypt_cback = p_callback;

    LOG_DEBUG("Started encryption peer:%s transport:%s",

              PRIVATE_ADDRESS(bd_addr), bt_transport_text(transport).c_str());

              ADDRESS_TO_LOGGABLE_CSTR(bd_addr), bt_transport_text(transport).c_str());

  } else {

    LOG_ERROR("Unable to start encryption process peer:%s transport:%s",

              PRIVATE_ADDRESS(bd_addr), bt_transport_text(transport).c_str());

              ADDRESS_TO_LOGGABLE_CSTR(bd_addr), bt_transport_text(transport).c_str());

  }

}