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

Commit 0ca6a08e authored by Hansong Zhang's avatar Hansong Zhang
Browse files

Get rid of p_cur_service in dev_rec 

Instead of storing the service for pending security requirements when we
pair a new device, we directly store the security requirement.

Bug: 159815595
Tag: #refactor
Test: compile & verify basic functions working
Change-Id: Ifc8114d952458320f72f422acc9f8b0b9b21bb0d
parent f460290e

system/stack/btm/btm_sec.cc

+20 −81
Original line number Diff line number Diff line
@@ -58,8 +58,6 @@ extern void bta_dm_remove_device(const RawAddress& bd_addr); 
 ******************************************************************************/

tBTM_SEC_SERV_REC* btm_sec_find_first_serv(bool is_originator, uint16_t psm);

static tBTM_SEC_SERV_REC* btm_sec_find_next_serv(tBTM_SEC_SERV_REC* p_cur);

static tBTM_SEC_SERV_REC* btm_sec_find_mx_serv(uint8_t is_originator,

                                               uint32_t mx_chan_id);

static bool btm_sec_start_get_name(tBTM_SEC_DEV_REC* p_dev_rec);

static void btm_sec_start_authentication(tBTM_SEC_DEV_REC* p_dev_rec);

static void btm_sec_start_encryption(tBTM_SEC_DEV_REC* p_dev_rec);
@@ -1623,8 +1621,8 @@ tBTM_STATUS btm_sec_l2cap_access_req(const RawAddress& bd_addr, uint16_t psm, 
    return (BTM_CMD_STARTED);

  }



  /* Save pointer to service record */

  p_dev_rec->p_cur_service = p_serv_rec;

  /* Save the security requirements in case a pairing is needed */

  p_dev_rec->required_security_flags_for_pairing = security_required;



  /* Modify security_required in btm_sec_l2cap_access_req for Lisbon */

  if (btm_cb.security_mode == BTM_SEC_MODE_SP ||
@@ -1751,10 +1749,9 @@ tBTM_STATUS btm_sec_l2cap_access_req(const RawAddress& bd_addr, uint16_t psm, 
    }

  }



  BTM_TRACE_EVENT(

      "%s() PSM:%d Handle:%d State:%d Flags: 0x%x Required: 0x%x Service ID:%d",

      __func__, psm, handle, p_dev_rec->sec_state, p_dev_rec->sec_flags,

      p_dev_rec->security_required, p_dev_rec->p_cur_service->service_id);

  BTM_TRACE_EVENT("%s() PSM:%d Handle:%d State:%d Flags: 0x%x Required: 0x%x",

                  __func__, psm, handle, p_dev_rec->sec_state,

                  p_dev_rec->sec_flags, p_dev_rec->security_required);



  rc = btm_sec_execute_procedure(p_dev_rec);

  if (rc != BTM_CMD_STARTED) {
@@ -1818,16 +1815,6 @@ tBTM_STATUS btm_sec_mx_access_request(const RawAddress& bd_addr, 


  auto requirement = legacy_stack_rfcomm_security_records[mx_chan_id];



  uint16_t sec_mask = BTM_SEC_OUT_ENCRYPT | BTM_SEC_OUT_AUTHENTICATE |

                      BTM_SEC_IN_ENCRYPT | BTM_SEC_IN_AUTHENTICATE;

  if (requirement.need_mitm) sec_mask |= BTM_SEC_OUT_MITM | BTM_SEC_IN_MITM;

  if (requirement.need_16_digit_pin) sec_mask |= BTM_SEC_IN_MIN_16_DIGIT_PIN;

  // Setting the legacy one is required for p_cur_serv for pairing

  if (!BTM_SetSecurityLevel(is_originator, "", requirement.service_id, sec_mask,

                            BT_PSM_RFCOMM, BTM_SEC_PROTO_RFCOMM, mx_chan_id)) {

    return BTM_NO_RESOURCES;

  }



  BTM_TRACE_DEBUG("%s() is_originator: %d", __func__, is_originator);

  /* Find or get oldest record */

  p_dev_rec = btm_find_or_alloc_dev(bd_addr);
@@ -1939,7 +1926,7 @@ tBTM_STATUS btm_sec_mx_access_request(const RawAddress& bd_addr, 
    }

  }



  p_dev_rec->p_cur_service = btm_sec_find_mx_serv(is_originator, mx_chan_id);

  p_dev_rec->required_security_flags_for_pairing = security_required;

  p_dev_rec->security_required = security_required;



  if (btm_cb.security_mode == BTM_SEC_MODE_SP ||
@@ -2361,9 +2348,7 @@ void btm_sec_rmt_name_request_complete(const RawAddress* p_bd_addr, 
      btm_cb.pairing_flags |= BTM_PAIR_FLAGS_PIN_REQD;

      (*btm_cb.api.p_pin_callback)(

          p_dev_rec->bd_addr, p_dev_rec->dev_class, p_bd_name,

          (p_dev_rec->p_cur_service == NULL)

              ? false

              : (p_dev_rec->p_cur_service->security_flags &

          (p_dev_rec->required_security_flags_for_pairing &

           BTM_SEC_IN_MIN_16_DIGIT_PIN));

    }
@@ -2576,15 +2561,9 @@ void btm_io_capabilities_req(const RawAddress& p) { 


  p_dev_rec->sm4 |= BTM_SM4_TRUE;



  BTM_TRACE_EVENT("%s: State: %s  Flags: 0x%04x  p_cur_service: 0x%08x",

                  __func__, btm_pair_state_descr(btm_cb.pairing_state),

                  btm_cb.pairing_flags, p_dev_rec->p_cur_service);



  if (p_dev_rec->p_cur_service) {

    BTM_TRACE_EVENT("%s: cur_service psm: 0x%04x, security_flags: 0x%04x",

                    __func__, p_dev_rec->p_cur_service->psm,

                    p_dev_rec->p_cur_service->security_flags);

  }

  BTM_TRACE_EVENT("%s: State: %s  Flags: 0x%04x", __func__,

                  btm_pair_state_descr(btm_cb.pairing_state),

                  btm_cb.pairing_flags);



  switch (btm_cb.pairing_state) {

    /* initiator connecting */
@@ -2648,16 +2627,17 @@ void btm_io_capabilities_req(const RawAddress& p) { 
  evt_data.is_orig = is_orig;



  if (is_orig) {

    /* local device initiated the pairing non-bonding -> use p_cur_service */

    /* local device initiated the pairing non-bonding -> use

     * required_security_flags_for_pairing */

    if (!(btm_cb.pairing_flags & BTM_PAIR_FLAGS_WE_STARTED_DD) &&

        p_dev_rec->p_cur_service &&

        (p_dev_rec->p_cur_service->security_flags & BTM_SEC_OUT_AUTHENTICATE)) {

        (p_dev_rec->required_security_flags_for_pairing &

         BTM_SEC_OUT_AUTHENTICATE)) {

      if (btm_cb.security_mode == BTM_SEC_MODE_SC) {

        /* SC only mode device requires MITM protection */

        evt_data.auth_req = BTM_AUTH_SP_YES;

      } else {

        evt_data.auth_req =

            (p_dev_rec->p_cur_service->security_flags & BTM_SEC_OUT_MITM)

            (p_dev_rec->required_security_flags_for_pairing & BTM_SEC_OUT_MITM)

                ? BTM_AUTH_SP_YES

                : BTM_AUTH_SP_NO;

      }
@@ -4313,9 +4293,7 @@ void btm_sec_pin_code_request(uint8_t* p_event) { 
      if (p_cb->api.p_pin_callback) {

        (*p_cb->api.p_pin_callback)(

            p_bda, p_dev_rec->dev_class, p_dev_rec->sec_bd_name,

            (p_dev_rec->p_cur_service == NULL)

                ? false

                : (p_dev_rec->p_cur_service->security_flags &

            (p_dev_rec->required_security_flags_for_pairing &

             BTM_SEC_IN_MIN_16_DIGIT_PIN));

      }

    } else {
@@ -4572,43 +4550,6 @@ static tBTM_SEC_SERV_REC* btm_sec_find_next_serv(tBTM_SEC_SERV_REC* p_cur) { 
  return (NULL);

}



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

 *

 * Function         btm_sec_find_mx_serv

 *

 * Description      Look for the record in the service database with specified

 *                  PSM and multiplexor channel information

 *

 * Returns          Pointer to the record or NULL

 *

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

static tBTM_SEC_SERV_REC* btm_sec_find_mx_serv(uint8_t is_originator,

                                               uint32_t mx_chan_id) {

  tBTM_SEC_SERV_REC* p_out_serv = btm_cb.p_out_serv;

  tBTM_SEC_SERV_REC* p_serv_rec = &btm_cb.sec_serv_rec[0];

  int i;



  BTM_TRACE_DEBUG("%s()", __func__);

  if (is_originator && p_out_serv && p_out_serv->psm == BT_PSM_RFCOMM &&

      p_out_serv->mx_proto_id == BTM_SEC_PROTO_RFCOMM &&

      p_out_serv->orig_mx_chan_id == mx_chan_id) {

    /* If this is outgoing connection and the parameters match p_out_serv,

     * use it as the current service */

    return btm_cb.p_out_serv;

  }



  /* otherwise, the old way */

  for (i = 0; i < BTM_SEC_MAX_SERVICE_RECORDS; i++, p_serv_rec++) {

    if ((p_serv_rec->security_flags & BTM_SEC_IN_USE) &&

        (p_serv_rec->psm == BT_PSM_RFCOMM) &&

        (p_serv_rec->mx_proto_id == BTM_SEC_PROTO_RFCOMM) &&

        ((is_originator && (p_serv_rec->orig_mx_chan_id == mx_chan_id)) ||

         (!is_originator && (p_serv_rec->term_mx_chan_id == mx_chan_id)))) {

      return (p_serv_rec);

    }

  }

  return (NULL);

}

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

 *

 * Function         btm_sec_collision_timeout
@@ -4873,9 +4814,7 @@ static bool btm_sec_check_prefetch_pin(tBTM_SEC_DEV_REC* p_dev_rec) { 
          btm_cb.pairing_flags |= BTM_PAIR_FLAGS_PIN_REQD;

        (btm_cb.api.p_pin_callback)(

            p_dev_rec->bd_addr, p_dev_rec->dev_class, p_dev_rec->sec_bd_name,

            (p_dev_rec->p_cur_service == NULL)

                ? false

                : (p_dev_rec->p_cur_service->security_flags &

            (p_dev_rec->required_security_flags_for_pairing &

             BTM_SEC_IN_MIN_16_DIGIT_PIN));

      }

    }

system/stack/btm/security_device_record.h

+1 −1
Original line number Diff line number Diff line
@@ -355,7 +355,7 @@ typedef uint8_t tBTM_BOND_TYPE; 
 * A record exists for each device authenticated with this device

 */

typedef struct {

  tBTM_SEC_SERV_REC* p_cur_service;

  uint32_t required_security_flags_for_pairing;

  tBTM_SEC_CALLBACK* p_callback;

  void* p_ref_data;

  uint32_t timestamp; /* Timestamp of the last connection   */