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