1 /*
2 * Copyright 2023 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 #include <sys/socket.h>
20
21 #include "bta/dm/bta_dm_sec_int.h"
22 #include "bta/test/bta_test_fixtures.h"
23 #include "stack/include/btm_status.h"
24 #include "test/mock/mock_stack_btm_interface.h"
25 #include "test/mock/mock_stack_rnr_interface.h"
26 #include "types/raw_address.h"
27
28 using ::testing::_;
29 using ::testing::ElementsAre;
30 using ::testing::Return;
31
32 namespace {
33 const RawAddress kRawAddress({0x11, 0x22, 0x33, 0x44, 0x55, 0x66});
34 const RawAddress kRawAddress2({0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc});
35 const DEV_CLASS kDeviceClass = {0x11, 0x22, 0x33};
36
37 constexpr char kRemoteName[] = "TheRemoteName";
38
39 } // namespace
40
41 class BtaSecTest : public BtaWithHwOnTest {
42 protected:
SetUp()43 void SetUp() override {
44 BtaWithHwOnTest::SetUp();
45 bluetooth::testing::stack::rnr::set_interface(&mock_stack_rnr_interface_);
46 }
47
TearDown()48 void TearDown() override {
49 bluetooth::testing::stack::rnr::reset_interface();
50 BtaWithHwOnTest::TearDown();
51 }
52
53 bluetooth::testing::stack::rnr::Mock mock_stack_rnr_interface_;
54 };
55
TEST_F(BtaSecTest,bta_dm_sp_cback__BTM_SP_CFM_REQ_EVT_WithName)56 TEST_F(BtaSecTest, bta_dm_sp_cback__BTM_SP_CFM_REQ_EVT_WithName) {
57 constexpr uint32_t kNumVal = 1234;
58 static bool callback_sent = false;
59
60 static tBTA_DM_SP_CFM_REQ cfm_req{};
61 bta_dm_sec_enable([](tBTA_DM_SEC_EVT /*event*/, tBTA_DM_SEC* p_data) {
62 callback_sent = true;
63 cfm_req = p_data->cfm_req;
64 });
65
66 tBTM_SP_EVT_DATA data = {
67 .cfm_req =
68 {
69 // tBTM_SP_CFM_REQ
70 .bd_addr = kRawAddress,
71 .dev_class = {},
72 .bd_name = {},
73 .num_val = kNumVal,
74 .just_works = false,
75 .loc_auth_req = BTM_AUTH_SP_YES,
76 .rmt_auth_req = BTM_AUTH_SP_YES,
77 .loc_io_caps = BTM_IO_CAP_NONE,
78 .rmt_io_caps = BTM_IO_CAP_NONE,
79 },
80 };
81 data.cfm_req.dev_class = kDeviceClass;
82 bd_name_from_char_pointer(data.cfm_req.bd_name, kRemoteName);
83
84 ASSERT_EQ(
85 btm_status_text(tBTM_STATUS::BTM_CMD_STARTED),
86 btm_status_text(bluetooth::legacy::testing::bta_dm_sp_cback(BTM_SP_CFM_REQ_EVT, &data)));
87 ASSERT_EQ(kNumVal, bta_dm_sec_cb.num_val);
88 ASSERT_TRUE(callback_sent);
89
90 ASSERT_EQ(kRawAddress, cfm_req.bd_addr);
91 ASSERT_THAT(cfm_req.dev_class, ElementsAre(kDeviceClass[0], kDeviceClass[1], kDeviceClass[2]));
92 ASSERT_STREQ(kRemoteName, reinterpret_cast<const char*>(cfm_req.bd_name));
93 ASSERT_EQ(kNumVal, cfm_req.num_val);
94 ASSERT_EQ(false, cfm_req.just_works);
95 ASSERT_EQ(BTM_AUTH_SP_YES, cfm_req.loc_auth_req);
96 ASSERT_EQ(BTM_AUTH_SP_YES, cfm_req.rmt_auth_req);
97 ASSERT_EQ(BTM_IO_CAP_NONE, cfm_req.loc_io_caps);
98 ASSERT_EQ(BTM_IO_CAP_NONE, cfm_req.rmt_io_caps);
99 }
100
TEST_F(BtaSecTest,bta_dm_sp_cback__BTM_SP_CFM_REQ_EVT_WithoutName_RNRSuccess)101 TEST_F(BtaSecTest, bta_dm_sp_cback__BTM_SP_CFM_REQ_EVT_WithoutName_RNRSuccess) {
102 constexpr uint32_t kNumVal = 1234;
103 static bool callback_sent = false;
104 reset_mock_btm_client_interface();
105
106 EXPECT_CALL(mock_stack_rnr_interface_, BTM_ReadRemoteDeviceName(_, _, _))
107 .WillOnce(Return(tBTM_STATUS::BTM_CMD_STARTED));
108
109 static tBTA_DM_SP_CFM_REQ cfm_req{};
110 bta_dm_sec_enable([](tBTA_DM_SEC_EVT /*event*/, tBTA_DM_SEC* p_data) {
111 callback_sent = true;
112 cfm_req = p_data->cfm_req;
113 });
114
115 tBTM_SP_EVT_DATA data = {
116 .cfm_req =
117 {
118 // tBTM_SP_CFM_REQ
119 .bd_addr = kRawAddress,
120 .dev_class = {},
121 .bd_name = {0}, // No name available
122 .num_val = kNumVal,
123 .just_works = false,
124 .loc_auth_req = BTM_AUTH_SP_YES,
125 .rmt_auth_req = BTM_AUTH_SP_YES,
126 .loc_io_caps = BTM_IO_CAP_NONE,
127 .rmt_io_caps = BTM_IO_CAP_NONE,
128 },
129 };
130 data.cfm_req.dev_class = kDeviceClass;
131
132 ASSERT_EQ(
133 btm_status_text(tBTM_STATUS::BTM_CMD_STARTED),
134 btm_status_text(bluetooth::legacy::testing::bta_dm_sp_cback(BTM_SP_CFM_REQ_EVT, &data)));
135 ASSERT_EQ(kNumVal, bta_dm_sec_cb.num_val);
136 ASSERT_FALSE(callback_sent);
137 }
138
TEST_F(BtaSecTest,bta_dm_sp_cback__BTM_SP_CFM_REQ_EVT_WithoutName_RNRFail)139 TEST_F(BtaSecTest, bta_dm_sp_cback__BTM_SP_CFM_REQ_EVT_WithoutName_RNRFail) {
140 constexpr uint32_t kNumVal = 1234;
141 static bool callback_sent = false;
142
143 EXPECT_CALL(mock_stack_rnr_interface_, BTM_ReadRemoteDeviceName(_, _, _))
144 .WillOnce(Return(tBTM_STATUS::BTM_SUCCESS));
145
146 static tBTA_DM_SP_CFM_REQ cfm_req{};
147 bta_dm_sec_enable([](tBTA_DM_SEC_EVT /*event*/, tBTA_DM_SEC* p_data) {
148 callback_sent = true;
149 cfm_req = p_data->cfm_req;
150 });
151
152 tBTM_SP_EVT_DATA data = {
153 .cfm_req =
154 {
155 // tBTM_SP_CFM_REQ
156 .bd_addr = kRawAddress,
157 .dev_class = {},
158 .bd_name = {0},
159 .num_val = kNumVal,
160 .just_works = false,
161 .loc_auth_req = BTM_AUTH_SP_YES,
162 .rmt_auth_req = BTM_AUTH_SP_YES,
163 .loc_io_caps = BTM_IO_CAP_NONE,
164 .rmt_io_caps = BTM_IO_CAP_NONE,
165 },
166 };
167 data.cfm_req.dev_class = kDeviceClass;
168
169 ASSERT_EQ(
170 btm_status_text(tBTM_STATUS::BTM_CMD_STARTED),
171 btm_status_text(bluetooth::legacy::testing::bta_dm_sp_cback(BTM_SP_CFM_REQ_EVT, &data)));
172 ASSERT_EQ(kNumVal, bta_dm_sec_cb.num_val);
173 ASSERT_TRUE(callback_sent);
174
175 ASSERT_EQ(kRawAddress, cfm_req.bd_addr);
176 ASSERT_THAT(cfm_req.dev_class, ElementsAre(kDeviceClass[0], kDeviceClass[1], kDeviceClass[2]));
177 ASSERT_EQ(kNumVal, cfm_req.num_val);
178 ASSERT_EQ(false, cfm_req.just_works);
179 ASSERT_EQ(BTM_AUTH_SP_YES, cfm_req.loc_auth_req);
180 ASSERT_EQ(BTM_AUTH_SP_YES, cfm_req.rmt_auth_req);
181 ASSERT_EQ(BTM_IO_CAP_NONE, cfm_req.loc_io_caps);
182 ASSERT_EQ(BTM_IO_CAP_NONE, cfm_req.rmt_io_caps);
183 }
184
TEST_F(BtaSecTest,bta_dm_sp_cback__BTM_SP_KEY_NOTIF_EVT)185 TEST_F(BtaSecTest, bta_dm_sp_cback__BTM_SP_KEY_NOTIF_EVT) {
186 constexpr uint32_t kPassKey = 1234;
187 static bool callback_sent = false;
188
189 ON_CALL(mock_stack_rnr_interface_, BTM_ReadRemoteDeviceName(_, _, _))
190 .WillByDefault(Return(tBTM_STATUS::BTM_CMD_STARTED));
191
192 static tBTA_DM_SP_KEY_NOTIF key_notif{};
193 bta_dm_sec_enable([](tBTA_DM_SEC_EVT /*event*/, tBTA_DM_SEC* p_data) {
194 callback_sent = true;
195 key_notif = p_data->key_notif;
196 });
197
198 tBTM_SP_EVT_DATA data = {
199 .key_notif =
200 {
201 // tBTM_SP_KEY_NOTIF
202 .bd_addr = kRawAddress,
203 .dev_class = {},
204 .bd_name = {},
205 .passkey = kPassKey,
206 },
207 };
208 data.key_notif.dev_class = kDeviceClass;
209 bd_name_from_char_pointer(data.key_notif.bd_name, kRemoteName);
210
211 ASSERT_EQ(btm_status_text(tBTM_STATUS::BTM_CMD_STARTED),
212 btm_status_text(
213 bluetooth::legacy::testing::bta_dm_sp_cback(BTM_SP_KEY_NOTIF_EVT, &data)));
214 ASSERT_EQ(kPassKey, bta_dm_sec_cb.num_val);
215 ASSERT_TRUE(callback_sent);
216
217 ASSERT_EQ(kRawAddress, key_notif.bd_addr);
218 ASSERT_THAT(key_notif.dev_class, ElementsAre(kDeviceClass[0], kDeviceClass[1], kDeviceClass[2]));
219 ASSERT_STREQ(kRemoteName, reinterpret_cast<const char*>(key_notif.bd_name));
220 ASSERT_EQ(kPassKey, key_notif.passkey);
221 }
222