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

Commit c465a344 authored by Chris Manton's avatar Chris Manton
Browse files

legacy: Re-do names bta/pan/bta_pan_api::BTA_PanSetRole 

Bug: 187824969
Tag: #refactor
Test: gd/cert/run
Change-Id: Ie4afcb6a07e28fe3454f310ac8f340e0a9b701ff
parent 4651e2c6

system/bta/include/bta_pan_api.h

+6 −6
Original line number Diff line number Diff line
@@ -53,10 +53,10 @@ typedef enum : uint8_t { 
typedef uint8_t tBTA_PAN_ROLE;



/*  information regarding PAN roles */

typedef struct {

  const char* p_srv_name; /* service name for the PAN role */

  uint8_t app_id;         /* application id */

} tBTA_PAN_ROLE_INFO;

struct tBTA_PAN_ROLE_INFO {

  const std::string p_srv_name; /* service name for the PAN role */

  const uint8_t app_id;         /* application id */

};



/* Event associated with BTA_PAN_SET_ROLE_EVT */

typedef struct {
@@ -142,8 +142,8 @@ extern void BTA_PanDisable(void); 
 * Returns          void

 *

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

void BTA_PanSetRole(tBTA_PAN_ROLE role, tBTA_PAN_ROLE_INFO* p_user_info,

                    tBTA_PAN_ROLE_INFO* p_nap_info);

void BTA_PanSetRole(tBTA_PAN_ROLE role, const tBTA_PAN_ROLE_INFO p_user_info,

                    const tBTA_PAN_ROLE_INFO p_nap_info);



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

 *

system/bta/pan/bta_pan_act.cc

+14 −12
Original line number Diff line number Diff line
@@ -321,18 +321,23 @@ void bta_pan_enable(tBTA_PAN_DATA* p_data) { 
 *

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

void bta_pan_set_role(tBTA_PAN_DATA* p_data) {

  tPAN_RESULT status;

  tBTA_PAN bta_pan;



  bta_pan_cb.app_id[0] = p_data->api_set_role.user_app_id;

  bta_pan_cb.app_id[2] = p_data->api_set_role.nap_app_id;



  /* set security correctly in api and here */

  status =

      PAN_SetRole(p_data->api_set_role.role, p_data->api_set_role.user_name,

                  p_data->api_set_role.nap_name);

  tPAN_RESULT status = PAN_SetRole(p_data->api_set_role.role,

                                   std::string(p_data->api_set_role.user_name),

                                   std::string(p_data->api_set_role.nap_name));



  tBTA_PAN bta_pan = {

      .set_role =

          {

              .role = p_data->api_set_role.role,

              .status =

                  (status == PAN_SUCCESS) ? BTA_PAN_SUCCESS : BTA_PAN_FAIL,

          },

  };



  bta_pan.set_role.role = p_data->api_set_role.role;

  if (status == PAN_SUCCESS) {

    if (p_data->api_set_role.role & PAN_ROLE_NAP_SERVER)

      bta_sys_add_uuid(UUID_SERVCLASS_NAP);
@@ -343,16 +348,13 @@ void bta_pan_set_role(tBTA_PAN_DATA* p_data) { 
      bta_sys_add_uuid(UUID_SERVCLASS_PANU);

    else

      bta_sys_remove_uuid(UUID_SERVCLASS_PANU);



    bta_pan.set_role.status = BTA_PAN_SUCCESS;

  }

  /* if status is not success clear everything */

  else {

    PAN_SetRole(0, NULL, NULL);

    PAN_SetRole(0, std::string(), std::string());

    bta_sys_remove_uuid(UUID_SERVCLASS_NAP);

    bta_sys_remove_uuid(UUID_SERVCLASS_GN);

    bta_sys_remove_uuid(UUID_SERVCLASS_PANU);

    bta_pan.set_role.status = BTA_PAN_FAIL;

  }

  bta_pan_cb.p_cback(BTA_PAN_SET_ROLE_EVT, &bta_pan);

}
@@ -374,7 +376,7 @@ void bta_pan_disable(void) { 
  uint8_t i;



  /* close all connections */

  PAN_SetRole(0, NULL, NULL);

  PAN_SetRole(0, std::string(), std::string());



#if (BTA_EIR_CANNED_UUID_LIST != TRUE)

  bta_sys_remove_uuid(UUID_SERVCLASS_NAP);

system/bta/pan/bta_pan_api.cc

+36 −24
Original line number Diff line number Diff line
@@ -24,17 +24,22 @@ 
 ******************************************************************************/



#include <cstdint>

#include <cstring>



#include "bt_target.h"  // Must be first to define build configuration



#include "bta/pan/bta_pan_int.h"

#include "osi/include/allocator.h"

#include "osi/include/compat.h"

#include "stack/include/bt_hdr.h"

#include "stack/include/btu.h"

#include "types/raw_address.h"



static const tBTA_SYS_REG bta_pan_reg = {bta_pan_hdl_event, BTA_PanDisable};



std::string user_service_name; /* Service name for PANU role */

std::string gn_service_name;   /* Service name for GN role */

std::string nap_service_name;  /* Service name for NAP role */



#ifndef PAN_SECURITY

#define PAN_SECURITY                                                         \

  (BTM_SEC_IN_AUTHENTICATE | BTM_SEC_OUT_AUTHENTICATE | BTM_SEC_IN_ENCRYPT | \
@@ -96,29 +101,36 @@ void BTA_PanDisable(void) { 
 * Returns          void

 *

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

void BTA_PanSetRole(tBTA_PAN_ROLE role, tBTA_PAN_ROLE_INFO* p_user_info,

                    tBTA_PAN_ROLE_INFO* p_nap_info) {

  tBTA_PAN_API_SET_ROLE* p_buf =

      (tBTA_PAN_API_SET_ROLE*)osi_calloc(sizeof(tBTA_PAN_API_SET_ROLE));



  p_buf->hdr.event = BTA_PAN_API_SET_ROLE_EVT;

  p_buf->role = role;



void BTA_PanSetRole(tBTA_PAN_ROLE role, const tBTA_PAN_ROLE_INFO user_info,

                    const tBTA_PAN_ROLE_INFO nap_info) {

  post_on_bt_main([=]() {

    tBTA_PAN_DATA data = {

        .api_set_role =

            {

                .hdr =

                    {

                        .event = BTA_PAN_API_SET_ROLE_EVT,

                    },

                .role = role,

                .user_name = {},

                .nap_name = {},

            },

    };

    if (role & BTA_PAN_ROLE_PANU) {

    if (p_user_info->p_srv_name)

      strlcpy(p_buf->user_name, p_user_info->p_srv_name, BTA_SERVICE_NAME_LEN);



    p_buf->user_app_id = p_user_info->app_id;

      if (!user_info.p_srv_name.empty())

        strncpy(data.api_set_role.user_name, user_info.p_srv_name.data(),

                BTA_SERVICE_NAME_LEN);

      data.api_set_role.user_app_id = user_info.app_id;

    }



    if (role & BTA_PAN_ROLE_NAP) {

    if (p_nap_info->p_srv_name)

      strlcpy(p_buf->nap_name, p_nap_info->p_srv_name, BTA_SERVICE_NAME_LEN);



    p_buf->nap_app_id = p_nap_info->app_id;

      if (!nap_info.p_srv_name.empty())

        strncpy(data.api_set_role.nap_name, nap_info.p_srv_name.data(),

                BTA_SERVICE_NAME_LEN);

      data.api_set_role.nap_app_id = nap_info.app_id;

    }



  bta_sys_sendmsg(p_buf);

    bta_pan_set_role(&data);

  });

}



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

system/bta/test/bta_pan_test.cc

+196 −5
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ 
 * limitations under the License.

 */



#include <gmock/gmock.h>

#include <gtest/gtest.h>

#include <string.h>
@@ -23,15 +24,205 @@ 
#include <string>



#include "bta/pan/bta_pan_int.h"

#include "test/common/main_handler.h"

#include "test/common/mock_functions.h"

#include "test/mock/mock_stack_pan_api.h"



// TODO put this in common place

extern std::map<std::string, int> mock_function_count_map;

using namespace testing;



namespace {



struct UuidPiece {

  uint16_t uuid16;

  bool adding;

};



struct EventPiece {

  tBTA_PAN_EVT event;

  tBTA_PAN data;

};



std::function<void(tBTA_PAN_EVT, tBTA_PAN*)> bta_pan_event_closure;

void BTA_PAN_CBACK(tBTA_PAN_EVT event, tBTA_PAN* p_data) {

  bta_pan_event_closure(event, p_data);

}



std::function<void(uint16_t, bool)> bta_sys_eir_closure;

void BTA_SYS_EIR_CBACK(uint16_t uuid16, bool adding) {

  bta_sys_eir_closure(uuid16, adding);

}



constexpr tBTA_PAN kNoData = {};



}  // namespace



class BtaPanTest : public ::testing::Test {

 protected:

  void SetUp() override {}

  void SetUp() override {

    uuids.clear();

    main_thread_start_up();

    bta_pan_event_closure = [this](tBTA_PAN_EVT event, tBTA_PAN* data) {

      events.push_back({

          .event = event,

          .data = (data == nullptr) ? kNoData : *data,

      });

    };

    tBTA_PAN_DATA data = {

        .api_enable =

            {

                .p_cback = BTA_PAN_CBACK,

            },

    };

    bta_sys_eir_closure = [this](uint16_t uuid16, bool adding) {

      uuids.push_back({

          .uuid16 = uuid16,

          .adding = adding,

      });

    };

    bta_pan_enable(&data);

    sync_main_handler();

    auto e = events.front();

    events.pop_front();

    ASSERT_EQ(BTA_PAN_ENABLE_EVT, e.event);

  }



  void TearDown() override {

    bta_pan_disable();

    sync_main_handler();

    main_thread_shut_down();

  }



  std::deque<struct EventPiece> events;

  std::deque<struct UuidPiece> uuids;

};



TEST_F(BtaPanTest, BTA_PanSetRole_Null) {

  tBTA_PAN_ROLE role = BTA_PAN_ROLE_PANU | BTA_PAN_ROLE_NAP;

  tBTA_PAN_ROLE_INFO user_info = {

      .p_srv_name = std::string(),

      .app_id = 12,

  };



  tBTA_PAN_ROLE_INFO nap_info = {

      .p_srv_name = std::string(),

      .app_id = 34,

  };



  bta_sys_eir_register(BTA_SYS_EIR_CBACK);

  BTA_PanSetRole(role, user_info, nap_info);



  // Wait for main thread to complete

  sync_main_handler();



  ASSERT_EQ(12, bta_pan_cb.app_id[0]);

  ASSERT_EQ(0, bta_pan_cb.app_id[1]);

  ASSERT_EQ(34, bta_pan_cb.app_id[2]);



  ASSERT_EQ(2U, uuids.size());

  ASSERT_EQ(0x1116, uuids[0].uuid16);

  ASSERT_EQ(true, uuids[0].adding);

  ASSERT_EQ(0x1115, uuids[1].uuid16);

  ASSERT_EQ(true, uuids[1].adding);

}



  void TearDown() override {}

TEST_F(BtaPanTest, BTA_PanSetRole_WithNames) {

  tBTA_PAN_ROLE role = BTA_PAN_ROLE_PANU | BTA_PAN_ROLE_NAP;

  tBTA_PAN_ROLE_INFO user_info = {

      .p_srv_name = "TestPanUser",

      .app_id = 12,

  };

  tBTA_PAN_ROLE_INFO nap_info = {

      .p_srv_name = "TestPanNap",

      .app_id = 34,

  };



  uint8_t stack_pan_role;

  std::string stack_pan_user_name;

  std::string stack_pan_nap_name;



  test::mock::stack_pan_api::PAN_SetRole.body =

      [&stack_pan_role, &stack_pan_user_name, &stack_pan_nap_name](

          uint8_t role, std::string user_name,

          std::string nap_name) -> tPAN_RESULT {

    stack_pan_role = role;

    stack_pan_user_name = user_name;

    stack_pan_nap_name = nap_name;

    return PAN_SUCCESS;

  };



  bta_sys_eir_register(BTA_SYS_EIR_CBACK);

  BTA_PanSetRole(role, user_info, nap_info);



  // Wait for main thread to complete

  sync_main_handler();



  ASSERT_EQ(1UL, events.size());

  auto e = events.front();

  events.pop_front();

  ASSERT_EQ(BTA_PAN_SET_ROLE_EVT, e.event);

  ASSERT_EQ(BTA_PAN_ROLE_PANU | BTA_PAN_ROLE_NAP, e.data.set_role.role);

  ASSERT_EQ(BTA_PAN_SUCCESS, e.data.set_role.status);



  ASSERT_EQ(BTA_PAN_ROLE_PANU | BTA_PAN_ROLE_NAP, stack_pan_role);

  ASSERT_THAT("TestPanUser", StrEq(stack_pan_user_name));

  ASSERT_THAT("TestPanNap", StrEq(stack_pan_nap_name));



  test::mock::stack_pan_api::PAN_SetRole = {};

}



constexpr size_t kBtaServiceNameLen = static_cast<size_t>(BTA_SERVICE_NAME_LEN);



TEST_F(BtaPanTest, BTA_PanSetRole_WithLongNames) {

  tBTA_PAN_ROLE role = BTA_PAN_ROLE_PANU | BTA_PAN_ROLE_NAP;

  tBTA_PAN_ROLE_INFO user_info = {

      .p_srv_name = std::string(200, 'A'),

      .app_id = 12,

  };

  ASSERT_EQ(200UL, user_info.p_srv_name.size());



  tBTA_PAN_ROLE_INFO nap_info = {

      .p_srv_name = std::string(201, 'A'),

      .app_id = 34,

  };

  ASSERT_EQ(201UL, nap_info.p_srv_name.size());



  uint8_t stack_pan_role;

  std::string stack_pan_user_name;

  std::string stack_pan_nap_name;



  test::mock::stack_pan_api::PAN_SetRole.body =

      [&stack_pan_role, &stack_pan_user_name, &stack_pan_nap_name](

          uint8_t role, std::string user_name,

          std::string nap_name) -> tPAN_RESULT {

    stack_pan_role = role;

    stack_pan_user_name = user_name;

    stack_pan_nap_name = nap_name;

    return PAN_SUCCESS;

  };



  bta_sys_eir_register(BTA_SYS_EIR_CBACK);

  BTA_PanSetRole(role, user_info, nap_info);



  // Wait for main thread to complete

  sync_main_handler();



  ASSERT_EQ(1UL, events.size());

  auto e = events.front();

  events.pop_front();

  ASSERT_EQ(BTA_PAN_SET_ROLE_EVT, e.event);

  ASSERT_EQ(BTA_PAN_ROLE_PANU | BTA_PAN_ROLE_NAP, e.data.set_role.role);

  ASSERT_EQ(BTA_PAN_SUCCESS, e.data.set_role.status);



  ASSERT_EQ(BTA_PAN_ROLE_PANU | BTA_PAN_ROLE_NAP, stack_pan_role);



  ASSERT_EQ(kBtaServiceNameLen, stack_pan_user_name.size());

  ASSERT_EQ(kBtaServiceNameLen, stack_pan_nap_name.size());



  ASSERT_THAT(stack_pan_user_name, StrEq(std::string(kBtaServiceNameLen, 'A')));

  ASSERT_THAT(stack_pan_user_name,

              StrEq("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"));

  ASSERT_THAT(stack_pan_nap_name, StrEq(std::string(kBtaServiceNameLen, 'A')));

  ASSERT_THAT(stack_pan_nap_name, StrEq("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"));



TEST_F(BtaPanTest, nop) {}
 
  test::mock::stack_pan_api::PAN_SetRole = {};

}

system/btif/src/btif_pan.cc

+4 −3
Original line number Diff line number Diff line
@@ -180,12 +180,13 @@ static inline tBTA_PAN_ROLE btpan_role_to_bta(int btpan_role) { 
}



static tBTA_PAN_ROLE btpan_dev_local_role;

static tBTA_PAN_ROLE_INFO bta_panu_info = {PANU_SERVICE_NAME, 0};

static tBTA_PAN_ROLE_INFO bta_pan_nap_info = {PAN_NAP_SERVICE_NAME, 1};

static tBTA_PAN_ROLE_INFO bta_panu_info = {std::string(PANU_SERVICE_NAME), 0};

static tBTA_PAN_ROLE_INFO bta_pan_nap_info = {std::string(PAN_NAP_SERVICE_NAME),

                                              1};



static bt_status_t btpan_enable(int local_role) {

  const tBTA_PAN_ROLE bta_pan_role = btpan_role_to_bta(local_role);

  BTA_PanSetRole(bta_pan_role, &bta_panu_info, &bta_pan_nap_info);

  BTA_PanSetRole(bta_pan_role, bta_panu_info, bta_pan_nap_info);

  btpan_dev_local_role = local_role;

  return BT_STATUS_SUCCESS;

}