1/******************************************************************************
2 *
3 *  Copyright 2018 The Android Open Source Project
4 *
5 *  Licensed under the Apache License, Version 2.0 (the "License");
6 *  you may not use this file except in compliance with the License.
7 *  You may obtain a copy of the License at:
8 *
9 *  http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 *
17 ******************************************************************************/
18
19#include <base/logging.h>
20#include <gmock/gmock.h>
21#include <gtest/gtest.h>
22
23#include "bt_types.h"
24#include "btm_api.h"
25#include "l2c_api.h"
26#include "osi/include/osi.h"
27#include "port_api.h"
28
29#include "btm_int.h"
30#include "rfc_int.h"
31
32#include "mock_btm_layer.h"
33#include "mock_l2cap_layer.h"
34#include "stack_rfcomm_test_utils.h"
35#include "stack_test_packet_utils.h"
36
37std::string DumpByteBufferToString(uint8_t* p_data, size_t len) {
38  std::stringstream str;
39  str.setf(std::ios_base::hex, std::ios::basefield);
40  str.setf(std::ios_base::uppercase);
41  str.fill('0');
42  for (size_t i = 0; i < len; ++i) {
43    str << std::setw(2) << static_cast<uint16_t>(p_data[i]);
44    str << " ";
45  }
46  return str.str();
47}
48
49std::string DumpBtHdrToString(BT_HDR* p_hdr) {
50  uint8_t* p_hdr_data = p_hdr->data + p_hdr->offset;
51  return DumpByteBufferToString(p_hdr_data, p_hdr->len);
52}
53
54void PrintTo(BT_HDR* value, ::std::ostream* os) {
55  *os << DumpBtHdrToString(value);
56}
57
58void PrintTo(tL2CAP_CFG_INFO* value, ::std::ostream* os) {
59  *os << DumpByteBufferToString((uint8_t*)value, sizeof(tL2CAP_CFG_INFO));
60}
61
62namespace {
63
64using testing::_;
65using testing::DoAll;
66using testing::Return;
67using testing::Test;
68using testing::StrictMock;
69using testing::SaveArg;
70using testing::SaveArgPointee;
71using testing::Pointee;
72using testing::StrEq;
73using testing::NotNull;
74
75using bluetooth::CreateL2capDataPacket;
76using bluetooth::CreateAclPacket;
77using bluetooth::AllocateWrappedIncomingL2capAclPacket;
78using bluetooth::AllocateWrappedOutgoingL2capAclPacket;
79
80using bluetooth::rfcomm::GetDlci;
81using bluetooth::rfcomm::GetAddressField;
82using bluetooth::rfcomm::GetControlField;
83using bluetooth::rfcomm::CreateMccPnFrame;
84using bluetooth::rfcomm::CreateMccMscFrame;
85using bluetooth::rfcomm::CreateMultiplexerControlFrame;
86using bluetooth::rfcomm::CreateRfcommPacket;
87using bluetooth::rfcomm::CreateQuickDataPacket;
88using bluetooth::rfcomm::CreateQuickPnPacket;
89using bluetooth::rfcomm::CreateQuickSabmPacket;
90using bluetooth::rfcomm::CreateQuickUaPacket;
91using bluetooth::rfcomm::CreateQuickMscPacket;
92
93MATCHER_P(PointerMemoryEqual, ptr,
94          DumpByteBufferToString((uint8_t*)ptr, sizeof(*ptr))) {
95  return memcmp(arg, ptr, sizeof(*ptr)) == 0;
96}
97
98MATCHER_P(BtHdrEqual, expected, DumpBtHdrToString(expected)) {
99  auto arg_hdr = static_cast<BT_HDR*>(arg);
100  uint8_t* arg_data = arg_hdr->data + arg_hdr->offset;
101  auto expected_hdr = static_cast<BT_HDR*>(expected);
102  uint8_t* expected_data = expected_hdr->data + expected_hdr->offset;
103  return memcmp(arg_data, expected_data, expected_hdr->len) == 0;
104}
105
106bluetooth::rfcomm::MockRfcommCallback* rfcomm_callback = nullptr;
107
108void port_mgmt_cback_0(uint32_t code, uint16_t port_handle) {
109  rfcomm_callback->PortManagementCallback(code, port_handle, 0);
110}
111
112void port_mgmt_cback_1(uint32_t code, uint16_t port_handle) {
113  rfcomm_callback->PortManagementCallback(code, port_handle, 1);
114}
115
116void port_event_cback_0(uint32_t code, uint16_t port_handle) {
117  rfcomm_callback->PortEventCallback(code, port_handle, 0);
118}
119
120void port_event_cback_1(uint32_t code, uint16_t port_handle) {
121  rfcomm_callback->PortEventCallback(code, port_handle, 1);
122}
123
124RawAddress GetTestAddress(int index) {
125  CHECK_LT(index, UINT8_MAX);
126  RawAddress result = {
127      {0xAA, 0x00, 0x11, 0x22, 0x33, static_cast<uint8_t>(index)}};
128  return result;
129}
130
131class StackRfcommTest : public Test {
132 public:
133  void StartServerPort(uint16_t uuid, uint8_t scn, uint16_t mtu,
134                       tPORT_CALLBACK* management_callback,
135                       tPORT_CALLBACK* event_callback,
136                       uint16_t* server_handle) {
137    VLOG(1) << "Step 1";
138    ASSERT_EQ(RFCOMM_CreateConnection(uuid, scn, true, mtu, RawAddress::kAny,
139                                      server_handle, management_callback),
140              PORT_SUCCESS);
141    ASSERT_EQ(PORT_SetEventMask(*server_handle, PORT_EV_RXCHAR), PORT_SUCCESS);
142    ASSERT_EQ(PORT_SetEventCallback(*server_handle, event_callback),
143              PORT_SUCCESS);
144  }
145
146  void ConnectServerL2cap(const RawAddress& peer_addr, uint16_t acl_handle,
147                          uint16_t lcid) {
148    VLOG(1) << "Step 1";
149    // Remote device connect to this channel, we shall accept
150    static const uint8_t cmd_id = 0x07;
151    EXPECT_CALL(l2cap_interface_,
152                ConnectResponse(peer_addr, cmd_id, lcid, L2CAP_CONN_OK, 0));
153    tL2CAP_CFG_INFO cfg_req = {.mtu_present = true, .mtu = L2CAP_MTU_SIZE};
154    EXPECT_CALL(l2cap_interface_,
155                ConfigRequest(lcid, PointerMemoryEqual(&cfg_req)))
156        .WillOnce(Return(true));
157    l2cap_appl_info_.pL2CA_ConnectInd_Cb(peer_addr, lcid, BT_PSM_RFCOMM,
158                                         cmd_id);
159
160    VLOG(1) << "Step 2";
161    // MTU configuration is done
162    cfg_req.mtu_present = false;
163    l2cap_appl_info_.pL2CA_ConfigCfm_Cb(lcid, &cfg_req);
164
165    VLOG(1) << "Step 3";
166    // Remote device also ask to configure MTU size
167    EXPECT_CALL(l2cap_interface_,
168                ConfigResponse(lcid, PointerMemoryEqual(&cfg_req)))
169        .WillOnce(Return(true));
170    l2cap_appl_info_.pL2CA_ConfigInd_Cb(lcid, &cfg_req);
171
172    VLOG(1) << "Step 4";
173    // Remote device connect to server channel 0
174    BT_HDR* sabm_channel_0 = AllocateWrappedIncomingL2capAclPacket(
175        CreateQuickSabmPacket(RFCOMM_MX_DLCI, lcid, acl_handle));
176    BT_HDR* ua_channel_0 = AllocateWrappedOutgoingL2capAclPacket(
177        CreateQuickUaPacket(RFCOMM_MX_DLCI, lcid, acl_handle));
178    EXPECT_CALL(l2cap_interface_, DataWrite(lcid, BtHdrEqual(ua_channel_0)))
179        .WillOnce(Return(L2CAP_DW_SUCCESS));
180    // Packet should be freed by RFCOMM
181    l2cap_appl_info_.pL2CA_DataInd_Cb(lcid, sabm_channel_0);
182    osi_free(ua_channel_0);
183  }
184
185  void ConnectServerPort(const RawAddress& peer_addr, uint16_t port_handle,
186                         uint8_t scn, uint16_t mtu, uint16_t acl_handle,
187                         uint16_t lcid, int port_callback_index) {
188    VLOG(1) << "Step 1";
189    // Negotiate parameters on scn
190    BT_HDR* uih_pn_cmd_from_peer = AllocateWrappedIncomingL2capAclPacket(
191        CreateQuickPnPacket(true, GetDlci(false, scn), true, mtu,
192                            RFCOMM_PN_CONV_LAYER_CBFC_I >> 4, 0, RFCOMM_K_MAX,
193                            lcid, acl_handle));
194    BT_HDR* uih_pn_rsp_to_peer = AllocateWrappedOutgoingL2capAclPacket(
195        CreateQuickPnPacket(false, GetDlci(false, scn), false, mtu,
196                            RFCOMM_PN_CONV_LAYER_CBFC_R >> 4, 0, RFCOMM_K_MAX,
197                            lcid, acl_handle));
198    EXPECT_CALL(l2cap_interface_,
199                DataWrite(lcid, BtHdrEqual(uih_pn_rsp_to_peer)))
200        .WillOnce(Return(L2CAP_DW_SUCCESS));
201    // uih_pn_cmd_from_peer should be freed by this method
202    l2cap_appl_info_.pL2CA_DataInd_Cb(lcid, uih_pn_cmd_from_peer);
203    osi_free(uih_pn_rsp_to_peer);
204
205    VLOG(1) << "Step 2";
206    // Remote device connect to scn
207    tBTM_SEC_CALLBACK* security_callback = nullptr;
208    void* p_port = nullptr;
209    BT_HDR* sabm_channel_dlci = AllocateWrappedIncomingL2capAclPacket(
210        CreateQuickSabmPacket(GetDlci(false, scn), lcid, acl_handle));
211    EXPECT_CALL(btm_security_internal_interface_,
212                MultiplexingProtocolAccessRequest(peer_addr, BT_PSM_RFCOMM,
213                                                  false, BTM_SEC_PROTO_RFCOMM,
214                                                  scn, NotNull(), NotNull()))
215        .WillOnce(DoAll(SaveArg<5>(&security_callback), SaveArg<6>(&p_port),
216                        Return(BTM_SUCCESS)));
217    // sabm_channel_dlci should be freed by this method
218    l2cap_appl_info_.pL2CA_DataInd_Cb(lcid, sabm_channel_dlci);
219
220    VLOG(1) << "Step 3";
221    // Confirm security check should trigger port as connected
222    EXPECT_CALL(
223        rfcomm_callback_,
224        PortManagementCallback(PORT_SUCCESS, port_handle, port_callback_index));
225    BT_HDR* ua_channel_dlci = AllocateWrappedOutgoingL2capAclPacket(
226        CreateQuickUaPacket(GetDlci(false, scn), lcid, acl_handle));
227    EXPECT_CALL(l2cap_interface_, DataWrite(lcid, BtHdrEqual(ua_channel_dlci)))
228        .WillOnce(Return(L2CAP_DW_SUCCESS));
229    ASSERT_TRUE(security_callback);
230    security_callback(&peer_addr, BT_TRANSPORT_BR_EDR, p_port, BTM_SUCCESS);
231    osi_free(ua_channel_dlci);
232
233    VLOG(1) << "Step 4";
234    // Remote also need to configure its modem signal before we can send data
235    BT_HDR* uih_msc_cmd_from_peer = AllocateWrappedIncomingL2capAclPacket(
236        CreateQuickMscPacket(true, GetDlci(false, scn), lcid, acl_handle, true,
237                             false, true, true, false, true));
238    BT_HDR* uih_msc_response_to_peer = AllocateWrappedOutgoingL2capAclPacket(
239        CreateQuickMscPacket(false, GetDlci(false, scn), lcid, acl_handle,
240                             false, false, true, true, false, true));
241    // We also have to do modem configuration ourself
242    EXPECT_CALL(l2cap_interface_,
243                DataWrite(lcid, BtHdrEqual(uih_msc_response_to_peer)))
244        .WillOnce(Return(L2CAP_DW_SUCCESS));
245    BT_HDR* uih_msc_cmd_to_peer = AllocateWrappedOutgoingL2capAclPacket(
246        CreateQuickMscPacket(false, GetDlci(false, scn), lcid, acl_handle, true,
247                             false, true, true, false, true));
248    EXPECT_CALL(l2cap_interface_,
249                DataWrite(lcid, BtHdrEqual(uih_msc_cmd_to_peer)))
250        .WillOnce(Return(L2CAP_DW_SUCCESS));
251    // uih_msc_cmd_from_peer should be freed by this method
252    l2cap_appl_info_.pL2CA_DataInd_Cb(lcid, uih_msc_cmd_from_peer);
253    osi_free(uih_msc_response_to_peer);
254
255    VLOG(1) << "Step 5";
256    // modem configuration is done
257    BT_HDR* uih_msc_response_from_peer = AllocateWrappedIncomingL2capAclPacket(
258        CreateQuickMscPacket(true, GetDlci(false, scn), lcid, acl_handle, false,
259                             false, true, true, false, true));
260    // uih_msc_response_from_peer should be freed by this method
261    l2cap_appl_info_.pL2CA_DataInd_Cb(lcid, uih_msc_response_from_peer);
262  }
263
264  void StartClientPort(const RawAddress& peer_bd_addr, uint16_t uuid,
265                       uint8_t scn, uint16_t mtu,
266                       tPORT_CALLBACK* management_callback,
267                       tPORT_CALLBACK* event_callback, uint16_t lcid,
268                       uint16_t acl_handle, uint16_t* client_handle,
269                       bool is_first_connection) {
270    VLOG(1) << "Step 1";
271    BT_HDR* uih_pn_channel_3 =
272        AllocateWrappedOutgoingL2capAclPacket(CreateQuickPnPacket(
273            true, GetDlci(false, scn), true, mtu, RFCOMM_PN_CONV_LAYER_TYPE_1,
274            RFCOMM_PN_PRIORITY_0, RFCOMM_K, lcid, acl_handle));
275    if (is_first_connection) {
276      EXPECT_CALL(l2cap_interface_, ConnectRequest(BT_PSM_RFCOMM, peer_bd_addr))
277          .WillOnce(Return(lcid));
278    } else {
279      EXPECT_CALL(l2cap_interface_,
280                  DataWrite(lcid, BtHdrEqual(uih_pn_channel_3)))
281          .WillOnce(Return(L2CAP_DW_SUCCESS));
282    }
283    ASSERT_EQ(RFCOMM_CreateConnection(uuid, scn, false, mtu, peer_bd_addr,
284                                      client_handle, management_callback),
285              PORT_SUCCESS);
286    ASSERT_EQ(PORT_SetEventMask(*client_handle, PORT_EV_RXCHAR), PORT_SUCCESS);
287    ASSERT_EQ(PORT_SetEventCallback(*client_handle, event_callback),
288              PORT_SUCCESS);
289    osi_free(uih_pn_channel_3);
290  }
291
292  void TestConnectClientPortL2cap(uint16_t acl_handle, uint16_t lcid) {
293    VLOG(1) << "Step 1";
294    // Send configuration request when L2CAP connect is succsseful
295    tL2CAP_CFG_INFO cfg_req = {.mtu_present = true, .mtu = L2CAP_MTU_SIZE};
296    EXPECT_CALL(l2cap_interface_,
297                ConfigRequest(lcid, PointerMemoryEqual(&cfg_req)))
298        .WillOnce(Return(true));
299    l2cap_appl_info_.pL2CA_ConnectCfm_Cb(lcid, L2CAP_CONN_OK);
300
301    VLOG(1) << "Step 2";
302    // Remote device confirms our configuration request
303    cfg_req.mtu_present = false;
304    l2cap_appl_info_.pL2CA_ConfigCfm_Cb(lcid, &cfg_req);
305
306    VLOG(1) << "Step 3";
307    // Remote device also asks to configure MTU
308    // Once configuration is done, we connect to multiplexer control channel 0
309    EXPECT_CALL(l2cap_interface_,
310                ConfigResponse(lcid, PointerMemoryEqual(&cfg_req)))
311        .WillOnce(Return(true));
312    // multiplexer control channel's DLCI is always 0
313    BT_HDR* sabm_channel_0 = AllocateWrappedOutgoingL2capAclPacket(
314        CreateQuickSabmPacket(RFCOMM_MX_DLCI, lcid, acl_handle));
315    EXPECT_CALL(l2cap_interface_, DataWrite(lcid, BtHdrEqual(sabm_channel_0)))
316        .WillOnce(Return(L2CAP_DW_SUCCESS));
317    l2cap_appl_info_.pL2CA_ConfigInd_Cb(lcid, &cfg_req);
318    osi_free(sabm_channel_0);
319  }
320
321  void ConnectClientPort(const RawAddress& peer_addr, uint16_t port_handle,
322                         uint8_t scn, uint16_t mtu, uint16_t acl_handle,
323                         uint16_t lcid, int port_callback_index,
324                         bool is_first_connection) {
325    VLOG(1) << "Step 1";
326    if (is_first_connection) {
327      VLOG(1) << "Step 1.5";
328      // Once remote accept multiplexer control channel 0
329      // We change to desired channel on non-initiating device (remote device)
330      BT_HDR* ua_channel_0 = AllocateWrappedIncomingL2capAclPacket(
331          CreateQuickUaPacket(RFCOMM_MX_DLCI, lcid, acl_handle));
332      BT_HDR* uih_pn_channel_3 =
333          AllocateWrappedOutgoingL2capAclPacket(CreateQuickPnPacket(
334              true, GetDlci(false, scn), true, mtu,
335              RFCOMM_PN_CONV_LAYER_CBFC_I >> 4, RFCOMM_PN_PRIORITY_0,
336              RFCOMM_K_MAX, lcid, acl_handle));
337      EXPECT_CALL(l2cap_interface_,
338                  DataWrite(lcid, BtHdrEqual(uih_pn_channel_3)))
339          .WillOnce(Return(L2CAP_DW_SUCCESS));
340      l2cap_appl_info_.pL2CA_DataInd_Cb(lcid, ua_channel_0);
341      osi_free(uih_pn_channel_3);
342    }
343
344    VLOG(1) << "Step 2";
345    // Once remote accept service channel change, we start security procedure
346    BT_HDR* uih_pn_channel_3_accept =
347        AllocateWrappedIncomingL2capAclPacket(CreateQuickPnPacket(
348            false, GetDlci(false, scn), false, mtu,
349            RFCOMM_PN_CONV_LAYER_CBFC_I >> 4, RFCOMM_PN_PRIORITY_0,
350            RFCOMM_K_MAX, lcid, acl_handle));
351    tBTM_SEC_CALLBACK* security_callback = nullptr;
352    void* p_port = nullptr;
353    EXPECT_CALL(btm_security_internal_interface_,
354                MultiplexingProtocolAccessRequest(peer_addr, BT_PSM_RFCOMM,
355                                                  true, BTM_SEC_PROTO_RFCOMM,
356                                                  scn, NotNull(), NotNull()))
357        .WillOnce(DoAll(SaveArg<5>(&security_callback), SaveArg<6>(&p_port),
358                        Return(BTM_SUCCESS)));
359    l2cap_appl_info_.pL2CA_DataInd_Cb(lcid, uih_pn_channel_3_accept);
360
361    VLOG(1) << "Step 3";
362    // Once security procedure is done, we officially connect to target scn
363    BT_HDR* sabm_channel_3 = AllocateWrappedOutgoingL2capAclPacket(
364        CreateQuickSabmPacket(GetDlci(false, scn), lcid, acl_handle));
365    EXPECT_CALL(l2cap_interface_, DataWrite(lcid, BtHdrEqual(sabm_channel_3)))
366        .WillOnce(Return(L2CAP_DW_SUCCESS));
367    ASSERT_TRUE(security_callback);
368    security_callback(&peer_addr, BT_TRANSPORT_BR_EDR, p_port, BTM_SUCCESS);
369    osi_free(sabm_channel_3);
370
371    VLOG(1) << "Step 4";
372    // When target scn is accepted by remote, we need to configure modem signal
373    // state beofre using the port
374    EXPECT_CALL(
375        rfcomm_callback_,
376        PortManagementCallback(PORT_SUCCESS, port_handle, port_callback_index));
377    BT_HDR* uih_msc_cmd = AllocateWrappedOutgoingL2capAclPacket(
378        CreateQuickMscPacket(true, GetDlci(false, scn), lcid, acl_handle, true,
379                             false, true, true, false, true));
380    EXPECT_CALL(l2cap_interface_, DataWrite(lcid, BtHdrEqual(uih_msc_cmd)))
381        .WillOnce(Return(L2CAP_DW_SUCCESS));
382    BT_HDR* ua_channel_3 = AllocateWrappedIncomingL2capAclPacket(
383        CreateQuickUaPacket(GetDlci(false, scn), lcid, acl_handle));
384    l2cap_appl_info_.pL2CA_DataInd_Cb(lcid, ua_channel_3);
385    osi_free(uih_msc_cmd);
386
387    VLOG(1) << "Step 5";
388    // modem configuration is done
389    BT_HDR* uih_msc_response = AllocateWrappedIncomingL2capAclPacket(
390        CreateQuickMscPacket(false, GetDlci(false, scn), lcid, acl_handle,
391                             false, false, true, true, false, true));
392    l2cap_appl_info_.pL2CA_DataInd_Cb(lcid, uih_msc_response);
393
394    VLOG(1) << "Step 6";
395    // Remote also need to configure its modem signal before we can send data
396    BT_HDR* uih_msc_cmd_from_peer = AllocateWrappedIncomingL2capAclPacket(
397        CreateQuickMscPacket(false, GetDlci(false, scn), lcid, acl_handle, true,
398                             false, true, true, false, true));
399    BT_HDR* uih_msc_response_to_peer = AllocateWrappedOutgoingL2capAclPacket(
400        CreateQuickMscPacket(true, GetDlci(false, scn), lcid, acl_handle, false,
401                             false, true, true, false, true));
402    EXPECT_CALL(l2cap_interface_,
403                DataWrite(lcid, BtHdrEqual(uih_msc_response_to_peer)))
404        .WillOnce(Return(L2CAP_DW_SUCCESS));
405    l2cap_appl_info_.pL2CA_DataInd_Cb(lcid, uih_msc_cmd_from_peer);
406    osi_free(uih_msc_response_to_peer);
407  }
408
409  void SendAndVerifyOutgoingTransmission(uint16_t port_handle,
410                                         bool is_initiator, uint8_t scn,
411                                         bool cr, const std::string& message,
412                                         int credits, uint16_t acl_handle,
413                                         uint16_t lcid) {
414    VLOG(1) << "Step 1";
415    BT_HDR* data_packet = AllocateWrappedOutgoingL2capAclPacket(
416        CreateQuickDataPacket(GetDlci(is_initiator, scn), cr, lcid, acl_handle,
417                              credits, message));
418    uint16_t transmitted_length = 0;
419    EXPECT_CALL(l2cap_interface_, DataWrite(lcid, BtHdrEqual(data_packet)))
420        .WillOnce(Return(L2CAP_DW_SUCCESS));
421    ASSERT_EQ(PORT_WriteData(port_handle, message.data(), message.size(),
422                             &transmitted_length),
423              PORT_SUCCESS);
424    ASSERT_EQ(transmitted_length, message.size());
425  }
426
427  void ReceiveAndVerifyIncomingTransmission(uint16_t port_handle,
428                                            bool is_initiator, uint8_t scn,
429                                            bool cr, const std::string& message,
430                                            int credits, uint16_t acl_handle,
431                                            uint16_t lcid,
432                                            int port_callback_index) {
433    VLOG(1) << "Step 1";
434    BT_HDR* data_packet = AllocateWrappedIncomingL2capAclPacket(
435        CreateQuickDataPacket(GetDlci(is_initiator, scn), cr, lcid, acl_handle,
436                              credits, message));
437    EXPECT_CALL(rfcomm_callback_,
438                PortEventCallback(_, port_handle, port_callback_index));
439    l2cap_appl_info_.pL2CA_DataInd_Cb(lcid, data_packet);
440
441    VLOG(1) << "Step 2";
442    char buffer[L2CAP_MTU_SIZE] = {};
443    uint16_t length = 0;
444    int status = PORT_ReadData(port_handle, buffer, L2CAP_MTU_SIZE, &length);
445    ASSERT_EQ(status, PORT_SUCCESS);
446    ASSERT_THAT(buffer, StrEq(message));
447  }
448
449 protected:
450  void SetUp() override {
451    Test::SetUp();
452    bluetooth::manager::SetMockSecurityInternalInterface(
453        &btm_security_internal_interface_);
454    bluetooth::l2cap::SetMockInterface(&l2cap_interface_);
455    rfcomm_callback = &rfcomm_callback_;
456    EXPECT_CALL(l2cap_interface_, Register(BT_PSM_RFCOMM, _))
457        .WillOnce(
458            DoAll(SaveArgPointee<1>(&l2cap_appl_info_), Return(BT_PSM_RFCOMM)));
459    RFCOMM_Init();
460    rfc_cb.trace_level = BT_TRACE_LEVEL_DEBUG;
461  }
462
463  void TearDown() override {
464    rfcomm_callback = nullptr;
465    bluetooth::l2cap::SetMockInterface(nullptr);
466    bluetooth::manager::SetMockSecurityInternalInterface(nullptr);
467    testing::Test::TearDown();
468  }
469  StrictMock<bluetooth::manager::MockBtmSecurityInternalInterface>
470      btm_security_internal_interface_;
471  StrictMock<bluetooth::l2cap::MockL2capInterface> l2cap_interface_;
472  StrictMock<bluetooth::rfcomm::MockRfcommCallback> rfcomm_callback_;
473  tL2CAP_APPL_INFO l2cap_appl_info_;
474};
475
476TEST_F(StackRfcommTest, SingleServerConnectionHelloWorld) {
477  // Prepare a server channel at kTestChannelNumber0
478  static const uint16_t acl_handle = 0x0009;
479  static const uint16_t lcid = 0x0054;
480  static const uint16_t test_uuid = 0x1112;
481  static const uint8_t test_scn = 8;
482  static const uint16_t test_mtu = 1600;
483  static const RawAddress test_address = GetTestAddress(0);
484  uint16_t server_handle = 0;
485  ASSERT_NO_FATAL_FAILURE(StartServerPort(test_uuid, test_scn, test_mtu,
486                                          port_mgmt_cback_0, port_event_cback_0,
487                                          &server_handle));
488  ASSERT_NO_FATAL_FAILURE(ConnectServerL2cap(test_address, acl_handle, lcid));
489  ASSERT_NO_FATAL_FAILURE(ConnectServerPort(
490      test_address, server_handle, test_scn, test_mtu, acl_handle, lcid, 0));
491  ASSERT_NO_FATAL_FAILURE(ReceiveAndVerifyIncomingTransmission(
492      server_handle, false, test_scn, true, "Hello World!\r", 50, acl_handle,
493      lcid, 0));
494  ASSERT_NO_FATAL_FAILURE(
495      SendAndVerifyOutgoingTransmission(server_handle, false, test_scn, false,
496                                        "\r!dlroW olleH", 4, acl_handle, lcid));
497}
498
499TEST_F(StackRfcommTest, MultiServerPortSameDeviceHelloWorld) {
500  // Prepare a server channel at kTestChannelNumber0
501  static const uint16_t acl_handle = 0x0009;
502  static const uint16_t lcid = 0x0054;
503  static const uint16_t test_mtu = 1600;
504  static const RawAddress test_address = GetTestAddress(0);
505
506  // Service 0
507  uint16_t server_handle_0 = 0;
508  static const uint8_t test_scn_0 = 8;
509  static const uint16_t test_uuid_0 = 0x1112;
510  ASSERT_NO_FATAL_FAILURE(StartServerPort(test_uuid_0, test_scn_0, test_mtu,
511                                          port_mgmt_cback_0, port_event_cback_0,
512                                          &server_handle_0));
513  ASSERT_NO_FATAL_FAILURE(ConnectServerL2cap(test_address, acl_handle, lcid));
514  ASSERT_NO_FATAL_FAILURE(ConnectServerPort(test_address, server_handle_0,
515                                            test_scn_0, test_mtu, acl_handle,
516                                            lcid, 0));
517
518  // Service 1
519  uint16_t server_handle_1 = 0;
520  static const uint8_t test_scn_1 = 10;
521  static const uint16_t test_uuid_1 = 0x111F;
522  ASSERT_NE(test_scn_1, test_scn_0);
523  ASSERT_NE(test_uuid_1, test_uuid_0);
524  ASSERT_NO_FATAL_FAILURE(StartServerPort(test_uuid_1, test_scn_1, test_mtu,
525                                          port_mgmt_cback_1, port_event_cback_1,
526                                          &server_handle_1));
527  // No L2CAP setup for 2nd device
528  ASSERT_NO_FATAL_FAILURE(ConnectServerPort(test_address, server_handle_1,
529                                            test_scn_1, test_mtu, acl_handle,
530                                            lcid, 1));
531
532  // Use service 0
533  ASSERT_NO_FATAL_FAILURE(ReceiveAndVerifyIncomingTransmission(
534      server_handle_0, false, test_scn_0, true, "Hello World0!\r", 50,
535      acl_handle, lcid, 0));
536  ASSERT_NO_FATAL_FAILURE(SendAndVerifyOutgoingTransmission(
537      server_handle_0, false, test_scn_0, false, "\r!0dlroW olleH", 4,
538      acl_handle, lcid));
539  // Use service 1
540  ASSERT_NO_FATAL_FAILURE(ReceiveAndVerifyIncomingTransmission(
541      server_handle_1, false, test_scn_1, true, "Hello World1!\r", 50,
542      acl_handle, lcid, 1));
543  ASSERT_NO_FATAL_FAILURE(SendAndVerifyOutgoingTransmission(
544      server_handle_1, false, test_scn_1, false, "\r!1dlroW olleH", 4,
545      acl_handle, lcid));
546}
547
548TEST_F(StackRfcommTest, SameServerPortMultiDeviceHelloWorld) {
549  // Prepare a server channel at kTestChannelNumber0
550  static const uint16_t test_mtu = 1600;
551  static const uint8_t test_scn = 3;
552  static const uint16_t test_uuid = 0x1112;
553
554  // Service 0
555  static const RawAddress test_address_0 = GetTestAddress(0);
556  static const uint16_t acl_handle_0 = 0x0009;
557  static const uint16_t lcid_0 = 0x0054;
558  uint16_t server_handle_0 = 0;
559  ASSERT_NO_FATAL_FAILURE(StartServerPort(test_uuid, test_scn, test_mtu,
560                                          port_mgmt_cback_0, port_event_cback_0,
561                                          &server_handle_0));
562  ASSERT_NO_FATAL_FAILURE(
563      ConnectServerL2cap(test_address_0, acl_handle_0, lcid_0));
564  ASSERT_NO_FATAL_FAILURE(ConnectServerPort(test_address_0, server_handle_0,
565                                            test_scn, test_mtu, acl_handle_0,
566                                            lcid_0, 0));
567
568  // Service 1
569  static const RawAddress test_address_1 = GetTestAddress(1);
570  static const uint16_t acl_handle_1 = 0x0012;
571  static const uint16_t lcid_1 = 0x0045;
572  uint16_t server_handle_1 = 0;
573  ASSERT_NO_FATAL_FAILURE(StartServerPort(test_uuid, test_scn, test_mtu,
574                                          port_mgmt_cback_1, port_event_cback_1,
575                                          &server_handle_1));
576  ASSERT_NO_FATAL_FAILURE(
577      ConnectServerL2cap(test_address_1, acl_handle_1, lcid_1));
578  ASSERT_NO_FATAL_FAILURE(ConnectServerPort(test_address_1, server_handle_1,
579                                            test_scn, test_mtu, acl_handle_1,
580                                            lcid_1, 1));
581
582  // Use service 0
583  ASSERT_NO_FATAL_FAILURE(ReceiveAndVerifyIncomingTransmission(
584      server_handle_0, false, test_scn, true, "Hello World0!\r", 50,
585      acl_handle_0, lcid_0, 0));
586  ASSERT_NO_FATAL_FAILURE(SendAndVerifyOutgoingTransmission(
587      server_handle_0, false, test_scn, false, "\r!0dlroW olleH", 4,
588      acl_handle_0, lcid_0));
589  // Use service 1
590  ASSERT_NO_FATAL_FAILURE(ReceiveAndVerifyIncomingTransmission(
591      server_handle_1, false, test_scn, true, "Hello World1!\r", 50,
592      acl_handle_1, lcid_1, 1));
593  ASSERT_NO_FATAL_FAILURE(SendAndVerifyOutgoingTransmission(
594      server_handle_1, false, test_scn, false, "\r!1dlroW olleH", 4,
595      acl_handle_1, lcid_1));
596}
597
598TEST_F(StackRfcommTest, SingleClientConnectionHelloWorld) {
599  static const uint16_t acl_handle = 0x0009;
600  static const uint16_t lcid = 0x0054;
601  static const uint16_t test_uuid = 0x1112;
602  static const uint8_t test_scn = 8;
603  static const uint16_t test_mtu = 1600;
604  static const RawAddress test_address = GetTestAddress(0);
605  uint16_t client_handle = 0;
606  ASSERT_NO_FATAL_FAILURE(StartClientPort(
607      test_address, test_uuid, test_scn, test_mtu, port_mgmt_cback_0,
608      port_event_cback_0, lcid, acl_handle, &client_handle, true));
609  ASSERT_NO_FATAL_FAILURE(TestConnectClientPortL2cap(acl_handle, lcid));
610  ASSERT_NO_FATAL_FAILURE(ConnectClientPort(test_address, client_handle,
611                                            test_scn, test_mtu, acl_handle,
612                                            lcid, 0, true));
613  ASSERT_NO_FATAL_FAILURE(SendAndVerifyOutgoingTransmission(
614      client_handle, false, test_scn, true, "\r!dlroW olleH", -1, acl_handle,
615      lcid));
616  ASSERT_NO_FATAL_FAILURE(ReceiveAndVerifyIncomingTransmission(
617      client_handle, false, test_scn, false, "Hello World!\r", -1, acl_handle,
618      lcid, 0));
619}
620
621TEST_F(StackRfcommTest, MultiClientPortSameDeviceHelloWorld) {
622  static const uint16_t acl_handle = 0x0009;
623  static const uint16_t lcid = 0x0054;
624  static const uint16_t test_mtu = 1600;
625  static const RawAddress test_address = GetTestAddress(0);
626
627  // Connection 0
628  static const uint16_t test_uuid_0 = 0x1112;
629  static const uint8_t test_scn_0 = 8;
630  uint16_t client_handle_0 = 0;
631  ASSERT_NO_FATAL_FAILURE(StartClientPort(
632      test_address, test_uuid_0, test_scn_0, test_mtu, port_mgmt_cback_0,
633      port_event_cback_0, lcid, acl_handle, &client_handle_0, true));
634  ASSERT_NO_FATAL_FAILURE(TestConnectClientPortL2cap(acl_handle, lcid));
635  ASSERT_NO_FATAL_FAILURE(ConnectClientPort(test_address, client_handle_0,
636                                            test_scn_0, test_mtu, acl_handle,
637                                            lcid, 0, true));
638
639  // Connection 1
640  static const uint16_t test_uuid_1 = 0x111F;
641  static const uint8_t test_scn_1 = 10;
642  uint16_t client_handle_1 = 0;
643  ASSERT_NO_FATAL_FAILURE(StartClientPort(
644      test_address, test_uuid_1, test_scn_1, test_mtu, port_mgmt_cback_1,
645      port_event_cback_1, lcid, acl_handle, &client_handle_1, false));
646  ASSERT_NO_FATAL_FAILURE(ConnectClientPort(test_address, client_handle_1,
647                                            test_scn_1, test_mtu, acl_handle,
648                                            lcid, 1, false));
649
650  // Use connection 0
651  ASSERT_NO_FATAL_FAILURE(SendAndVerifyOutgoingTransmission(
652      client_handle_0, false, test_scn_0, true, "\r!dlroW olleH", -1,
653      acl_handle, lcid));
654  ASSERT_NO_FATAL_FAILURE(ReceiveAndVerifyIncomingTransmission(
655      client_handle_0, false, test_scn_0, false, "Hello World!\r", -1,
656      acl_handle, lcid, 0));
657
658  // Use connection 1
659  ASSERT_NO_FATAL_FAILURE(SendAndVerifyOutgoingTransmission(
660      client_handle_1, false, test_scn_1, true, "\r!dlroW olleH", -1,
661      acl_handle, lcid));
662  ASSERT_NO_FATAL_FAILURE(ReceiveAndVerifyIncomingTransmission(
663      client_handle_1, false, test_scn_1, false, "Hello World!\r", -1,
664      acl_handle, lcid, 1));
665}
666
667TEST_F(StackRfcommTest, SameClientPortMultiDeviceHelloWorld) {
668  static const uint16_t test_uuid = 0x1112;
669  static const uint8_t test_scn = 8;
670  static const uint16_t test_mtu = 1600;
671
672  // Connection 0
673  static const RawAddress test_address_0 = GetTestAddress(0);
674  static const uint16_t acl_handle_0 = 0x0009;
675  static const uint16_t lcid_0 = 0x0054;
676  uint16_t client_handle_0 = 0;
677  ASSERT_NO_FATAL_FAILURE(StartClientPort(
678      test_address_0, test_uuid, test_scn, test_mtu, port_mgmt_cback_0,
679      port_event_cback_0, lcid_0, acl_handle_0, &client_handle_0, true));
680  ASSERT_NO_FATAL_FAILURE(TestConnectClientPortL2cap(acl_handle_0, lcid_0));
681  ASSERT_NO_FATAL_FAILURE(ConnectClientPort(test_address_0, client_handle_0,
682                                            test_scn, test_mtu, acl_handle_0,
683                                            lcid_0, 0, true));
684
685  // Connection 1
686  static const RawAddress test_address_1 = GetTestAddress(1);
687  static const uint16_t acl_handle_1 = 0x0012;
688  static const uint16_t lcid_1 = 0x0045;
689  uint16_t client_handle_1 = 0;
690  ASSERT_NO_FATAL_FAILURE(StartClientPort(
691      test_address_1, test_uuid, test_scn, test_mtu, port_mgmt_cback_1,
692      port_event_cback_1, lcid_1, acl_handle_1, &client_handle_1, true));
693  ASSERT_NO_FATAL_FAILURE(TestConnectClientPortL2cap(acl_handle_1, lcid_1));
694  ASSERT_NO_FATAL_FAILURE(ConnectClientPort(test_address_1, client_handle_1,
695                                            test_scn, test_mtu, acl_handle_1,
696                                            lcid_1, 1, true));
697
698  // Use connection 0
699  ASSERT_NO_FATAL_FAILURE(SendAndVerifyOutgoingTransmission(
700      client_handle_0, false, test_scn, true, "\r!dlroW olleH", -1,
701      acl_handle_0, lcid_0));
702  ASSERT_NO_FATAL_FAILURE(ReceiveAndVerifyIncomingTransmission(
703      client_handle_0, false, test_scn, false, "Hello World!\r", -1,
704      acl_handle_0, lcid_0, 0));
705
706  // Use connection 1
707  ASSERT_NO_FATAL_FAILURE(SendAndVerifyOutgoingTransmission(
708      client_handle_1, false, test_scn, true, "\r!dlroW olleH", -1,
709      acl_handle_1, lcid_1));
710  ASSERT_NO_FATAL_FAILURE(ReceiveAndVerifyIncomingTransmission(
711      client_handle_1, false, test_scn, false, "Hello World!\r", -1,
712      acl_handle_1, lcid_1, 1));
713}
714
715TEST_F(StackRfcommTest, TestConnectionCollision) {
716  static const uint16_t acl_handle = 0x0008;
717  static const uint16_t old_lcid = 0x004a;
718  static const uint16_t new_lcid = 0x005c;
719  static const uint16_t test_uuid = 0x1112;
720  static const uint8_t test_server_scn = 3;
721  static const uint8_t test_peer_scn = 10;
722  // Must be smaller than L2CAP_MTU_SIZE by at least 4 bytes
723  static const uint16_t test_mtu = 1000;
724  static const RawAddress test_address = GetTestAddress(0);
725  uint16_t server_handle = 0;
726  VLOG(1) << "Step 1";
727  // Prepare a server port
728  int status = RFCOMM_CreateConnection(test_uuid, test_server_scn, true,
729                                       test_mtu, RawAddress::kAny,
730                                       &server_handle, port_mgmt_cback_0);
731  ASSERT_EQ(status, PORT_SUCCESS);
732  status = PORT_SetEventMask(server_handle, PORT_EV_RXCHAR);
733  ASSERT_EQ(status, PORT_SUCCESS);
734  status = PORT_SetEventCallback(server_handle, port_event_cback_0);
735  ASSERT_EQ(status, PORT_SUCCESS);
736
737  VLOG(1) << "Step 2";
738  // Try to connect to a client port
739  uint16_t client_handle_1 = 0;
740  EXPECT_CALL(l2cap_interface_, ConnectRequest(BT_PSM_RFCOMM, test_address))
741      .Times(1)
742      .WillOnce(Return(old_lcid));
743  status = RFCOMM_CreateConnection(test_uuid, test_peer_scn, false, test_mtu,
744                                   test_address, &client_handle_1,
745                                   port_mgmt_cback_1);
746  ASSERT_EQ(status, PORT_SUCCESS);
747  status = PORT_SetEventMask(client_handle_1, PORT_EV_RXCHAR);
748  ASSERT_EQ(status, PORT_SUCCESS);
749  status = PORT_SetEventCallback(client_handle_1, port_event_cback_1);
750  ASSERT_EQ(status, PORT_SUCCESS);
751
752  VLOG(1) << "Step 3";
753  // While our connection is pending, remote device tries to connect to
754  // new_lcid, with L2CAP command id: pending_cmd_id
755  static const uint8_t pending_cmd_id = 0x05;
756  // RFCOMM starts timer for collision:
757  l2cap_appl_info_.pL2CA_ConnectInd_Cb(test_address, new_lcid, BT_PSM_RFCOMM,
758                                       pending_cmd_id);
759
760  VLOG(1) << "Step 4";
761  // Remote reject our connection request saying PSM not allowed
762  // This should trigger RFCOMM to accept remote L2CAP connection at new_lcid
763  EXPECT_CALL(l2cap_interface_, ConnectResponse(test_address, pending_cmd_id,
764                                                new_lcid, L2CAP_CONN_OK, 0))
765      .WillOnce(Return(true));
766  // Followed by configure request for MTU size
767  tL2CAP_CFG_INFO our_cfg_req = {.mtu_present = true, .mtu = L2CAP_MTU_SIZE};
768  EXPECT_CALL(l2cap_interface_,
769              ConfigRequest(new_lcid, PointerMemoryEqual(&our_cfg_req)))
770      .WillOnce(Return(true));
771  l2cap_appl_info_.pL2CA_ConnectCfm_Cb(old_lcid, L2CAP_CONN_NO_PSM);
772
773  VLOG(1) << "Step 5";
774  // Remote device also ask to configure MTU size as well
775  tL2CAP_CFG_INFO peer_cfg_req = {.mtu_present = true, .mtu = test_mtu};
776  // We responded by saying OK
777  tL2CAP_CFG_INFO our_cfg_rsp = {.result = L2CAP_CFG_OK,
778                                 .mtu = peer_cfg_req.mtu};
779  EXPECT_CALL(l2cap_interface_,
780              ConfigResponse(new_lcid, PointerMemoryEqual(&our_cfg_rsp)))
781      .WillOnce(Return(true));
782  l2cap_appl_info_.pL2CA_ConfigInd_Cb(new_lcid, &peer_cfg_req);
783
784  VLOG(1) << "Step 6";
785  // Remote device accepted our MTU size
786  tL2CAP_CFG_INFO peer_cfg_rsp = {.mtu_present = true, .mtu = L2CAP_MTU_SIZE};
787  l2cap_appl_info_.pL2CA_ConfigCfm_Cb(new_lcid, &peer_cfg_rsp);
788
789  // L2CAP collision and connection setup done
790
791  VLOG(1) << "Step 7";
792  // Remote device connect multiplexer channel
793  BT_HDR* sabm_channel_0 = AllocateWrappedIncomingL2capAclPacket(
794      CreateQuickSabmPacket(RFCOMM_MX_DLCI, new_lcid, acl_handle));
795  // We accept
796  BT_HDR* ua_channel_0 = AllocateWrappedOutgoingL2capAclPacket(
797      CreateQuickUaPacket(RFCOMM_MX_DLCI, new_lcid, acl_handle));
798  EXPECT_CALL(l2cap_interface_, DataWrite(new_lcid, BtHdrEqual(ua_channel_0)))
799      .WillOnce(Return(L2CAP_DW_SUCCESS));
800  // And immediately try to configure test_peer_scn
801  BT_HDR* uih_pn_cmd_to_peer = AllocateWrappedOutgoingL2capAclPacket(
802      CreateQuickPnPacket(false, GetDlci(true, test_peer_scn), true, test_mtu,
803                          RFCOMM_PN_CONV_LAYER_CBFC_I >> 4, 0, RFCOMM_K_MAX,
804                          new_lcid, acl_handle));
805  EXPECT_CALL(l2cap_interface_,
806              DataWrite(new_lcid, BtHdrEqual(uih_pn_cmd_to_peer)))
807      .WillOnce(Return(L2CAP_DW_SUCCESS));
808  // Packet should be freed by this method
809  l2cap_appl_info_.pL2CA_DataInd_Cb(new_lcid, sabm_channel_0);
810  osi_free(ua_channel_0);
811  osi_free(uih_pn_cmd_to_peer);
812
813  VLOG(1) << "Step 8";
814  // Peer tries to configure test_server_scn
815  BT_HDR* uih_pn_cmd_from_peer = AllocateWrappedIncomingL2capAclPacket(
816      CreateQuickPnPacket(true, GetDlci(false, test_server_scn), true, test_mtu,
817                          RFCOMM_PN_CONV_LAYER_CBFC_I >> 4, 0, RFCOMM_K_MAX,
818                          new_lcid, acl_handle));
819  // We, as acceptor, must accept
820  BT_HDR* uih_pn_rsp_to_peer = AllocateWrappedOutgoingL2capAclPacket(
821      CreateQuickPnPacket(false, GetDlci(false, test_server_scn), false,
822                          test_mtu, RFCOMM_PN_CONV_LAYER_CBFC_R >> 4, 0,
823                          RFCOMM_K_MAX, new_lcid, acl_handle));
824  EXPECT_CALL(l2cap_interface_,
825              DataWrite(new_lcid, BtHdrEqual(uih_pn_rsp_to_peer)))
826      .Times(1)
827      .WillOnce(Return(L2CAP_DW_SUCCESS));
828  l2cap_appl_info_.pL2CA_DataInd_Cb(new_lcid, uih_pn_cmd_from_peer);
829  osi_free(uih_pn_rsp_to_peer);
830
831  VLOG(1) << "Step 9";
832  // Remote never replies our configuration request for test_peer_scn
833  // But instead connect to test_server_scn directly
834  BT_HDR* sabm_server_scn =
835      AllocateWrappedIncomingL2capAclPacket(CreateQuickSabmPacket(
836          GetDlci(false, test_server_scn), new_lcid, acl_handle));
837  // We must do security check first
838  tBTM_SEC_CALLBACK* security_callback = nullptr;
839  void* p_port = nullptr;
840  EXPECT_CALL(btm_security_internal_interface_,
841              MultiplexingProtocolAccessRequest(
842                  test_address, BT_PSM_RFCOMM, false, BTM_SEC_PROTO_RFCOMM,
843                  test_server_scn, NotNull(), NotNull()))
844      .WillOnce(DoAll(SaveArg<5>(&security_callback), SaveArg<6>(&p_port),
845                      Return(BTM_SUCCESS)));
846  l2cap_appl_info_.pL2CA_DataInd_Cb(new_lcid, sabm_server_scn);
847
848  VLOG(1) << "Step 10";
849  // After security check, we accept the connection
850  ASSERT_TRUE(security_callback);
851  BT_HDR* ua_server_scn =
852      AllocateWrappedOutgoingL2capAclPacket(CreateQuickUaPacket(
853          GetDlci(false, test_server_scn), new_lcid, acl_handle));
854  EXPECT_CALL(l2cap_interface_, DataWrite(new_lcid, BtHdrEqual(ua_server_scn)))
855      .WillOnce(Return(L2CAP_DW_SUCCESS));
856  // Callback should come from server port instead, client port will timeout
857  // in 20 seconds
858  EXPECT_CALL(rfcomm_callback_,
859              PortManagementCallback(PORT_SUCCESS, server_handle, 0));
860  security_callback(&test_address, BT_TRANSPORT_BR_EDR, p_port, BTM_SUCCESS);
861  osi_free(ua_server_scn);
862
863  VLOG(1) << "Step 11";
864  // MPX_CTRL Modem Status Command (MSC)
865  BT_HDR* uih_msc_cmd_from_peer = AllocateWrappedIncomingL2capAclPacket(
866      CreateQuickMscPacket(true, GetDlci(false, test_server_scn), new_lcid,
867                           acl_handle, true, false, true, true, false, true));
868  BT_HDR* uih_msc_rsp_to_peer = AllocateWrappedOutgoingL2capAclPacket(
869      CreateQuickMscPacket(false, GetDlci(false, test_server_scn), new_lcid,
870                           acl_handle, false, false, true, true, false, true));
871  // MPX_CTRL Modem Status Response (MSC)
872  EXPECT_CALL(l2cap_interface_,
873              DataWrite(new_lcid, BtHdrEqual(uih_msc_rsp_to_peer)))
874      .WillOnce(Return(L2CAP_DW_SUCCESS));
875  BT_HDR* uih_msc_cmd_to_peer = AllocateWrappedOutgoingL2capAclPacket(
876      CreateQuickMscPacket(false, GetDlci(false, test_server_scn), new_lcid,
877                           acl_handle, true, false, true, true, false, true));
878  EXPECT_CALL(l2cap_interface_,
879              DataWrite(new_lcid, BtHdrEqual(uih_msc_cmd_to_peer)))
880      .WillOnce(Return(L2CAP_DW_SUCCESS));
881  l2cap_appl_info_.pL2CA_DataInd_Cb(new_lcid, uih_msc_cmd_from_peer);
882  osi_free(uih_msc_rsp_to_peer);
883  osi_free(uih_msc_cmd_to_peer);
884
885  VLOG(1) << "Step 12";
886  BT_HDR* uih_msc_rsp_from_peer = AllocateWrappedIncomingL2capAclPacket(
887      CreateQuickMscPacket(true, GetDlci(false, test_server_scn), new_lcid,
888                           acl_handle, false, false, true, true, false, true));
889  l2cap_appl_info_.pL2CA_DataInd_Cb(new_lcid, uih_msc_rsp_from_peer);
890}
891
892}  // namespace
893