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

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

Merge "stack::sec Simplify tSECURITY_STATE naming" into main am: df9aeb64 

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



Change-Id: Id4660de049d0a20f2b037b131143078cead4b0df
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents d1abbd1d df9aeb64

system/stack/btm/btm_ble_sec.cc

+7 −7
Original line number Diff line number Diff line
@@ -1067,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 == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING) {

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

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

     * the link */

    *p_sec_req_act = BTM_BLE_SEC_REQ_ACT_DISCARD;
@@ -1171,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 = tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING;

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

      }

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

  }



  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;

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

    p_rec->sec_rec.sec_state = tSECURITY_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 = tSECURITY_STATE::BTM_SEC_STATE_IDLE;

  p_dev_rec->sec_rec.sec_state = tSECURITY_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 = tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING;

          p_dev_rec->sec_rec.sec_state = tSECURITY_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 = tSECURITY_STATE::BTM_SEC_STATE_IDLE;

            p_dev_rec->sec_rec.sec_state = tSECURITY_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 = tSECURITY_STATE::BTM_SEC_STATE_IDLE;

  p_dev_rec->sec_rec.sec_state = tSECURITY_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
@@ -163,7 +163,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 = tSECURITY_STATE::BTM_SEC_STATE_IDLE;

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

  return true;

}

system/stack/btm/btm_sec.cc

+55 −57
Original line number Diff line number Diff line
@@ -720,7 +720,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 = tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING;

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

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

      return BTM_CMD_STARTED;

    }
@@ -872,7 +872,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 == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING) {

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

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

      if (SMP_PairCancel(bd_addr)) {

        return BTM_CMD_STARTED;
@@ -896,8 +896,8 @@ 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 == tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING) ||

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

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

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

        return (BTM_CMD_STARTED);

      }
@@ -1056,21 +1056,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 tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING:

      case tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BOTH:

      case tSECURITY_STATE::AUTHENTICATING:

      case tSECURITY_STATE::DISCONNECTING_BOTH:

        /* Applicable for both transports */

        enqueue = true;

        break;



      case tSECURITY_STATE::BTM_SEC_STATE_ENCRYPTING:

      case tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING:

      case tSECURITY_STATE::ENCRYPTING:

      case tSECURITY_STATE::DISCONNECTING:

        if (transport == BT_TRANSPORT_BR_EDR) {

          enqueue = true;

        }

        break;



      case tSECURITY_STATE::BTM_SEC_STATE_LE_ENCRYPTING:

      case tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BLE:

      case tSECURITY_STATE::LE_ENCRYPTING:

      case tSECURITY_STATE::DISCONNECTING_BLE:

        if (transport == BT_TRANSPORT_LE) {

          enqueue = true;

        }
@@ -1091,8 +1091,7 @@ tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr, 
      return BTM_CMD_STARTED;

    }

  } else {

    if (p_dev_rec->sec_rec.p_callback ||

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

    if (p_dev_rec->sec_rec.p_callback || (p_dev_rec->sec_rec.sec_state != tSECURITY_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);
@@ -1157,9 +1156,8 @@ tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr, 


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 == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING);

  return p_dev_rec && (p_dev_rec->sec_rec.is_security_state_encrypting() ||

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

}



/*******************************************************************************
@@ -1175,32 +1173,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 tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING:

    case tSECURITY_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 = tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BOTH;

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

      break;



    case tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BLE:

    case tSECURITY_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 = tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BOTH;

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

      break;



    case tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BOTH:

    case tSECURITY_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)

                                             ? tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING

                                             : tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BLE;

                                             ? tSECURITY_STATE::DISCONNECTING

                                             : tSECURITY_STATE::DISCONNECTING_BLE;



      break;

  }
@@ -1678,7 +1676,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 = tSECURITY_STATE::BTM_SEC_STATE_DELAY_FOR_ENC;

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

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



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



    /* the new security request */

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

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

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

      rc = BTM_CMD_STARTED;

    }
@@ -2150,12 +2148,12 @@ void btm_sec_abort_access_req(const RawAddress& bd_addr) { 


  if (!p_dev_rec) return;



  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)) {

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

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

    return;

  }



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

  p_dev_rec->sec_rec.sec_state = tSECURITY_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));
@@ -2256,7 +2254,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(tSECURITY_STATE::BTM_SEC_STATE_GETTING_NAME);

    p_dev_rec = btm_sec_find_dev_by_sec_state(tSECURITY_STATE::GETTING_NAME);

    if (p_dev_rec) {

      p_bd_addr = &p_dev_rec->bd_addr;

    }
@@ -2318,9 +2316,9 @@ void btm_sec_rmt_name_request_complete(const RawAddress* p_bd_addr, 


  // Security procedure resumes

  const bool is_security_state_getting_name =

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

          (p_dev_rec->sec_rec.sec_state == tSECURITY_STATE::GETTING_NAME);

  if (is_security_state_getting_name) {

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

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

  }



  /* If we were delaying asking UI for a PIN because name was not resolved,
@@ -2926,7 +2924,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 != tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING) {

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

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

       * at that time */

      disc = true;
@@ -3027,9 +3025,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(tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING);

      p_dev_rec = btm_sec_find_dev_by_sec_state(tSECURITY_STATE::AUTHENTICATING);

      if (p_dev_rec == NULL)

        p_dev_rec = btm_sec_find_dev_by_sec_state(tSECURITY_STATE::BTM_SEC_STATE_ENCRYPTING);

        p_dev_rec = btm_sec_find_dev_by_sec_state(tSECURITY_STATE::ENCRYPTING);

    } else

      p_dev_rec = btm_find_dev_by_handle(handle);
@@ -3037,9 +3035,9 @@ 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 == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING ||

      if (p_dev_rec->sec_rec.sec_state == tSECURITY_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;

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

      }



      btm_sec_cb.p_collided_dev_rec = p_dev_rec;
@@ -3085,7 +3083,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 = tSECURITY_STATE::BTM_SEC_STATE_IDLE;

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

    btm_sec_execute_procedure(p_dev_rec);

    return true;

  }
@@ -3138,8 +3136,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 == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING) {

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

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

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

    was_authenticating = true;

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

     * and the peer device is doing encryption.
@@ -3407,8 +3405,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 (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;

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

      p_dev_rec->sec_rec.sec_state = tSECURITY_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));
@@ -3416,8 +3414,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 == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING) {

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

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

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

      return;

    }

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

  }



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

  p_dev_rec->sec_rec.sec_state = tSECURITY_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);
@@ -4004,12 +4002,12 @@ void btm_sec_disconnected(uint16_t handle, tHCI_REASON reason, 
    return;

  }



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

  if (p_dev_rec->sec_rec.sec_state == tSECURITY_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)

                                           ? tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING

                                           : tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BLE;

                                           ? tSECURITY_STATE::DISCONNECTING

                                           : tSECURITY_STATE::DISCONNECTING_BLE;

    return;

  }
@@ -4022,14 +4020,14 @@ void btm_sec_disconnected(uint16_t handle, tHCI_REASON reason, 
      return;

    }



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

    if (p_dev_rec->sec_rec.sec_state == tSECURITY_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 == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING ||

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

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

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

        transport != BT_TRANSPORT_BR_EDR) {

      log::debug(

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

  }



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

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

  p_dev_rec->sec_rec.security_required = BTM_SEC_NONE;



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


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

  if (!concurrentPeerAuthIsEnabled()) {

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

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

  }



  if ((btm_sec_cb.pairing_state == BTM_PAIR_STATE_WAIT_PIN_REQ) &&
@@ -4575,8 +4573,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 != tSECURITY_STATE::BTM_SEC_STATE_IDLE &&

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

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

      p_dev_rec->sec_rec.sec_state != tSECURITY_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);
@@ -4671,7 +4669,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 = tSECURITY_STATE::BTM_SEC_STATE_ENCRYPTING;

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

    return (BTM_CMD_STARTED);

  } else {

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

  }



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

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



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

   * security get name case */
@@ -4776,11 +4774,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 == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING) {

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

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

  } else {

    log::info("starting authentication");

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

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

    btsnd_hcic_auth_request(p_dev_rec->hci_handle);

  }

}

system/stack/btm/security_device_record.h

+33 −37
Original line number Diff line number Diff line
@@ -155,35 +155,35 @@ enum : uint16_t { 
};



enum class tSECURITY_STATE : uint8_t {

  BTM_SEC_STATE_IDLE = 0,

  BTM_SEC_STATE_AUTHENTICATING = 1,

  BTM_SEC_STATE_ENCRYPTING = 2,

  BTM_SEC_STATE_GETTING_NAME = 3,

  BTM_SEC_STATE_AUTHORIZING = 4,

  BTM_SEC_STATE_SWITCHING_ROLE = 5,

  IDLE = 0,

  AUTHENTICATING = 1,

  ENCRYPTING = 2,

  GETTING_NAME = 3,

  AUTHORIZING = 4,

  SWITCHING_ROLE = 5,

  /* disconnecting BR/EDR */

  BTM_SEC_STATE_DISCONNECTING = 6,

  DISCONNECTING = 6,

  /* delay to check for encryption to work around */

  /* controller problems */

  BTM_SEC_STATE_DELAY_FOR_ENC = 7,

  BTM_SEC_STATE_DISCONNECTING_BLE = 8,

  BTM_SEC_STATE_DISCONNECTING_BOTH = 9,

  BTM_SEC_STATE_LE_ENCRYPTING = 10,

  DELAY_FOR_ENC = 7,

  DISCONNECTING_BLE = 8,

  DISCONNECTING_BOTH = 9,

  LE_ENCRYPTING = 10,

};



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

  switch (state) {

    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);

    CASE_RETURN_STRING(tSECURITY_STATE::IDLE);

    CASE_RETURN_STRING(tSECURITY_STATE::AUTHENTICATING);

    CASE_RETURN_STRING(tSECURITY_STATE::ENCRYPTING);

    CASE_RETURN_STRING(tSECURITY_STATE::GETTING_NAME);

    CASE_RETURN_STRING(tSECURITY_STATE::AUTHORIZING);

    CASE_RETURN_STRING(tSECURITY_STATE::SWITCHING_ROLE);

    CASE_RETURN_STRING(tSECURITY_STATE::DISCONNECTING);

    CASE_RETURN_STRING(tSECURITY_STATE::DELAY_FOR_ENC);

    CASE_RETURN_STRING(tSECURITY_STATE::DISCONNECTING_BLE);

    CASE_RETURN_STRING(tSECURITY_STATE::DISCONNECTING_BOTH);

    CASE_RETURN_STRING(tSECURITY_STATE::LE_ENCRYPTING);

    default:

      RETURN_UNKNOWN_TYPE_STRING(tSECURITY_STATE, state);

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

  }



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

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

  bool is_security_state_authenticating() const {

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_AUTHENTICATING;

    return sec_state == tSECURITY_STATE::AUTHENTICATING;

  }

  bool is_security_state_bredr_encrypting() const {

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_ENCRYPTING;

    return sec_state == tSECURITY_STATE::ENCRYPTING;

  }

  bool is_security_state_le_encrypting() const {

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_LE_ENCRYPTING;

    return sec_state == tSECURITY_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 == tSECURITY_STATE::BTM_SEC_STATE_GETTING_NAME;

  }

  bool is_security_state_authorizing() const {

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_AUTHORIZING;

  }

  bool is_security_state_getting_name() const { return sec_state == tSECURITY_STATE::GETTING_NAME; }

  bool is_security_state_authorizing() const { return sec_state == tSECURITY_STATE::AUTHORIZING; }

  bool is_security_state_switching_role() const {

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_SWITCHING_ROLE;

    return sec_state == tSECURITY_STATE::SWITCHING_ROLE;

  }

  bool is_security_state_disconnecting() const {

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING;

    return sec_state == tSECURITY_STATE::DISCONNECTING;

  }

  bool is_security_state_wait_for_encryption() const {

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_DELAY_FOR_ENC;

    return sec_state == tSECURITY_STATE::DELAY_FOR_ENC;

  }

  bool is_security_state_ble_disconnecting() const {

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BLE;

    return sec_state == tSECURITY_STATE::DISCONNECTING_BLE;

  }

  bool is_security_state_br_edr_and_ble() const {

    return sec_state == tSECURITY_STATE::BTM_SEC_STATE_DISCONNECTING_BOTH;

    return sec_state == tSECURITY_STATE::DISCONNECTING_BOTH;

  }



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