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

Commit 60ed51da authored by Hui Peng's avatar Hui Peng
Browse files

[Invisalign2] Encapsulate tBTM_SEC_CB::change_pairing_state 

Bug: 301661850
Test: m com.android.btservices
Flag: EXEMPT, mechanical refactor
Change-Id: Ie4a8ee23c9ce64ef77444f022427b9402bea4e41
parent 6eb676f4

system/stack/btm/btm_sec.cc

+67 −70
Original line number Diff line number Diff line
@@ -103,7 +103,6 @@ static void btm_sec_collision_timeout(void* data); 
static void btm_restore_mode(void);

static void btm_sec_pairing_timeout(void* data);

static tBTM_STATUS btm_sec_dd_create_conn(tBTM_SEC_DEV_REC* p_dev_rec);

static void btm_sec_change_pairing_state(tBTM_PAIRING_STATE new_state);



static void btm_sec_check_pending_reqs(void);

static bool btm_sec_queue_mx_request(const RawAddress& bd_addr, uint16_t psm,
@@ -521,13 +520,13 @@ void BTM_PINCodeReply(const RawAddress& bd_addr, tBTM_STATUS res, 
         (btm_sec_cb.pairing_flags & BTM_PAIR_FLAGS_DISC_WHEN_DONE))) {

      /* use BTM_PAIR_STATE_WAIT_AUTH_COMPLETE to report authentication failed

       * event */

      btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

      acl_set_disconnect_reason(HCI_ERR_HOST_REJECT_SECURITY);



      btsnd_hcic_pin_code_neg_reply(bd_addr);

    } else {

      p_dev_rec->sec_rec.security_required = BTM_SEC_NONE;

      btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

    }

    return;

  }
@@ -559,16 +558,16 @@ void BTM_PINCodeReply(const RawAddress& bd_addr, tBTM_STATUS res, 
      /* we change state little bit early so btm_sec_connected() will originate

       * connection */

      /*   when existing ACL link is down completely */

      btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_PIN_REQ);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_PIN_REQ);

    }

    /* if we already accepted incoming connection from pairing device */

    else if (p_dev_rec->sm4 & BTM_SM4_CONN_PEND) {

      LOG_WARN(

          "BTM_PINCodeReply(): link is connecting so wait pin code request "

          "from peer");

      btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_PIN_REQ);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_PIN_REQ);

    } else if (btm_sec_dd_create_conn(p_dev_rec) != BTM_CMD_STARTED) {

      btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

      p_dev_rec->sec_rec.sec_flags &= ~BTM_SEC_LINK_KEY_AUTHED;



      NotifyBondingChange(*p_dev_rec, HCI_ERR_AUTH_FAILURE);
@@ -576,7 +575,7 @@ void BTM_PINCodeReply(const RawAddress& bd_addr, tBTM_STATUS res, 
    return;

  }



  btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

  btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

  acl_set_disconnect_reason(HCI_SUCCESS);



  btsnd_hcic_pin_code_req_reply(bd_addr, pin_len, p_pin);
@@ -656,7 +655,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;

      btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

      return BTM_CMD_STARTED;

    }
@@ -693,7 +692,7 @@ tBTM_STATUS btm_sec_bond_by_transport(const RawAddress& bd_addr, 
  if (BTM_IsAclConnectionUpAndHandleValid(bd_addr, transport)) {

    btm_sec_wait_and_start_authentication(p_dev_rec);



    btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_PIN_REQ);

    btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_PIN_REQ);



    /* Mark lcb as bonding */

    l2cu_update_lcb_4_bonding(bd_addr, true);
@@ -713,11 +712,11 @@ tBTM_STATUS btm_sec_bond_by_transport(const RawAddress& bd_addr, 
      /* we are not accepting connection request from peer

       * -> RNR (to learn if peer is 2.1)

       * RNR when no ACL causes HCI_RMT_HOST_SUP_FEAT_NOTIFY_EVT */

      btm_sec_change_pairing_state(BTM_PAIR_STATE_GET_REM_NAME);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_GET_REM_NAME);

      status = BTM_ReadRemoteDeviceName(bd_addr, NULL, BT_TRANSPORT_BR_EDR);

    } else {

      /* We are accepting connection request from peer */

      btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_PIN_REQ);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_PIN_REQ);

      status = BTM_CMD_STARTED;

    }

    LOG_VERBOSE("State:%s sm4: 0x%x sec_state:%d",
@@ -731,7 +730,7 @@ tBTM_STATUS btm_sec_bond_by_transport(const RawAddress& bd_addr, 
  if (status != BTM_CMD_STARTED) {

    LOG_ERROR("BTM_ReadRemoteDeviceName or btm_sec_dd_create_conn error: 0x%x",

              (int)status);

    btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

    btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

  }



  return status;
@@ -1169,7 +1168,7 @@ void BTM_ConfirmReqReply(tBTM_STATUS res, const RawAddress& bd_addr) { 
  BTM_LogHistory(kBtmLogTag, bd_addr, "Confirm reply",

                 base::StringPrintf("status:%s", btm_status_text(res).c_str()));



  btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

  btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);



  if ((res == BTM_SUCCESS) || (res == BTM_SUCCESS_NO_SECURITY)) {

    acl_set_disconnect_reason(HCI_SUCCESS);
@@ -1224,7 +1223,7 @@ void BTM_PasskeyReqReply(tBTM_STATUS res, const RawAddress& bd_addr, 
      p_dev_rec->sec_rec.sec_flags &=

          ~(BTM_SEC_LINK_KEY_AUTHED | BTM_SEC_LINK_KEY_KNOWN);



      btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

      return;

    }

  } else if (btm_sec_cb.pairing_state != BTM_PAIR_STATE_KEY_ENTRY)
@@ -1232,7 +1231,7 @@ void BTM_PasskeyReqReply(tBTM_STATUS res, const RawAddress& bd_addr, 


  if (passkey > BTM_MAX_PASSKEY_VAL) res = BTM_ILLEGAL_VALUE;



  btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

  btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);



  if (res != BTM_SUCCESS) {

    /* use BTM_PAIR_STATE_WAIT_AUTH_COMPLETE to report authentication failed
@@ -1275,7 +1274,7 @@ void BTM_RemoteOobDataReply(tBTM_STATUS res, const RawAddress& bd_addr, 
  /* If timeout already expired or has been canceled, ignore the reply */

  if (btm_sec_cb.pairing_state != BTM_PAIR_STATE_WAIT_LOCAL_OOB_RSP) return;



  btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

  btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);



  if (res != BTM_SUCCESS) {

    /* use BTM_PAIR_STATE_WAIT_AUTH_COMPLETE to report authentication failed
@@ -1951,7 +1950,7 @@ static void btm_sec_bond_cancel_complete(void) { 
     */

    p_dev_rec = btm_find_dev(btm_sec_cb.pairing_bda);

    if (p_dev_rec != NULL) p_dev_rec->sec_rec.security_required = BTM_SEC_NONE;

    btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

    btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);



    /* Notify application that the cancel succeeded */

    if (btm_sec_cb.api.p_bond_cancel_cmpl_callback)
@@ -2115,7 +2114,7 @@ static tBTM_STATUS btm_sec_dd_create_conn(tBTM_SEC_DEV_REC* p_dev_rec) { 
    if (BTM_IsAclConnectionUp(p_dev_rec->bd_addr, BT_TRANSPORT_BR_EDR)) {

      return BTM_SUCCESS;

    }

    btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_PIN_REQ);

    btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_PIN_REQ);

    return BTM_CMD_STARTED;

  } else if (status == BTM_NO_RESOURCES) {

    return BTM_NO_RESOURCES;
@@ -2127,7 +2126,7 @@ static tBTM_STATUS btm_sec_dd_create_conn(tBTM_SEC_DEV_REC* p_dev_rec) { 
  LOG_INFO("Security Manager: %s",

           ADDRESS_TO_LOGGABLE_CSTR(p_dev_rec->bd_addr));



  btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_PIN_REQ);

  btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_PIN_REQ);



  return (BTM_CMD_STARTED);

}
@@ -2267,7 +2266,7 @@ void btm_sec_rmt_name_request_complete(const RawAddress* p_bd_addr, 
    }



    /* Set the same state again to force the timer to be restarted */

    btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_LOCAL_PIN);

    btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_LOCAL_PIN);

    return;

  }
@@ -2282,7 +2281,7 @@ void btm_sec_rmt_name_request_complete(const RawAddress* p_bd_addr, 
      }



      if (status != HCI_SUCCESS) {

        btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

        btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);



        return NotifyBondingChange(*p_dev_rec, status);

      }
@@ -2326,7 +2325,7 @@ void btm_sec_rmt_name_request_complete(const RawAddress* p_bd_addr, 
          } else if (req_status != BTM_CMD_STARTED) {

            LOG_WARN("failed to start connection");



            btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

            btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);



            NotifyBondingChange(*p_dev_rec, HCI_ERR_MEMORY_FULL);

          }
@@ -2560,7 +2559,7 @@ void btm_io_capabilities_req(RawAddress p) { 
  if (evt_data.bd_addr == btm_sec_cb.connecting_bda)

    memcpy(p_dev_rec->dev_class, btm_sec_cb.connecting_dc, DEV_CLASS_LEN);



  btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_LOCAL_IOCAPS);

  btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_LOCAL_IOCAPS);



  if (p_dev_rec->sm4 & BTM_SM4_UPGRADE) {

    p_dev_rec->sm4 &= ~BTM_SM4_UPGRADE;
@@ -2622,7 +2621,7 @@ void btm_io_capabilities_rsp(const tBTM_SP_IO_RSP evt_data) { 
  if (btm_sec_cb.pairing_state == BTM_PAIR_STATE_IDLE) {

    btm_sec_cb.pairing_bda = evt_data.bd_addr;



    btm_sec_change_pairing_state(BTM_PAIR_STATE_INCOMING_SSP);

    btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_INCOMING_SSP);



    /* work around for FW bug */

    btm_inq_stop_on_ssp();
@@ -2692,7 +2691,7 @@ void btm_proc_sp_req_evt(tBTM_SP_EVT event, const RawAddress bda, 
    switch (event) {

      case BTM_SP_CFM_REQ_EVT:

        /* Numeric confirmation. Need user to conf the passkey */

        btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_NUMERIC_CONFIRM);

        btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_NUMERIC_CONFIRM);



        /* The device record must be allocated in the "IO cap exchange" step */

        evt_data.cfm_req.num_val = value;
@@ -2744,13 +2743,13 @@ void btm_proc_sp_req_evt(tBTM_SP_EVT event, const RawAddress bda, 
        LOG_VERBOSE("BTM_SP_KEY_NOTIF_EVT:  passkey: %u",

                    evt_data.key_notif.passkey);



        btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

        btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

        break;



      case BTM_SP_KEY_REQ_EVT:

        if (btm_sec_cb.devcb.loc_io_caps != BTM_IO_CAP_NONE) {

          /* HCI_USER_PASSKEY_REQUEST_EVT */

          btm_sec_change_pairing_state(BTM_PAIR_STATE_KEY_ENTRY);

          btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_KEY_ENTRY);

        }

        break;

    }
@@ -2830,7 +2829,7 @@ void btm_simple_pair_complete(const RawAddress bd_addr, uint8_t status) { 
    p_dev_rec->sec_rec.sec_flags |= BTM_SEC_AUTHENTICATED;

  } else if (status == HCI_ERR_PAIRING_NOT_ALLOWED) {

    /* The test spec wants the peer device to get this failure code. */

    btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_DISCONNECT);

    btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_DISCONNECT);



    /* Change the timer to 1 second */

    alarm_set_on_mloop(btm_sec_cb.pairing_timer, BT_1SEC_TIMEOUT_MS,
@@ -2887,7 +2886,7 @@ void btm_rem_oob_req(const RawAddress bd_addr) { 
    strlcpy((char*)evt_data.bd_name, (char*)p_dev_rec->sec_bd_name,

            BTM_MAX_REM_BD_NAME_LEN + 1);



    btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_LOCAL_OOB_RSP);

    btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_LOCAL_OOB_RSP);

    if ((*btm_sec_cb.api.p_sp_callback)(BTM_SP_RMT_OOB_EVT,

                                        (tBTM_SP_EVT_DATA*)&evt_data) ==

        BTM_NOT_AUTHORIZED) {
@@ -3077,7 +3076,7 @@ void btm_sec_auth_complete(uint16_t handle, tHCI_STATUS status) { 
    if (btm_sec_cb.pairing_flags & BTM_PAIR_FLAGS_WE_STARTED_DD) {

      are_bonding = true;

    }

    btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

    btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

  }



  if (was_authenticating == false) {
@@ -3360,7 +3359,7 @@ static void btm_sec_connect_after_reject_timeout(void* /* data */) { 
  if (btm_sec_dd_create_conn(p_dev_rec) != BTM_CMD_STARTED) {

    LOG_WARN("Security Manager: failed to start connection");



    btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

    btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);



    NotifyBondingChange(*p_dev_rec, HCI_ERR_MEMORY_FULL);

  }
@@ -3404,7 +3403,7 @@ void btm_sec_connected(const RawAddress& bda, uint16_t handle, 
          btm_sec_cb.pairing_bda == bda) {

        LOG_WARN("Connection failed during bonding attempt peer:%s reason:%s",

                 ADDRESS_TO_LOGGABLE_CSTR(bda), hci_error_code_text(status).c_str());

        btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

        btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

      }



      LOG_DEBUG("Ignoring failed device connection peer:%s reason:%s",
@@ -3448,12 +3447,12 @@ void btm_sec_connected(const RawAddress& bda, uint16_t handle, 
          } else {

            /* remote device name is unknowm, start getting remote name first */



            btm_sec_change_pairing_state(BTM_PAIR_STATE_GET_REM_NAME);

            btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_GET_REM_NAME);

            if (BTM_ReadRemoteDeviceName(p_dev_rec->bd_addr, NULL,

                                         BT_TRANSPORT_BR_EDR) !=

                BTM_CMD_STARTED) {

              LOG_ERROR("cannot read remote name");

              btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

              btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

            }

          }

          return;
@@ -3483,11 +3482,11 @@ void btm_sec_connected(const RawAddress& bda, uint16_t handle, 
      btm_sec_cb.pairing_flags &= ~BTM_PAIR_FLAGS_REJECTED_CONNECT;

      if (BTM_SEC_IS_SM4_UNKNOWN(p_dev_rec->sm4)) {

        /* Try again: RNR when no ACL causes HCI_RMT_HOST_SUP_FEAT_NOTIFY_EVT */

        btm_sec_change_pairing_state(BTM_PAIR_STATE_GET_REM_NAME);

        btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_GET_REM_NAME);

        if (BTM_ReadRemoteDeviceName(bda, NULL, BT_TRANSPORT_BR_EDR) !=

            BTM_CMD_STARTED) {

          LOG_ERROR("cannot read remote name");

          btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

          btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

        }

        return;

      }
@@ -3526,7 +3525,7 @@ void btm_sec_connected(const RawAddress& bda, uint16_t handle, 
      LOG_VERBOSE("security_required:%x ",

                  p_dev_rec->sec_rec.security_required);



      btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);



      /* We need to notify host that the key is not known any more */

      NotifyBondingChange(*p_dev_rec, status);
@@ -3600,7 +3599,7 @@ void btm_sec_connected(const RawAddress& bda, uint16_t handle, 
    /* remember flag before it is initialized */

    const bool is_pair_flags_we_started_dd =

        btm_sec_cb.pairing_flags & BTM_PAIR_FLAGS_WE_STARTED_DD;

    btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

    btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);



    if (is_pair_flags_we_started_dd) {

      /* Let l2cap start bond timer */
@@ -3710,7 +3709,7 @@ void btm_sec_disconnected(uint16_t handle, tHCI_REASON reason, 
      (btm_sec_cb.pairing_bda == p_dev_rec->bd_addr)) {

    LOG_DEBUG("Disconnected while pairing process active handle:0x%04x",

              handle);

    btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

    btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

    p_dev_rec->sec_rec.sec_flags &= ~BTM_SEC_LINK_KEY_KNOWN;



    /* If the disconnection reason is REPEATED_ATTEMPTS,
@@ -3915,7 +3914,7 @@ void btm_sec_link_key_notification(const RawAddress& p_bda, 
    if (btm_sec_cb.pairing_flags & BTM_PAIR_FLAGS_WE_STARTED_DD)

      we_are_bonding = true;

    else

      btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

  }



  /* save LTK derived LK no matter what */
@@ -4053,7 +4052,7 @@ static void btm_sec_pairing_timeout(void* /* data */) { 
    case BTM_PAIR_STATE_WAIT_LOCAL_PIN:

      if ((btm_sec_cb.pairing_flags & BTM_PAIR_FLAGS_PRE_FETCH_PIN) == 0)

        btsnd_hcic_pin_code_neg_reply(p_cb->pairing_bda);

      btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

      /* We need to notify the UI that no longer need the PIN */

      if (btm_sec_cb.api.p_auth_complete_callback) {

        if (p_dev_rec == NULL) {
@@ -4067,14 +4066,14 @@ static void btm_sec_pairing_timeout(void* /* data */) { 


    case BTM_PAIR_STATE_WAIT_NUMERIC_CONFIRM:

      btsnd_hcic_user_conf_reply(p_cb->pairing_bda, false);

      /* btm_sec_change_pairing_state (BTM_PAIR_STATE_IDLE); */

      /* btm_sec_cb.change_pairing_state (BTM_PAIR_STATE_IDLE); */

      break;



    case BTM_PAIR_STATE_KEY_ENTRY:

      if (btm_sec_cb.devcb.loc_io_caps != BTM_IO_CAP_NONE) {

        btsnd_hcic_user_passkey_neg_reply(p_cb->pairing_bda);

      } else {

        btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

        btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

      }

      break;
@@ -4083,12 +4082,12 @@ static void btm_sec_pairing_timeout(void* /* data */) { 
      btsnd_hcic_io_cap_req_reply(p_cb->pairing_bda,

                                  btm_sec_cb.devcb.loc_io_caps, BTM_OOB_NONE,

                                  auth_req);

      btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

      break;



    case BTM_PAIR_STATE_WAIT_LOCAL_OOB_RSP:

      btsnd_hcic_rem_oob_neg_reply(p_cb->pairing_bda);

      btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

      break;



    case BTM_PAIR_STATE_WAIT_DISCONNECT:
@@ -4103,14 +4102,14 @@ static void btm_sec_pairing_timeout(void* /* data */) { 
      btm_sec_send_hci_disconnect(

          p_dev_rec, HCI_ERR_AUTH_FAILURE, p_dev_rec->hci_handle,

          "stack::btm::btm_sec::btm_sec_pairing_timeout");

      btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

      break;



    case BTM_PAIR_STATE_WAIT_AUTH_COMPLETE:

    case BTM_PAIR_STATE_GET_REM_NAME:

      /* We need to notify the UI that timeout has happened while waiting for

       * authentication*/

      btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

      if (btm_sec_cb.api.p_auth_complete_callback) {

        if (p_dev_rec == NULL) {

          name[0] = 0;
@@ -4125,7 +4124,7 @@ static void btm_sec_pairing_timeout(void* /* data */) { 
    default:

      LOG_WARN("not processed state: %s",

               tBTM_SEC_CB::btm_pair_state_descr(btm_sec_cb.pairing_state));

      btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);

      btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_IDLE);

      break;

  }

}
@@ -4183,7 +4182,7 @@ void btm_sec_pin_code_request(const RawAddress p_bda) { 


  if (!p_cb->pairing_disabled && (p_cb->cfg.pin_type == HCI_PIN_TYPE_FIXED)) {

    LOG_VERBOSE("btm_sec_pin_code_request fixed pin replying");

    btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

    btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

    btsnd_hcic_pin_code_req_reply(p_bda, p_cb->cfg.pin_code_len,

                                  p_cb->cfg.pin_code);

    return;
@@ -4209,7 +4208,7 @@ void btm_sec_pin_code_request(const RawAddress p_bda) { 
    /* is not forced to be secure - found a FW issue, so we can not do this

    btm_restore_mode(); */



    btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

    btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);

  }



  /* If pairing disabled OR (no PIN callback and not bonding) */
@@ -4236,7 +4235,7 @@ void btm_sec_pin_code_request(const RawAddress p_bda) { 
  }

  /* Notify upper layer of PIN request and start expiration timer */

  else {

    btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_LOCAL_PIN);

    btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_LOCAL_PIN);

    /* Pin code request can not come at the same time as connection request */

    p_cb->connecting_bda = p_bda;

    memcpy(p_cb->connecting_dc, p_dev_rec->dev_class, DEV_CLASS_LEN);
@@ -4594,47 +4593,45 @@ static void btm_restore_mode(void) { 


/*******************************************************************************

 *

 * Function         btm_sec_change_pairing_state

 * Function         change_pairing_state

 *

 * Description      This function is called to change pairing state

 *

 ******************************************************************************/

static void btm_sec_change_pairing_state(tBTM_PAIRING_STATE new_state) {

  tBTM_PAIRING_STATE old_state = btm_sec_cb.pairing_state;

void tBTM_SEC_CB::change_pairing_state(tBTM_PAIRING_STATE new_state) {

  tBTM_PAIRING_STATE old_state = pairing_state;



  LOG_DEBUG("Pairing state changed %s => %s pairing_flags:0x%x",

            tBTM_SEC_CB::btm_pair_state_descr(btm_sec_cb.pairing_state),

            tBTM_SEC_CB::btm_pair_state_descr(new_state),

            btm_sec_cb.pairing_flags);

            tBTM_SEC_CB::btm_pair_state_descr(pairing_state),

            tBTM_SEC_CB::btm_pair_state_descr(new_state), pairing_flags);



  if (btm_sec_cb.pairing_state != new_state) {

  if (pairing_state != new_state) {

    BTM_LogHistory(

        kBtmLogTag, btm_sec_cb.pairing_bda, "Pairing state changed",

        base::StringPrintf(

            "%s => %s",

            tBTM_SEC_CB::btm_pair_state_descr(btm_sec_cb.pairing_state),

        base::StringPrintf("%s => %s",

                           tBTM_SEC_CB::btm_pair_state_descr(pairing_state),

                           tBTM_SEC_CB::btm_pair_state_descr(new_state)));

  }

  btm_sec_cb.pairing_state = new_state;

  pairing_state = new_state;



  if (new_state == BTM_PAIR_STATE_IDLE) {

    alarm_cancel(btm_sec_cb.pairing_timer);

    alarm_cancel(pairing_timer);



    btm_sec_cb.pairing_flags = 0;

    btm_sec_cb.pin_code_len = 0;

    pairing_flags = 0;

    pin_code_len = 0;



    /* Make sure the the lcb shows we are not bonding */

    l2cu_update_lcb_4_bonding(btm_sec_cb.pairing_bda, false);

    l2cu_update_lcb_4_bonding(pairing_bda, false);



    btm_restore_mode();

    btm_sec_check_pending_reqs();

    btm_inq_clear_ssp();



    btm_sec_cb.pairing_bda = RawAddress::kAny;

    pairing_bda = RawAddress::kAny;

  } else {

    /* If transitioning out of idle, mark the lcb as bonding */

    if (old_state == BTM_PAIR_STATE_IDLE)

      l2cu_update_lcb_4_bonding(btm_sec_cb.pairing_bda, true);

      l2cu_update_lcb_4_bonding(pairing_bda, true);



    alarm_set_on_mloop(btm_sec_cb.pairing_timer, BTM_SEC_TIMEOUT_VALUE * 1000,

                       btm_sec_pairing_timeout, NULL);
@@ -4767,7 +4764,7 @@ static bool btm_sec_check_prefetch_pin(tBTM_SEC_DEV_REC* p_dev_rec) { 
      btsnd_hcic_write_auth_enable(true);

    }

  } else {

    btm_sec_change_pairing_state(BTM_PAIR_STATE_WAIT_LOCAL_PIN);

    btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_LOCAL_PIN);



    /* If we got a PIN, use that, else try to get one */

    if (btm_sec_cb.pin_code_len) {

system/stack/btm/btm_sec_cb.h

+2 −0
Original line number Diff line number Diff line
@@ -100,6 +100,8 @@ class tBTM_SEC_CB { 
  uint8_t RemoveServiceById(uint8_t service_id);

  uint8_t RemoveServiceByPsm(uint16_t psm);



  void change_pairing_state(tBTM_PAIRING_STATE new_state);



  // misc static methods

  static const char* btm_pair_state_descr(tBTM_PAIRING_STATE state);

};