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

Commit 05ee808f authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Class enum-ify stack::sec::tSECURITY_STATE" into main am: a77dee9a 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/3133940



Change-Id: Iead0768d910eca2ddb88dfe90596492a5c5ed406
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 8ebd1dea a77dee9a

system/stack/btm/btm_ble_sec.cc

+8 −8
Original line number Diff line number Diff line
@@ -30,7 +30,6 @@ 
#include "btif/include/btif_storage.h"

#include "crypto_toolbox/crypto_toolbox.h"

#include "device/include/interop.h"

#include "device/include/interop_config.h"

#include "hci/controller_interface.h"

#include "main/shim/entry.h"

#include "osi/include/allocator.h"
@@ -1068,7 +1067,7 @@ void btm_ble_link_sec_check(const RawAddress& bd_addr, 
  }



  if (p_dev_rec->sec_rec.is_security_state_encrypting() ||

      p_dev_rec->sec_rec.sec_state == BTM_SEC_STATE_AUTHENTICATING) {

      p_dev_rec->sec_rec.sec_state == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING) {

    /* race condition: discard the security request while central is encrypting

     * the link */

    *p_sec_req_act = BTM_BLE_SEC_REQ_ACT_DISCARD;
@@ -1172,7 +1171,7 @@ tBTM_STATUS btm_ble_set_encryption(const RawAddress& bd_addr, 


      if (SMP_Pair(bd_addr) == SMP_STARTED) {

        cmd = BTM_CMD_STARTED;

        p_rec->sec_rec.sec_state = BTM_SEC_STATE_AUTHENTICATING;

        p_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING;

      }

      break;
@@ -1253,8 +1252,9 @@ tBTM_STATUS btm_ble_start_encrypt(const RawAddress& bda, bool use_stk, 
    return BTM_ERR_KEY_MISSING;

  }



  if (p_rec->sec_rec.sec_state == BTM_SEC_STATE_IDLE)

    p_rec->sec_rec.sec_state = BTM_SEC_STATE_LE_ENCRYPTING;

  if (p_rec->sec_rec.sec_state == tSECURITY_STATE::BTM_SEC_STATE_IDLE) {

    p_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_LE_ENCRYPTING;

  }



  return BTM_CMD_STARTED;

}
@@ -1324,7 +1324,7 @@ void btm_ble_link_encrypted(const RawAddress& bd_addr, uint8_t encr_enable) { 
  if (encr_enable && p_dev_rec->sec_rec.enc_key_size == 0)

    p_dev_rec->sec_rec.enc_key_size = p_dev_rec->sec_rec.ble_keys.key_size;



  p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_IDLE;

  p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_IDLE;

  if (p_dev_rec->sec_rec.p_callback && enc_cback) {

    if (encr_enable) btm_sec_dev_rec_cback_event(p_dev_rec, BTM_SUCCESS, true);

    /* LTK missing on peripheral */
@@ -1594,7 +1594,7 @@ tBTM_STATUS btm_proc_smp_cback(tSMP_EVT event, const RawAddress& bd_addr, 
        }

        btm_sec_cb.pairing_bda = bd_addr;

        if (event != SMP_CONSENT_REQ_EVT) {

          p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_AUTHENTICATING;

          p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING;

        }

        btm_sec_cb.pairing_flags |= BTM_PAIR_FLAGS_LE_ACTIVE;

        FALLTHROUGH_INTENDED; /* FALLTHROUGH */
@@ -1651,7 +1651,7 @@ tBTM_STATUS btm_proc_smp_cback(tSMP_EVT event, const RawAddress& bd_addr, 
          }



          if (res == BTM_SUCCESS) {

            p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_IDLE;

            p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_IDLE;



            if (p_dev_rec->sec_rec.bond_type != BOND_TYPE_TEMPORARY) {

              // Add all bonded device into resolving list if IRK is available.

system/stack/btm/btm_dev.cc

+1 −1
Original line number Diff line number Diff line
@@ -214,7 +214,7 @@ void BTM_SecClearSecurityFlags(const RawAddress& bd_addr) { 
  if (p_dev_rec == NULL) return;



  p_dev_rec->sec_rec.sec_flags = 0;

  p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_IDLE;

  p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_IDLE;

  p_dev_rec->sm4 = BTM_SM4_UNKNOWN;

}

system/stack/btm/btm_devctl.cc

+1 −1
Original line number Diff line number Diff line
@@ -161,7 +161,7 @@ void BTM_db_reset(void) { 


static bool set_sec_state_idle(void* data, void* /* context */) {

  tBTM_SEC_DEV_REC* p_dev_rec = static_cast<tBTM_SEC_DEV_REC*>(data);

  p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_IDLE;

  p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_IDLE;

  return true;

}

system/stack/btm/btm_sec.cc

+62 −56
Original line number Diff line number Diff line
@@ -766,7 +766,7 @@ tBTM_STATUS btm_sec_bond_by_transport(const RawAddress& bd_addr, 


    if (SMP_Pair(bd_addr, addr_type) == SMP_STARTED) {

      btm_sec_cb.pairing_flags |= BTM_PAIR_FLAGS_LE_ACTIVE;

      p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_AUTHENTICATING;

      p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING;

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

      return BTM_CMD_STARTED;

    }
@@ -918,7 +918,7 @@ tBTM_STATUS BTM_SecBondCancel(const RawAddress& bd_addr) { 
  }



  if (btm_sec_cb.pairing_flags & BTM_PAIR_FLAGS_LE_ACTIVE) {

    if (p_dev_rec->sec_rec.sec_state == BTM_SEC_STATE_AUTHENTICATING) {

    if (p_dev_rec->sec_rec.sec_state == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING) {

      log::verbose("Cancel LE pairing");

      if (SMP_PairCancel(bd_addr)) {

        return BTM_CMD_STARTED;
@@ -942,9 +942,10 @@ tBTM_STATUS BTM_SecBondCancel(const RawAddress& bd_addr) { 
    /* If the HCI link is up */

    if (p_dev_rec->hci_handle != HCI_INVALID_HANDLE) {

      /* If some other thread disconnecting, we do not send second command */

      if ((p_dev_rec->sec_rec.sec_state == BTM_SEC_STATE_DISCONNECTING) ||

          (p_dev_rec->sec_rec.sec_state == BTM_SEC_STATE_DISCONNECTING_BOTH))

      if ((p_dev_rec->sec_rec.sec_state == tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING) ||

          (p_dev_rec->sec_rec.sec_state == tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BOTH)) {

        return (BTM_CMD_STARTED);

      }



      /* If the HCI link was set up by Bonding process */

      if (btm_sec_cb.pairing_flags & BTM_PAIR_FLAGS_DISC_WHEN_DONE)
@@ -1101,21 +1102,21 @@ tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr, 
  if (bluetooth::common::init_flags::encryption_in_busy_state_is_enabled()) {

    bool enqueue = false;

    switch (p_dev_rec->sec_rec.sec_state) {

      case BTM_SEC_STATE_AUTHENTICATING:

      case BTM_SEC_STATE_DISCONNECTING_BOTH:

      case tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING:

      case tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BOTH:

        /* Applicable for both transports */

        enqueue = true;

        break;



      case BTM_SEC_STATE_ENCRYPTING:

      case BTM_SEC_STATE_DISCONNECTING:

      case tSECURITY_STATE::BTM_SEC_STATE_ENCRYPTING:

      case tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING:

        if (transport == BT_TRANSPORT_BR_EDR) {

          enqueue = true;

        }

        break;



      case BTM_SEC_STATE_LE_ENCRYPTING:

      case BTM_SEC_STATE_DISCONNECTING_BLE:

      case tSECURITY_STATE::BTM_SEC_STATE_LE_ENCRYPTING:

      case tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BLE:

        if (transport == BT_TRANSPORT_LE) {

          enqueue = true;

        }
@@ -1137,7 +1138,7 @@ tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr, 
    }

  } else {

    if (p_dev_rec->sec_rec.p_callback ||

        (p_dev_rec->sec_rec.sec_state != BTM_SEC_STATE_IDLE)) {

        (p_dev_rec->sec_rec.sec_state != tSECURITY_STATE::BTM_SEC_STATE_IDLE)) {

      log::warn("Security Manager: BTM_SetEncryption busy, enqueue request");

      btm_sec_queue_encrypt_request(bd_addr, transport, p_callback, p_ref_data,

                                    sec_act);
@@ -1204,7 +1205,7 @@ bool BTM_SecIsSecurityPending(const RawAddress& bd_addr) { 
  tBTM_SEC_DEV_REC* p_dev_rec = btm_find_dev(bd_addr);

  return p_dev_rec &&

         (p_dev_rec->sec_rec.is_security_state_encrypting() ||

          p_dev_rec->sec_rec.sec_state == BTM_SEC_STATE_AUTHENTICATING);

          p_dev_rec->sec_rec.sec_state == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING);

}



/*******************************************************************************
@@ -1220,32 +1221,32 @@ static tBTM_STATUS btm_sec_send_hci_disconnect(tBTM_SEC_DEV_REC* p_dev_rec, 


  /* send HCI_Disconnect on a transport only once */

  switch (old_state) {

    case BTM_SEC_STATE_DISCONNECTING:

    case tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING:

      if (conn_handle == p_dev_rec->hci_handle) {

        // Already sent classic disconnect

        return status;

      }

      // Prepare to send disconnect on le transport

      p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_DISCONNECTING_BOTH;

      p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BOTH;

      break;



    case BTM_SEC_STATE_DISCONNECTING_BLE:

    case tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BLE:

      if (conn_handle == p_dev_rec->ble_hci_handle) {

        // Already sent ble disconnect

        return status;

      }

      // Prepare to send disconnect on classic transport

      p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_DISCONNECTING_BOTH;

      p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BOTH;

      break;



    case BTM_SEC_STATE_DISCONNECTING_BOTH:

    case tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BOTH:

      // Already sent disconnect on both transports

      return status;



    default:

      p_dev_rec->sec_rec.sec_state = (conn_handle == p_dev_rec->hci_handle)

                                         ? BTM_SEC_STATE_DISCONNECTING

                                         : BTM_SEC_STATE_DISCONNECTING_BLE;

                                             ? tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING

                                             : tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BLE;



      break;

  }
@@ -1723,7 +1724,7 @@ tBTM_STATUS btm_sec_l2cap_access_req_by_requirement( 
      log::info(

          "peer should have initiated security process by now (SM4 to SM4)");

      p_dev_rec->sec_rec.p_callback = p_callback;

      p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_DELAY_FOR_ENC;

      p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_DELAY_FOR_ENC;

      (*p_callback)(bd_addr, transport, p_ref_data, rc);



      return BTM_SUCCESS;
@@ -1906,7 +1907,7 @@ tBTM_STATUS btm_sec_mx_access_request(const RawAddress& bd_addr, 
    }



    /* the new security request */

    if (p_dev_rec->sec_rec.sec_state != BTM_SEC_STATE_IDLE) {

    if (p_dev_rec->sec_rec.sec_state != tSECURITY_STATE::BTM_SEC_STATE_IDLE) {

      log::debug("A pending security procedure in progress");

      rc = BTM_CMD_STARTED;

    }
@@ -2195,11 +2196,12 @@ void btm_sec_abort_access_req(const RawAddress& bd_addr) { 


  if (!p_dev_rec) return;



  if ((p_dev_rec->sec_rec.sec_state != BTM_SEC_STATE_AUTHORIZING) &&

      (p_dev_rec->sec_rec.sec_state != BTM_SEC_STATE_AUTHENTICATING))

  if ((p_dev_rec->sec_rec.sec_state != tSECURITY_STATE::BTM_SEC_STATE_AUTHORIZING) &&

      (p_dev_rec->sec_rec.sec_state != tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING)) {

    return;

  }



  p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_IDLE;

  p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_IDLE;



  log::verbose("clearing callback. p_dev_rec={}, p_callback={}",

               fmt::ptr(p_dev_rec), fmt::ptr(p_dev_rec->sec_rec.p_callback));
@@ -2300,7 +2302,7 @@ void btm_sec_rmt_name_request_complete(const RawAddress* p_bd_addr, 
    log::info(

        "Remote read request complete with no address so searching device "

        "database");

    p_dev_rec = btm_sec_find_dev_by_sec_state(BTM_SEC_STATE_GETTING_NAME);

    p_dev_rec = btm_sec_find_dev_by_sec_state(tSECURITY_STATE::BTM_SEC_STATE_GETTING_NAME);

    if (p_dev_rec) {

      p_bd_addr = &p_dev_rec->bd_addr;

    }
@@ -2359,8 +2361,9 @@ void btm_sec_rmt_name_request_complete(const RawAddress* p_bd_addr, 


  // Security procedure resumes

  tSECURITY_STATE old_sec_state = p_dev_rec->sec_rec.sec_state;

  if (p_dev_rec->sec_rec.sec_state == BTM_SEC_STATE_GETTING_NAME)

    p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_IDLE;

  if (p_dev_rec->sec_rec.sec_state == tSECURITY_STATE::BTM_SEC_STATE_GETTING_NAME) {

    p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_IDLE;

  }



  /* If we were delaying asking UI for a PIN because name was not resolved,

   * ask now */
@@ -2482,7 +2485,9 @@ void btm_sec_rmt_name_request_complete(const RawAddress* p_bd_addr, 
    return;

  }



  if (old_sec_state != BTM_SEC_STATE_GETTING_NAME) return;

  if (old_sec_state != tSECURITY_STATE::BTM_SEC_STATE_GETTING_NAME) {

    return;

  }



  /* If get name failed, notify the waiting layer */

  if (status != HCI_SUCCESS) {
@@ -2960,7 +2965,7 @@ void btm_simple_pair_complete(const RawAddress bd_addr, uint8_t status) { 
    /* stop the timer */

    alarm_cancel(btm_sec_cb.pairing_timer);



    if (p_dev_rec->sec_rec.sec_state != BTM_SEC_STATE_AUTHENTICATING) {

    if (p_dev_rec->sec_rec.sec_state != tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING) {

      /* the initiating side: will receive auth complete event. disconnect ACL

       * at that time */

      disc = true;
@@ -3061,9 +3066,9 @@ static void btm_sec_auth_collision(uint16_t handle) { 
  if ((bluetooth::common::time_get_os_boottime_ms() -

       btm_sec_cb.collision_start_time) < BTM_SEC_MAX_COLLISION_DELAY) {

    if (handle == HCI_INVALID_HANDLE) {

      p_dev_rec = btm_sec_find_dev_by_sec_state(BTM_SEC_STATE_AUTHENTICATING);

      p_dev_rec = btm_sec_find_dev_by_sec_state(tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING);

      if (p_dev_rec == NULL)

        p_dev_rec = btm_sec_find_dev_by_sec_state(BTM_SEC_STATE_ENCRYPTING);

        p_dev_rec = btm_sec_find_dev_by_sec_state(tSECURITY_STATE::BTM_SEC_STATE_ENCRYPTING);

    } else

      p_dev_rec = btm_find_dev_by_handle(handle);
@@ -3071,9 +3076,10 @@ static void btm_sec_auth_collision(uint16_t handle) { 
      log::verbose("btm_sec_auth_collision: state {} (retrying in a moment...)",

                   p_dev_rec->sec_rec.sec_state);

      /* We will restart authentication after timeout */

      if (p_dev_rec->sec_rec.sec_state == BTM_SEC_STATE_AUTHENTICATING ||

          p_dev_rec->sec_rec.is_security_state_bredr_encrypting())

        p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_IDLE;

      if (p_dev_rec->sec_rec.sec_state == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING ||

          p_dev_rec->sec_rec.is_security_state_bredr_encrypting()) {

        p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_IDLE;

      }



      btm_sec_cb.p_collided_dev_rec = p_dev_rec;

      alarm_set_on_mloop(btm_sec_cb.sec_collision_timer, BT_1SEC_TIMEOUT_MS,
@@ -3118,7 +3124,7 @@ static bool btm_sec_auth_retry(uint16_t handle, uint8_t status) { 
       controller.

       If the stack may sit on top of other controller, we may need this

       BTM_DeleteStoredLinkKey (bd_addr, NULL); */

    p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_IDLE;

    p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_IDLE;

    btm_sec_execute_procedure(p_dev_rec);

    return true;

  }
@@ -3171,8 +3177,8 @@ void btm_sec_auth_complete(uint16_t handle, tHCI_STATUS status) { 


  if (!p_dev_rec) return;



  if (p_dev_rec->sec_rec.sec_state == BTM_SEC_STATE_AUTHENTICATING) {

    p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_IDLE;

  if (p_dev_rec->sec_rec.sec_state == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING) {

    p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_IDLE;

    was_authenticating = true;

    /* There can be a race condition, when we are starting authentication

     * and the peer device is doing encryption.
@@ -3440,8 +3446,8 @@ void btm_sec_encrypt_change(uint16_t handle, tHCI_STATUS status, 


  /* If this encryption was started by peer do not need to do anything */

  if (!p_dev_rec->sec_rec.is_security_state_bredr_encrypting()) {

    if (BTM_SEC_STATE_DELAY_FOR_ENC == p_dev_rec->sec_rec.sec_state) {

      p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_IDLE;

    if (tSECURITY_STATE::BTM_SEC_STATE_DELAY_FOR_ENC == p_dev_rec->sec_rec.sec_state) {

      p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_IDLE;

      log::verbose("clearing callback. p_dev_rec={}, p_callback={}",

                   fmt::ptr(p_dev_rec),

                   fmt::ptr(p_dev_rec->sec_rec.p_callback));
@@ -3449,8 +3455,8 @@ void btm_sec_encrypt_change(uint16_t handle, tHCI_STATUS status, 
      l2cu_resubmit_pending_sec_req(&p_dev_rec->bd_addr);

      return;

    } else if (!concurrentPeerAuthIsEnabled() &&

               p_dev_rec->sec_rec.sec_state == BTM_SEC_STATE_AUTHENTICATING) {

      p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_IDLE;

               p_dev_rec->sec_rec.sec_state == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING) {

      p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_IDLE;

      return;

    }

    if (!handleUnexpectedEncryptionChange()) {
@@ -3458,7 +3464,7 @@ void btm_sec_encrypt_change(uint16_t handle, tHCI_STATUS status, 
    }

  }



  p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_IDLE;

  p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_IDLE;

  /* If encryption setup failed, notify the waiting layer */

  if (status != HCI_SUCCESS) {

    btm_sec_dev_rec_cback_event(p_dev_rec, BTM_ERR_PROCESSING, false);
@@ -4037,12 +4043,12 @@ void btm_sec_disconnected(uint16_t handle, tHCI_REASON reason, 
    return;

  }



  if (p_dev_rec->sec_rec.sec_state == BTM_SEC_STATE_DISCONNECTING_BOTH) {

  if (p_dev_rec->sec_rec.sec_state == tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BOTH) {

    log::debug("Waiting for other transport to disconnect current:{}",

               bt_transport_text(transport));

    p_dev_rec->sec_rec.sec_state = (transport == BT_TRANSPORT_LE)

                                       ? BTM_SEC_STATE_DISCONNECTING

                                       : BTM_SEC_STATE_DISCONNECTING_BLE;

                                           ? tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING

                                           : tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BLE;

    return;

  }
@@ -4055,14 +4061,14 @@ void btm_sec_disconnected(uint16_t handle, tHCI_REASON reason, 
      return;

    }



    if (p_dev_rec->sec_rec.sec_state == BTM_SEC_STATE_LE_ENCRYPTING &&

    if (p_dev_rec->sec_rec.sec_state == tSECURITY_STATE::BTM_SEC_STATE_LE_ENCRYPTING &&

        transport != BT_TRANSPORT_LE) {

      log::debug("Disconnection on the other transport while encrypting LE");

      return;

    }



    if ((p_dev_rec->sec_rec.sec_state == BTM_SEC_STATE_AUTHENTICATING ||

         p_dev_rec->sec_rec.sec_state == BTM_SEC_STATE_ENCRYPTING) &&

    if ((p_dev_rec->sec_rec.sec_state == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING ||

         p_dev_rec->sec_rec.sec_state == tSECURITY_STATE::BTM_SEC_STATE_ENCRYPTING) &&

        transport != BT_TRANSPORT_BR_EDR) {

      log::debug(

          "Disconnection on the other transport while encrypting BR/EDR");
@@ -4070,7 +4076,7 @@ void btm_sec_disconnected(uint16_t handle, tHCI_REASON reason, 
    }

  }



  p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_IDLE;

  p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_IDLE;

  p_dev_rec->sec_rec.security_required = BTM_SEC_NONE;



  if (p_dev_rec->sec_rec.p_callback != nullptr) {
@@ -4278,7 +4284,7 @@ void btm_sec_link_key_request(const RawAddress bda) { 


  log::verbose("bda: {}", bda);

  if (!concurrentPeerAuthIsEnabled()) {

    p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_AUTHENTICATING;

    p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING;

  }



  if ((btm_sec_cb.pairing_state == BTM_PAIR_STATE_WAIT_PIN_REQ) &&
@@ -4606,8 +4612,8 @@ tBTM_STATUS btm_sec_execute_procedure(tBTM_SEC_DEV_REC* p_dev_rec) { 
          static_cast<tSECURITY_STATE>(p_dev_rec->sec_rec.sec_state)),

      p_dev_rec->sec_rec.sec_state);



  if (p_dev_rec->sec_rec.sec_state != BTM_SEC_STATE_IDLE &&

      p_dev_rec->sec_rec.sec_state != BTM_SEC_STATE_LE_ENCRYPTING) {

  if (p_dev_rec->sec_rec.sec_state != tSECURITY_STATE::BTM_SEC_STATE_IDLE &&

      p_dev_rec->sec_rec.sec_state != tSECURITY_STATE::BTM_SEC_STATE_LE_ENCRYPTING) {

    log::info("No immediate action taken in busy state: {}",

              security_state_text(p_dev_rec->sec_rec.sec_state));

    return (BTM_CMD_STARTED);
@@ -4702,7 +4708,7 @@ tBTM_STATUS btm_sec_execute_procedure(tBTM_SEC_DEV_REC* p_dev_rec) { 
    log::verbose("Security Manager: Start encryption");



    btsnd_hcic_set_conn_encrypt(p_dev_rec->hci_handle, true);

    p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_ENCRYPTING;

    p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_ENCRYPTING;

    return (BTM_CMD_STARTED);

  } else {

    log::debug("Encryption not required");
@@ -4749,7 +4755,7 @@ static bool btm_sec_start_get_name(tBTM_SEC_DEV_REC* p_dev_rec) { 
    return false;

  }



  p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_GETTING_NAME;

  p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_GETTING_NAME;



  /* 0 and NULL are as timeout and callback params because they are not used in

   * security get name case */
@@ -4807,11 +4813,11 @@ static void btm_sec_auth_timer_timeout(void* data) { 
                                       p_dev_rec->sec_rec.p_ref_data,

                                       BTM_SUCCESS);

    }

  } else if (p_dev_rec->sec_rec.sec_state == BTM_SEC_STATE_AUTHENTICATING) {

  } else if (p_dev_rec->sec_rec.sec_state == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING) {

    log::info("device is in the process of authenticating");

  } else {

    log::info("starting authentication");

    p_dev_rec->sec_rec.sec_state = BTM_SEC_STATE_AUTHENTICATING;

    p_dev_rec->sec_rec.sec_state = tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING;

    btsnd_hcic_auth_request(p_dev_rec->hci_handle);

  }

}

system/stack/btm/security_device_record.h

+25 −27
Original line number Diff line number Diff line
@@ -154,7 +154,7 @@ enum : uint16_t { 
  BTM_SEC_16_DIGIT_PIN_AUTHED = 0x4000,

};



typedef enum : uint8_t {

enum class tSECURITY_STATE : uint8_t {

  BTM_SEC_STATE_IDLE = 0,

  BTM_SEC_STATE_AUTHENTICATING = 1,

  BTM_SEC_STATE_ENCRYPTING = 2,
@@ -169,23 +169,23 @@ typedef enum : uint8_t { 
  BTM_SEC_STATE_DISCONNECTING_BLE = 8,

  BTM_SEC_STATE_DISCONNECTING_BOTH = 9,

  BTM_SEC_STATE_LE_ENCRYPTING = 10,

} tSECURITY_STATE;

};



static inline std::string security_state_text(const tSECURITY_STATE& state) {

  switch (state) {

    CASE_RETURN_TEXT(BTM_SEC_STATE_IDLE);

    CASE_RETURN_TEXT(BTM_SEC_STATE_AUTHENTICATING);

    CASE_RETURN_TEXT(BTM_SEC_STATE_ENCRYPTING);

    CASE_RETURN_TEXT(BTM_SEC_STATE_GETTING_NAME);

    CASE_RETURN_TEXT(BTM_SEC_STATE_AUTHORIZING);

    CASE_RETURN_TEXT(BTM_SEC_STATE_SWITCHING_ROLE);

    CASE_RETURN_TEXT(BTM_SEC_STATE_DISCONNECTING);

    CASE_RETURN_TEXT(BTM_SEC_STATE_DELAY_FOR_ENC);

    CASE_RETURN_TEXT(BTM_SEC_STATE_DISCONNECTING_BLE);

    CASE_RETURN_TEXT(BTM_SEC_STATE_DISCONNECTING_BOTH);

    CASE_RETURN_TEXT(BTM_SEC_STATE_LE_ENCRYPTING);

    CASE_RETURN_STRING(tSECURITY_STATE::BTM_SEC_STATE_IDLE);

    CASE_RETURN_STRING(tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING);

    CASE_RETURN_STRING(tSECURITY_STATE::BTM_SEC_STATE_ENCRYPTING);

    CASE_RETURN_STRING(tSECURITY_STATE::BTM_SEC_STATE_GETTING_NAME);

    CASE_RETURN_STRING(tSECURITY_STATE::BTM_SEC_STATE_AUTHORIZING);

    CASE_RETURN_STRING(tSECURITY_STATE::BTM_SEC_STATE_SWITCHING_ROLE);

    CASE_RETURN_STRING(tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING);

    CASE_RETURN_STRING(tSECURITY_STATE::BTM_SEC_STATE_DELAY_FOR_ENC);

    CASE_RETURN_STRING(tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BLE);

    CASE_RETURN_STRING(tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BOTH);

    CASE_RETURN_STRING(tSECURITY_STATE::BTM_SEC_STATE_LE_ENCRYPTING);

    default:

      return base::StringPrintf("UNKNOWN[%hhu]", state);

      RETURN_UNKNOWN_TYPE_STRING(tSECURITY_STATE, state);

  }

}
@@ -304,42 +304,40 @@ struct tBTM_SEC_REC { 
    sec_flags &= ~BTM_SEC_16_DIGIT_PIN_AUTHED;

  }



  bool is_security_state_idle() const {

    return sec_state == BTM_SEC_STATE_IDLE;

  }

  bool is_security_state_idle() const { return sec_state == tSECURITY_STATE::BTM_SEC_STATE_IDLE; }

  bool is_security_state_authenticating() const {

    return sec_state == BTM_SEC_STATE_AUTHENTICATING;

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING;

  }

  bool is_security_state_bredr_encrypting() const {

    return sec_state == BTM_SEC_STATE_ENCRYPTING;

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_ENCRYPTING;

  }

  bool is_security_state_le_encrypting() const {

    return sec_state == BTM_SEC_STATE_LE_ENCRYPTING;

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_LE_ENCRYPTING;

  }

  bool is_security_state_encrypting() const {

    return (is_security_state_bredr_encrypting() ||

            is_security_state_le_encrypting());

  }

  bool is_security_state_getting_name() const {

    return sec_state == BTM_SEC_STATE_GETTING_NAME;

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_GETTING_NAME;

  }

  bool is_security_state_authorizing() const {

    return sec_state == BTM_SEC_STATE_AUTHORIZING;

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_AUTHORIZING;

  }

  bool is_security_state_switching_role() const {

    return sec_state == BTM_SEC_STATE_SWITCHING_ROLE;

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_SWITCHING_ROLE;

  }

  bool is_security_state_disconnecting() const {

    return sec_state == BTM_SEC_STATE_DISCONNECTING;

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING;

  }

  bool is_security_state_wait_for_encryption() const {

    return sec_state == BTM_SEC_STATE_DELAY_FOR_ENC;

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_DELAY_FOR_ENC;

  }

  bool is_security_state_ble_disconnecting() const {

    return sec_state == BTM_SEC_STATE_DISCONNECTING_BLE;

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BLE;

  }

  bool is_security_state_br_edr_and_ble() const {

    return sec_state == BTM_SEC_STATE_DISCONNECTING_BOTH;

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BOTH;

  }



  bool is_bond_type_unknown() const { return bond_type == BOND_TYPE_UNKNOWN; }