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

Commit 3ee8569b authored by android-build-team Robot's avatar android-build-team Robot
Browse files

Snap for 5907400 from e870e2b4 to qt-qpr1-release 

Change-Id: Ie35fb4ed3af0aa89ca6b9508c7b38d6f02a4a377
parents 404d4329 e870e2b4

system/btcore/src/device_class.cc

+3 −1
Original line number Diff line number Diff line
@@ -88,7 +88,9 @@ void device_class_from_int(bt_device_class_t* dc, int data) { 
int device_class_to_int(const bt_device_class_t* dc) {

  CHECK(dc != NULL);

  // Careful with endianess.

  return (int)(le32toh(*(int*)dc) & 0xffffff);

  int val = 0;

  memcpy(&val, dc, sizeof(*dc));

  return static_cast<int>(le32toh(val) & 0xffffff);

}



bool device_class_equals(const bt_device_class_t* p1,

system/btcore/test/device_class_test.cc

+24 −15
Original line number Diff line number Diff line
@@ -22,9 +22,6 @@ 


#include "btcore/include/device_class.h"



// Device Class is 3 bytes.

static const int DC_MASK = 0xffffff;



::testing::AssertionResult check_bitfield(const char* m_expr,

                                          const char* n_expr, int m, int n) {

  if (m == n) return ::testing::AssertionSuccess();
@@ -84,8 +81,9 @@ TEST_F(DeviceClassTest, to_stream) { 
    int rc = device_class_to_stream(&dc, dc_stream1, sizeof(dc_stream1));

    EXPECT_EQ(3, rc);



    uint32_t* val = (uint32_t*)&dc;

    EXPECT_PRED_FORMAT2(check_bitfield, 0x00000000, *val & 0xffffff);

    uint32_t val = 0;

    memcpy(&val, &dc, sizeof(dc));

    EXPECT_PRED_FORMAT2(check_bitfield, 0x00000000, val);



    EXPECT_PRED_FORMAT2(check_bitfield, 0x00, dc_stream1[0]);

    EXPECT_PRED_FORMAT2(check_bitfield, 0x00, dc_stream1[1]);
@@ -101,8 +99,9 @@ TEST_F(DeviceClassTest, to_stream) { 


    int rc = device_class_to_stream(&dc, dc_stream1, sizeof(dc_stream1));

    EXPECT_EQ(3, rc);

    uint32_t* val = (uint32_t*)&dc;

    EXPECT_PRED_FORMAT2(check_bitfield, 0x00aa55aa, *val & 0xffffff);

    uint32_t val = 0;

    memcpy(&val, &dc, sizeof(dc));

    EXPECT_PRED_FORMAT2(check_bitfield, 0x00aa55aa, val);



    EXPECT_PRED_FORMAT2(check_bitfield, 0xaa, dc_stream1[0]);

    EXPECT_PRED_FORMAT2(check_bitfield, 0x55, dc_stream1[1]);
@@ -118,8 +117,9 @@ TEST_F(DeviceClassTest, to_stream) { 


    int rc = device_class_to_stream(&dc, dc_stream1, sizeof(dc_stream1));

    EXPECT_EQ(3, rc);

    uint32_t* val = (uint32_t*)&dc;

    EXPECT_PRED_FORMAT2(check_bitfield, 0x452301, *val & 0xffffff);

    uint32_t val = 0;

    memcpy(&val, &dc, sizeof(dc));

    EXPECT_PRED_FORMAT2(check_bitfield, 0x452301, val);



    EXPECT_PRED_FORMAT2(check_bitfield, 0x01, dc_stream1[0]);

    EXPECT_PRED_FORMAT2(check_bitfield, 0x23, dc_stream1[1]);
@@ -131,24 +131,33 @@ TEST_F(DeviceClassTest, limited_discoverable_mode) { 
  uint8_t dc_stream[] = {0x00, 0x00, 0x00};

  bt_device_class_t dc;

  device_class_from_stream(&dc, dc_stream);

  uint32_t* test = (uint32_t*)&dc;

  uint32_t test = 0;

  memcpy(&test, &dc, sizeof(dc));



  EXPECT_FALSE(device_class_get_limited(&dc));

  EXPECT_EQ((unsigned)0x00000000, *test & DC_MASK);

  EXPECT_EQ((unsigned)0x00000000, test);



  device_class_set_limited(&dc, true);

  test = 0;

  memcpy(&test, &dc, sizeof(dc));

  EXPECT_TRUE(device_class_get_limited(&dc));

  EXPECT_EQ((unsigned)0x00002000, *test & DC_MASK);

  EXPECT_EQ((unsigned)0x00002000, test);



  device_class_set_limited(&dc, false);

  test = 0;

  memcpy(&test, &dc, sizeof(dc));

  EXPECT_FALSE(device_class_get_limited(&dc));

  EXPECT_EQ((unsigned)0x00000000, *test & DC_MASK);

  EXPECT_EQ((unsigned)0x00000000, test);



  device_class_set_limited(&dc, true);

  EXPECT_PRED_FORMAT2(check_bitfield, 0x00002000, *test & DC_MASK);

  test = 0;

  memcpy(&test, &dc, sizeof(dc));

  EXPECT_PRED_FORMAT2(check_bitfield, 0x00002000, test);



  device_class_set_limited(&dc, false);

  EXPECT_PRED_FORMAT2(check_bitfield, 0x00000000, *test & DC_MASK);

  test = 0;

  memcpy(&test, &dc, sizeof(dc));

  EXPECT_PRED_FORMAT2(check_bitfield, 0x00000000, test);

}



TEST_F(DeviceClassTest, equals) {

system/stack/btm/btm_ble_connection_establishment.cc

+1 −0
Original line number Diff line number Diff line
@@ -159,6 +159,7 @@ void btm_ble_conn_complete(uint8_t* p, UNUSED_ATTR uint16_t evt_len, 
        if (!btm_ble_init_pseudo_addr(match_rec, bda)) {

          /* assign the original address to be the current report address */

          bda = match_rec->ble.pseudo_addr;

          bda_type = match_rec->ble.ble_addr_type;

        } else {

          bda = match_rec->bd_addr;

        }

system/stack/btm/btm_ble_gap.cc

+1 −0
Original line number Diff line number Diff line
@@ -1755,6 +1755,7 @@ void btm_ble_process_adv_addr(RawAddress& bda, uint8_t* addr_type) { 
      } else {

        // Assign the original address to be the current report address

        bda = match_rec->ble.pseudo_addr;

        *addr_type = match_rec->ble.ble_addr_type;

      }

    }

  }

system/stack/sdp/sdp_discovery.cc

+17 −6
Original line number Diff line number Diff line
@@ -334,11 +334,13 @@ static void process_service_search_rsp(tCONN_CB* p_ccb, uint8_t* p_reply, 
 * Description      copy the raw data

 *

 *

 * Returns          void

 * Returns          bool

 *                          true if successful

 *                          false if not copied

 *

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

#if (SDP_RAW_DATA_INCLUDED == TRUE)

static void sdp_copy_raw_data(tCONN_CB* p_ccb, bool offset) {

static bool sdp_copy_raw_data(tCONN_CB* p_ccb, bool offset) {

  unsigned int cpy_len, rem_len;

  uint32_t list_len;

  uint8_t* p;
@@ -358,11 +360,11 @@ static void sdp_copy_raw_data(tCONN_CB* p_ccb, bool offset) { 
      p = sdpu_get_len_from_type(p, p_end, type, &list_len);

      if (p == NULL || (p + list_len) > p_end) {

        SDP_TRACE_WARNING("%s: bad length", __func__);

        return;

        return false;

      }

      if ((int)cpy_len < (p - old_p)) {

        SDP_TRACE_WARNING("%s: no bytes left for data", __func__);

        return;

        return false;

      }

      cpy_len -= (p - old_p);

    }
@@ -377,6 +379,7 @@ static void sdp_copy_raw_data(tCONN_CB* p_ccb, bool offset) { 
    memcpy(&p_ccb->p_db->raw_data[p_ccb->p_db->raw_used], p, cpy_len);

    p_ccb->p_db->raw_used += cpy_len;

  }

  return true;

}

#endif
@@ -430,7 +433,11 @@ static void process_service_attr_rsp(tCONN_CB* p_ccb, uint8_t* p_reply, 
    } else {

#if (SDP_RAW_DATA_INCLUDED == TRUE)

      SDP_TRACE_WARNING("process_service_attr_rsp");

      sdp_copy_raw_data(p_ccb, false);

      if (!sdp_copy_raw_data(p_ccb, false)) {

        SDP_TRACE_ERROR("sdp_copy_raw_data failed");

        sdp_disconnect(p_ccb, SDP_ILLEGAL_PARAMETER);

      }



#endif



      /* Save the response in the database. Stop on any error */
@@ -632,7 +639,10 @@ static void process_service_search_attr_rsp(tCONN_CB* p_ccb, uint8_t* p_reply, 


#if (SDP_RAW_DATA_INCLUDED == TRUE)

  SDP_TRACE_WARNING("process_service_search_attr_rsp");

  sdp_copy_raw_data(p_ccb, true);

  if (!sdp_copy_raw_data(p_ccb, true)) {

    SDP_TRACE_ERROR("sdp_copy_raw_data failed");

    sdp_disconnect(p_ccb, SDP_ILLEGAL_PARAMETER);

  }

#endif



  p = &p_ccb->rsp_list[0];
@@ -647,6 +657,7 @@ static void process_service_search_attr_rsp(tCONN_CB* p_ccb, uint8_t* p_reply, 
  p = sdpu_get_len_from_type(p, p + p_ccb->list_len, type, &seq_len);

  if (p == NULL || (p + seq_len) > (p + p_ccb->list_len)) {

    SDP_TRACE_WARNING("%s: bad length", __func__);

    sdp_disconnect(p_ccb, SDP_ILLEGAL_PARAMETER);

    return;

  }

  p_end = &p_ccb->rsp_list[p_ccb->list_len];