1 /*
2  * Copyright 2020 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 <dlfcn.h>
18 #include <gtest/gtest.h>
19 
20 #include "osi/include/allocator.h"
21 #include "stack/include/avdt_api.h"
22 #include "stack/avdt/avdt_int.h"
23 #include "stack/test/common/mock_stack_avdt_msg.h"
24 
25 #ifndef UNUSED_ATTR
26 #define UNUSED_ATTR
27 #endif
28 
29 // Global trace level referred in the code under test
30 uint8_t appl_trace_level = BT_TRACE_LEVEL_VERBOSE;
31 
LogMsg(uint32_t trace_set_mask,const char * fmt_str,...)32 void LogMsg(uint32_t trace_set_mask, const char* fmt_str, ...) { }
33 
34 // All mock requires this symbol to count calling times
35 std::map<std::string, int> mock_function_count_map;
36 
37 class StackAvdtpTest : public ::testing::Test {
38  protected:
39   StackAvdtpTest() = default;
40 
41   virtual ~StackAvdtpTest() = default;
42  protected:
43   static AvdtpRcb reg_ctrl_block_;
44   static uint8_t callback_event_;
45   static uint8_t scb_handle_;
46 
47  protected:
AvdtConnCallback(uint8_t handle,const RawAddress & bd_addr,uint8_t event,tAVDT_CTRL * p_data,uint8_t scb_index)48   static void AvdtConnCallback(uint8_t handle, const RawAddress& bd_addr,
49                                uint8_t event, tAVDT_CTRL* p_data,
50                                uint8_t scb_index) {
51     mock_function_count_map[__func__]++;
52     callback_event_ = event;
53   }
54 
StreamCtrlCallback(uint8_t handle,const RawAddress & bd_addr,uint8_t event,tAVDT_CTRL * p_data,uint8_t scb_index)55   static void StreamCtrlCallback(uint8_t handle, const RawAddress& bd_addr,
56                                  uint8_t event, tAVDT_CTRL* p_data,
57                                  uint8_t scb_index) {
58     mock_function_count_map[__func__]++;
59     callback_event_ = event;
60   }
61 
AvdtReportCallback(uint8_t handle,AVDT_REPORT_TYPE type,tAVDT_REPORT_DATA * p_data)62   static void AvdtReportCallback(uint8_t handle, AVDT_REPORT_TYPE type,
63                                  tAVDT_REPORT_DATA* p_data) {
64     mock_function_count_map[__func__]++;
65   }
66 
SetUpTestCase()67   static void SetUpTestCase() {
68     reg_ctrl_block_.ctrl_mtu = 672;
69     reg_ctrl_block_.ret_tout = 4;
70     reg_ctrl_block_.sig_tout = 4;
71     reg_ctrl_block_.idle_tout = 10;
72     reg_ctrl_block_.scb_index = 0;
73     AVDT_Register(&reg_ctrl_block_, AvdtConnCallback);
74 
75     uint8_t peer_id = 1;
76     scb_handle_ = 0;
77     AvdtpStreamConfig avdtp_stream_config{};
78     avdtp_stream_config.cfg.psc_mask = AVDT_PSC_DELAY_RPT;
79     avdtp_stream_config.p_avdt_ctrl_cback = StreamCtrlCallback;
80     avdtp_stream_config.p_report_cback = AvdtReportCallback;
81     avdtp_stream_config.tsep = AVDT_TSEP_SNK;
82     // We have to reuse the stream since there is only AVDT_NUM_SEPS *
83     // AVDT_NUM_LINKS
84     ASSERT_EQ(AVDT_CreateStream(peer_id, &scb_handle_, avdtp_stream_config), AVDT_SUCCESS);
85   }
86 
TearDownTestCase()87   static void TearDownTestCase() { AVDT_Deregister(); }
88 
SetUp()89   void SetUp() override {
90     callback_event_ = AVDT_MAX_EVT + 1;
91     mock_function_count_map.clear();
92   }
93 
TearDown()94   void TearDown() override {
95     auto pscb = avdt_scb_by_hdl(scb_handle_);
96     tAVDT_SCB_EVT data;
97     // clean up the SCB state
98     avdt_scb_event(pscb, AVDT_SCB_MSG_ABORT_RSP_EVT, &data);
99     avdt_scb_event(pscb, AVDT_SCB_TC_CLOSE_EVT, &data);
100     ASSERT_EQ(AVDT_RemoveStream(scb_handle_), AVDT_SUCCESS);
101     // fallback to default settings (delay report + sink)
102     pscb->stream_config.cfg.psc_mask = AVDT_PSC_DELAY_RPT;
103     pscb->stream_config.tsep = AVDT_TSEP_SNK;
104   }
105 };
106 
107 AvdtpRcb StackAvdtpTest::reg_ctrl_block_{};
108 uint8_t StackAvdtpTest::callback_event_ = AVDT_MAX_EVT + 1;
109 uint8_t StackAvdtpTest::scb_handle_ = 0;
110 
TEST_F(StackAvdtpTest,test_delay_report_as_accept)111 TEST_F(StackAvdtpTest, test_delay_report_as_accept) {
112   // Get SCB ready to send response
113   auto pscb = avdt_scb_by_hdl(scb_handle_);
114   pscb->in_use = true;
115 
116   // Send SetConfig response
117   uint8_t label = 0;
118   uint8_t err_code = 0;
119   uint8_t category = 0;
120 
121   mock_avdt_msg_send_cmd_clear_history();
122   mock_avdt_msg_send_rsp_clear_history();
123   ASSERT_EQ(AVDT_ConfigRsp(scb_handle_, label, err_code, category), AVDT_SUCCESS);
124 
125   // Config response sent
126   ASSERT_EQ(mock_function_count_map["avdt_msg_send_rsp"], 1);
127   ASSERT_EQ(mock_avdt_msg_send_rsp_get_sig_id_at(0), AVDT_SIG_SETCONFIG);
128 
129   // Delay report command sent
130   ASSERT_EQ(mock_function_count_map["avdt_msg_send_cmd"], 1);
131   ASSERT_EQ(mock_avdt_msg_send_cmd_get_sig_id_at(0), AVDT_SIG_DELAY_RPT);
132 
133   // Delay report confirmed
134   tAVDT_SCB_EVT data;
135   ASSERT_EQ(mock_function_count_map["StreamCtrlCallback"], 0);
136   avdt_scb_hdl_delay_rpt_rsp(pscb, &data);
137   ASSERT_EQ(callback_event_, AVDT_DELAY_REPORT_CFM_EVT);
138 }
139 
TEST_F(StackAvdtpTest,test_no_delay_report_if_not_sink)140 TEST_F(StackAvdtpTest, test_no_delay_report_if_not_sink) {
141   // Get SCB ready to send response
142   auto pscb = avdt_scb_by_hdl(scb_handle_);
143   pscb->in_use = true;
144 
145   // Change the scb to SRC
146   pscb->stream_config.tsep = AVDT_TSEP_SRC;
147 
148   // Send SetConfig response
149   uint8_t label = 0;
150   uint8_t err_code = 0;
151   uint8_t category = 0;
152   ASSERT_EQ(AVDT_ConfigRsp(scb_handle_, label, err_code, category), AVDT_SUCCESS);
153   ASSERT_EQ(mock_function_count_map["avdt_msg_send_rsp"], 1); // Config response sent
154   ASSERT_EQ(mock_function_count_map["avdt_msg_send_cmd"], 0); // Delay report command not sent
155 }
156 
TEST_F(StackAvdtpTest,test_no_delay_report_if_not_enabled)157 TEST_F(StackAvdtpTest, test_no_delay_report_if_not_enabled) {
158   // Get SCB ready to send response
159   auto pscb = avdt_scb_by_hdl(scb_handle_);
160   pscb->in_use = true;
161 
162   // Disable the scb's delay report mask
163   pscb->stream_config.cfg.psc_mask &= ~AVDT_PSC_DELAY_RPT;
164 
165   // Send SetConfig response
166   uint8_t label = 0;
167   uint8_t err_code = 0;
168   uint8_t category = 0;
169   ASSERT_EQ(AVDT_ConfigRsp(scb_handle_, label, err_code, category), AVDT_SUCCESS);
170   ASSERT_EQ(mock_function_count_map["avdt_msg_send_rsp"], 1); // Config response sent
171   ASSERT_EQ(mock_function_count_map["avdt_msg_send_cmd"], 0); // Delay report command not sent
172 }
173 
TEST_F(StackAvdtpTest,test_delay_report_as_init)174 TEST_F(StackAvdtpTest, test_delay_report_as_init) {
175   auto pscb = avdt_scb_by_hdl(scb_handle_);
176   pscb->in_use = true;
177 
178   tAVDT_SCB_EVT data;
179 
180   // Delay report -> Open command
181   mock_avdt_msg_send_cmd_clear_history();
182   avdt_scb_event(pscb, AVDT_SCB_MSG_SETCONFIG_RSP_EVT, &data);
183   ASSERT_EQ(mock_function_count_map["avdt_msg_send_cmd"], 2);
184   ASSERT_EQ(mock_avdt_msg_send_cmd_get_sig_id_at(0), AVDT_SIG_DELAY_RPT);
185   ASSERT_EQ(mock_avdt_msg_send_cmd_get_sig_id_at(1), AVDT_SIG_OPEN);
186 }
187 
TEST_F(StackAvdtpTest,test_SR_reporting_handler)188 TEST_F(StackAvdtpTest, test_SR_reporting_handler) {
189   constexpr uint8_t sender_report_packet[] = {
190       // Header
191       0x80, 0xc8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
192       // Sender Info
193       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
194       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
195       // Report Block #1
196       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
197       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
198   uint16_t packet_length = sizeof(sender_report_packet);
199   tAVDT_SCB_EVT data;
200   auto pscb = avdt_scb_by_hdl(scb_handle_);
201 
202   data.p_pkt = (BT_HDR*)osi_calloc(sizeof(BT_HDR) + packet_length);
203   *data.p_pkt = {.len = packet_length, .layer_specific = AVDT_CHAN_REPORT};
204   memcpy(data.p_pkt->data, sender_report_packet, packet_length);
205   avdt_scb_hdl_pkt(pscb, &data);
206   ASSERT_EQ(mock_function_count_map["AvdtReportCallback"], 1);
207 
208   // no payload
209   data.p_pkt = (BT_HDR*)osi_calloc(sizeof(BT_HDR) + packet_length);
210   *data.p_pkt = {.layer_specific = AVDT_CHAN_REPORT};
211   memcpy(data.p_pkt->data, sender_report_packet, packet_length);
212   avdt_scb_hdl_pkt(pscb, &data);
213   ASSERT_EQ(mock_function_count_map["AvdtReportCallback"], 1);
214 
215   // only reporting header
216   data.p_pkt = (BT_HDR*)osi_calloc(sizeof(BT_HDR) + packet_length);
217   *data.p_pkt = {.len = 8, .layer_specific = AVDT_CHAN_REPORT};
218   memcpy(data.p_pkt->data, sender_report_packet, packet_length);
219   avdt_scb_hdl_pkt(pscb, &data);
220   ASSERT_EQ(mock_function_count_map["AvdtReportCallback"], 1);
221 
222   // reporting header + sender info
223   data.p_pkt = (BT_HDR*)osi_calloc(sizeof(BT_HDR) + packet_length);
224   *data.p_pkt = {.len = 28, .layer_specific = AVDT_CHAN_REPORT};
225   memcpy(data.p_pkt->data, sender_report_packet, packet_length);
226   avdt_scb_hdl_pkt(pscb, &data);
227   ASSERT_EQ(mock_function_count_map["AvdtReportCallback"], 2);
228 }
229 
TEST_F(StackAvdtpTest,test_RR_reporting_handler)230 TEST_F(StackAvdtpTest, test_RR_reporting_handler) {
231   constexpr uint8_t receiver_report_packet[] = {
232       // Header
233       0x80, 0xc9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
234       // Report Block #1
235       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
236       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
237   uint16_t packet_length = sizeof(receiver_report_packet);
238   tAVDT_SCB_EVT data;
239   auto pscb = avdt_scb_by_hdl(scb_handle_);
240 
241   data.p_pkt = (BT_HDR*)osi_calloc(sizeof(BT_HDR) + packet_length);
242   *data.p_pkt = {.len = packet_length, .layer_specific = AVDT_CHAN_REPORT};
243   memcpy(data.p_pkt->data, receiver_report_packet, packet_length);
244   avdt_scb_hdl_pkt(pscb, &data);
245   ASSERT_EQ(mock_function_count_map["AvdtReportCallback"], 1);
246 
247   // no payload
248   data.p_pkt = (BT_HDR*)osi_calloc(sizeof(BT_HDR) + packet_length);
249   *data.p_pkt = {.layer_specific = AVDT_CHAN_REPORT};
250   memcpy(data.p_pkt->data, receiver_report_packet, packet_length);
251   avdt_scb_hdl_pkt(pscb, &data);
252   ASSERT_EQ(mock_function_count_map["AvdtReportCallback"], 1);
253 
254   // only reporting header
255   data.p_pkt = (BT_HDR*)osi_calloc(sizeof(BT_HDR) + packet_length);
256   *data.p_pkt = {.len = 8, .layer_specific = AVDT_CHAN_REPORT};
257   memcpy(data.p_pkt->data, receiver_report_packet, packet_length);
258   avdt_scb_hdl_pkt(pscb, &data);
259   ASSERT_EQ(mock_function_count_map["AvdtReportCallback"], 1);
260 
261   // reporting header + report block
262   data.p_pkt = (BT_HDR*)osi_calloc(sizeof(BT_HDR) + packet_length);
263   *data.p_pkt = {.len = 32, .layer_specific = AVDT_CHAN_REPORT};
264   memcpy(data.p_pkt->data, receiver_report_packet, packet_length);
265   avdt_scb_hdl_pkt(pscb, &data);
266   ASSERT_EQ(mock_function_count_map["AvdtReportCallback"], 2);
267 }
268 
TEST_F(StackAvdtpTest,test_SDES_reporting_handler)269 TEST_F(StackAvdtpTest, test_SDES_reporting_handler) {
270   constexpr uint8_t source_description_packet[] = {// Header
271                                                    0x80, 0xca, 0x00, 0x00,
272                                                    // Chunk #1
273                                                    0x00, 0x00, 0x00, 0x00,
274                                                    // SDES Item (CNAME=1)
275                                                    0x01, 0x05, 0x00, 0x00, 0x00,
276                                                    0x00, 0x00, 0x00};
277   uint16_t packet_length = sizeof(source_description_packet);
278   tAVDT_SCB_EVT data;
279   auto pscb = avdt_scb_by_hdl(scb_handle_);
280 
281   data.p_pkt = (BT_HDR*)osi_calloc(sizeof(BT_HDR) + packet_length);
282   *data.p_pkt = {.len = packet_length, .layer_specific = AVDT_CHAN_REPORT};
283   memcpy(data.p_pkt->data, source_description_packet, packet_length);
284   avdt_scb_hdl_pkt(pscb, &data);
285   ASSERT_EQ(mock_function_count_map["AvdtReportCallback"], 1);
286 
287   // no payload
288   data.p_pkt = (BT_HDR*)osi_calloc(sizeof(BT_HDR) + packet_length);
289   *data.p_pkt = {.layer_specific = AVDT_CHAN_REPORT};
290   memcpy(data.p_pkt->data, source_description_packet, packet_length);
291   avdt_scb_hdl_pkt(pscb, &data);
292   ASSERT_EQ(mock_function_count_map["AvdtReportCallback"], 1);
293 
294   // only reporting header
295   data.p_pkt = (BT_HDR*)osi_calloc(sizeof(BT_HDR) + packet_length);
296   *data.p_pkt = {.len = 4, .layer_specific = AVDT_CHAN_REPORT};
297   memcpy(data.p_pkt->data, source_description_packet, packet_length);
298   avdt_scb_hdl_pkt(pscb, &data);
299   ASSERT_EQ(mock_function_count_map["AvdtReportCallback"], 1);
300 
301   // SDES Item (CNAME) with empty value
302   data.p_pkt = (BT_HDR*)osi_calloc(sizeof(BT_HDR) + packet_length);
303   *data.p_pkt = {.len = 10, .layer_specific = AVDT_CHAN_REPORT};
304   memcpy(data.p_pkt->data, source_description_packet, packet_length);
305   avdt_scb_hdl_pkt(pscb, &data);
306   ASSERT_EQ(mock_function_count_map["AvdtReportCallback"], 1);
307 
308   // SDES Item (not CNAME) which is not supported
309   data.p_pkt = (BT_HDR*)osi_calloc(sizeof(BT_HDR) + packet_length);
310   *data.p_pkt = {.len = 10, .layer_specific = AVDT_CHAN_REPORT};
311   memcpy(data.p_pkt->data, source_description_packet, packet_length);
312   *(data.p_pkt->data + 8) = 0x02;
313   *(data.p_pkt->data + 9) = 0x00;
314   avdt_scb_hdl_pkt(pscb, &data);
315   ASSERT_EQ(mock_function_count_map["AvdtReportCallback"], 1);
316 }
317