1/****************************************************************************** 2 * 3 * Copyright (C) 2017 Google, Inc. 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 "l2cap_packet.h" 20#include "l2cap_test_packets.h" 21 22#include <gtest/gtest.h> 23#include <memory> 24 25using std::unique_ptr; 26using std::vector; 27 28namespace test_vendor_lib { 29 30class L2capTest : public ::testing::Test { 31 public: 32 L2capTest() {} 33 34 void compare_packets(vector<uint8_t>& complete_packet, 35 vector<uint8_t>& assembled_packet) { 36 ASSERT_EQ(complete_packet.size() - 4, assembled_packet.size()); 37 38 for (size_t i = 0; i < assembled_packet.size(); i++) { 39 ASSERT_EQ(complete_packet[i + 4], assembled_packet[i]); 40 } 41 } 42 43 L2capSdu update_fcs(vector<uint8_t> sdu) { 44 sdu.resize(sdu.size() - 2); 45 46 return L2capSdu::L2capSduBuilder(sdu); 47 } 48 49 void compare_fragmented_packets(vector<uint8_t>& expected, 50 vector<uint8_t>& received) { 51 ASSERT_EQ(expected.size(), received.size()); 52 53 for (size_t i = 0; i < expected.size(); i++) { 54 ASSERT_EQ(expected[i], received[i]); 55 } 56 } 57 58 ~L2capTest() = default; 59}; 60 61TEST_F(L2capTest, assembleGoodPackets) { 62 vector<L2capSdu> test_packet; 63 vector<uint8_t> assembled_payload; 64 65 // Test 1: Pass correct packets. 66 test_packet.push_back(L2capSdu(good_sdu[0])); 67 test_packet.push_back(L2capSdu(good_sdu[1])); 68 test_packet.push_back(L2capSdu(good_sdu[2])); 69 70 unique_ptr<L2capPacket> test_1 = L2capPacket::assemble(test_packet); 71 ASSERT_NE(test_1, nullptr); 72 73 assembled_payload = test_1->get_l2cap_payload(); 74 75 compare_packets(good_l2cap_packet, assembled_payload); 76 77 assembled_payload.clear(); 78 test_packet.clear(); 79 80 test_packet.push_back(L2capSdu(l2cap_test_packet_1)); 81 test_packet.push_back(L2capSdu(l2cap_test_packet_2)); 82 test_packet.push_back(L2capSdu(l2cap_test_packet_3)); 83 test_packet.push_back(L2capSdu(l2cap_test_packet_4)); 84 test_packet.push_back(L2capSdu(l2cap_test_packet_5)); 85 test_packet.push_back(L2capSdu(l2cap_test_packet_6)); 86 test_packet.push_back(L2capSdu(l2cap_test_packet_7)); 87 test_packet.push_back(L2capSdu(l2cap_test_packet_8)); 88 test_packet.push_back(L2capSdu(l2cap_test_packet_9)); 89 90 test_1 = L2capPacket::assemble(test_packet); 91 ASSERT_NE(test_1, nullptr); 92 93 assembled_payload = test_1->get_l2cap_payload(); 94 compare_packets(complete_l2cap_packet, assembled_payload); 95 96 assembled_payload.clear(); 97 test_packet.clear(); 98} 99 100TEST_F(L2capTest, assembleOutofOrderPackets) { 101 vector<L2capSdu> test_packet; 102 103 // Test 2: Pass out of order packets. 104 test_packet.push_back(L2capSdu(good_sdu[1])); 105 test_packet.push_back(L2capSdu(good_sdu[0])); 106 test_packet.push_back(L2capSdu(good_sdu[2])); 107 108 unique_ptr<L2capPacket> test_2 = L2capPacket::assemble(test_packet); 109 EXPECT_EQ(test_2, nullptr); 110 111 test_packet.clear(); 112 113 test_packet.push_back(L2capSdu(l2cap_test_packet_1)); 114 test_packet.push_back(L2capSdu(l2cap_test_packet_3)); 115 test_packet.push_back(L2capSdu(l2cap_test_packet_2)); 116 test_packet.push_back(L2capSdu(l2cap_test_packet_6)); 117 test_packet.push_back(L2capSdu(l2cap_test_packet_5)); 118 test_packet.push_back(L2capSdu(l2cap_test_packet_4)); 119 test_packet.push_back(L2capSdu(l2cap_test_packet_8)); 120 test_packet.push_back(L2capSdu(l2cap_test_packet_7)); 121 test_packet.push_back(L2capSdu(l2cap_test_packet_9)); 122 123 test_2 = L2capPacket::assemble(test_packet); 124 EXPECT_EQ(test_2, nullptr); 125 126 test_packet.clear(); 127} 128 129TEST_F(L2capTest, assembleBadControlBytes) { 130 vector<L2capSdu> test_packet; 131 132 // Test 3: Pass packets missing the finished control bytes. 133 test_packet.push_back(L2capSdu(good_sdu[0])); 134 test_packet.push_back(L2capSdu(good_sdu[1])); 135 136 unique_ptr<L2capPacket> test_3 = L2capPacket::assemble(test_packet); 137 EXPECT_EQ(test_3, nullptr); 138 139 test_packet.clear(); 140 141 test_packet.push_back(L2capSdu(l2cap_test_packet_1)); 142 test_packet.push_back(L2capSdu(l2cap_test_packet_2)); 143 test_packet.push_back(L2capSdu(l2cap_test_packet_3)); 144 test_packet.push_back(L2capSdu(l2cap_test_packet_4)); 145 test_packet.push_back(L2capSdu(l2cap_test_packet_5)); 146 test_packet.push_back(L2capSdu(l2cap_test_packet_6)); 147 test_packet.push_back(L2capSdu(l2cap_test_packet_7)); 148 test_packet.push_back(L2capSdu(l2cap_test_packet_8)); 149 150 test_3 = L2capPacket::assemble(test_packet); 151 EXPECT_EQ(test_3, nullptr); 152 153 test_packet.clear(); 154} 155 156TEST_F(L2capTest, assembleBadFCS) { 157 vector<L2capSdu> test_packet; 158 159 // Test 4: Pass packets with incorrect frame check sequences. 160 test_packet.push_back(L2capSdu(good_sdu[0])); 161 good_sdu[1][good_sdu[1].size() - 1]++; 162 test_packet.push_back(L2capSdu(good_sdu[1])); 163 good_sdu[1][good_sdu[1].size() - 1]--; 164 test_packet.push_back(L2capSdu(good_sdu[2])); 165 166 unique_ptr<L2capPacket> test_4 = L2capPacket::assemble(test_packet); 167 EXPECT_EQ(test_4, nullptr); 168 169 test_packet.clear(); 170 171 test_packet.push_back(L2capSdu(l2cap_test_packet_1)); 172 test_packet.push_back(L2capSdu(l2cap_test_packet_2)); 173 test_packet.push_back(L2capSdu(l2cap_test_packet_3)); 174 test_packet.push_back(L2capSdu(l2cap_test_packet_4)); 175 l2cap_test_packet_5[l2cap_test_packet_5.size() - 1]++; 176 test_packet.push_back(L2capSdu(l2cap_test_packet_5)); 177 l2cap_test_packet_5[l2cap_test_packet_5.size() - 1]--; 178 test_packet.push_back(L2capSdu(l2cap_test_packet_6)); 179 test_packet.push_back(L2capSdu(l2cap_test_packet_7)); 180 test_packet.push_back(L2capSdu(l2cap_test_packet_8)); 181 test_packet.push_back(L2capSdu(l2cap_test_packet_9)); 182 183 test_4 = L2capPacket::assemble(test_packet); 184 EXPECT_EQ(test_4, nullptr); 185 186 test_packet.clear(); 187} 188 189TEST_F(L2capTest, assembleEmptyPayload) { 190 vector<L2capSdu> test_packet; 191 vector<uint8_t> assembled_payload; 192 193 // Test 5: Pass a packet with an empty payload. 194 test_packet.push_back(L2capSdu(empty_sdu_payload[0])); 195 test_packet.push_back(L2capSdu(empty_sdu_payload[1])); 196 197 unique_ptr<L2capPacket> test_5 = L2capPacket::assemble(test_packet); 198 ASSERT_NE(test_5, nullptr); 199 200 EXPECT_EQ(test_5->get_l2cap_cid(), 0x0047); 201 assembled_payload = test_5->get_l2cap_payload(); 202 compare_packets(empty_l2cap_payload, assembled_payload); 203 204 assembled_payload.clear(); 205 test_packet.clear(); 206} 207 208TEST_F(L2capTest, assembleAllStartingControlError) { 209 vector<L2capSdu> test_packet; 210 211 // Test 6: Pass a SDU with all the control bytes set to as the starting bytes. 212 test_packet.push_back(L2capSdu(all_first_packet[0])); 213 test_packet.push_back(L2capSdu(all_first_packet[1])); 214 test_packet.push_back(L2capSdu(all_first_packet[2])); 215 216 unique_ptr<L2capPacket> test_6 = L2capPacket::assemble(test_packet); 217 EXPECT_EQ(test_6, nullptr); 218 219 test_packet.clear(); 220} 221 222TEST_F(L2capTest, assembleBadCID) { 223 vector<L2capSdu> test_packet; 224 225 // Test 7: Pass SDUs with mixed channel ids. 226 test_packet.push_back(L2capSdu(good_sdu[0])); 227 good_sdu[1][2]++; 228 test_packet.push_back(update_fcs(good_sdu[1])); 229 good_sdu[1][2]--; 230 test_packet.push_back(L2capSdu(good_sdu[2])); 231 232 unique_ptr<L2capPacket> test_7 = L2capPacket::assemble(test_packet); 233 EXPECT_EQ(test_7, nullptr); 234 235 test_packet.clear(); 236 237 test_packet.push_back(L2capSdu(l2cap_test_packet_1)); 238 l2cap_test_packet_2[2]++; 239 test_packet.push_back(update_fcs(l2cap_test_packet_2)); 240 l2cap_test_packet_2[2]--; 241 test_packet.push_back(L2capSdu(l2cap_test_packet_3)); 242 test_packet.push_back(L2capSdu(l2cap_test_packet_4)); 243 l2cap_test_packet_5[2]++; 244 test_packet.push_back(update_fcs(l2cap_test_packet_5)); 245 l2cap_test_packet_5[2]--; 246 test_packet.push_back(L2capSdu(l2cap_test_packet_6)); 247 test_packet.push_back(L2capSdu(l2cap_test_packet_7)); 248 l2cap_test_packet_8[2]--; 249 test_packet.push_back(update_fcs(l2cap_test_packet_8)); 250 l2cap_test_packet_8[2]++; 251 test_packet.push_back(L2capSdu(l2cap_test_packet_9)); 252 253 test_7 = L2capPacket::assemble(test_packet); 254 EXPECT_EQ(test_7, nullptr); 255 256 test_packet.clear(); 257} 258 259TEST_F(L2capTest, assembleUnsegmentedSDU) { 260 vector<L2capSdu> test_packet; 261 262 // Test 8: Pass a complete l2cap packet. 263 test_packet.push_back(L2capSdu(one_sdu[0])); 264 265 unique_ptr<L2capPacket> test_8 = L2capPacket::assemble(test_packet); 266 EXPECT_NE(test_8, nullptr); 267 268 test_packet.clear(); 269} 270 271TEST_F(L2capTest, assembleBadTxSeq) { 272 vector<L2capSdu> test_packet; 273 274 // Test 9: Pass SDUs with incorrect TxSeq. 275 good_sdu[0][4] += 4; 276 test_packet.push_back(update_fcs(good_sdu[0])); 277 good_sdu[0][4] -= 4; 278 test_packet.push_back(L2capSdu(good_sdu[1])); 279 test_packet.push_back(L2capSdu(good_sdu[2])); 280 281 unique_ptr<L2capPacket> test_9 = L2capPacket::assemble(test_packet); 282 EXPECT_EQ(test_9, nullptr); 283 284 test_packet.clear(); 285} 286 287TEST_F(L2capTest, assembleBadTotalSDULength) { 288 vector<L2capSdu> test_packet; 289 290 // Test 10: Pass SDUs with an incorrect total SDU length 291 good_sdu[0][7]++; 292 test_packet.push_back(update_fcs(good_sdu[0])); 293 good_sdu[0][7]--; 294 test_packet.push_back(L2capSdu(good_sdu[1])); 295 test_packet.push_back(L2capSdu(good_sdu[2])); 296 297 unique_ptr<L2capPacket> test_10 = L2capPacket::assemble(test_packet); 298 EXPECT_EQ(test_10, nullptr); 299 300 test_packet.clear(); 301 302 l2cap_test_packet_1[6]++; 303 test_packet.push_back(update_fcs(l2cap_test_packet_1)); 304 l2cap_test_packet_1[6]--; 305 test_packet.push_back(L2capSdu(l2cap_test_packet_2)); 306 test_packet.push_back(L2capSdu(l2cap_test_packet_3)); 307 test_packet.push_back(L2capSdu(l2cap_test_packet_4)); 308 test_packet.push_back(L2capSdu(l2cap_test_packet_5)); 309 test_packet.push_back(L2capSdu(l2cap_test_packet_6)); 310 test_packet.push_back(L2capSdu(l2cap_test_packet_7)); 311 test_packet.push_back(L2capSdu(l2cap_test_packet_8)); 312 test_packet.push_back(L2capSdu(l2cap_test_packet_9)); 313 314 test_10 = L2capPacket::assemble(test_packet); 315 316 EXPECT_EQ(test_10, nullptr); 317 318 test_packet.clear(); 319} 320 321// Begin Fragment Test1 322TEST_F(L2capTest, fragmentSmallSegmentTest) { 323 std::vector<L2capSdu> sdu; 324 std::unique_ptr<L2capPacket> l2cap_expected; 325 std::unique_ptr<L2capPacket> l2cap_received; 326 327 sdu.push_back(L2capSdu(good_sdu[0])); 328 sdu.push_back(L2capSdu(good_sdu[1])); 329 sdu.push_back(L2capSdu(good_sdu[2])); 330 331 l2cap_expected = L2capPacket::assemble(sdu); 332 333 sdu.clear(); 334 335 // Test1: Small segments 336 sdu = l2cap_expected->fragment(16, 0x02, 0x41); 337 338 l2cap_received = L2capPacket::assemble(sdu); 339 ASSERT_NE(l2cap_received, nullptr) 340 << "packet reassembly failed after fragment" << std::endl 341 << "Test1: Small Segment request" << std::endl 342 << "sdu used: good_sdu" << std::endl 343 << "function call: fragment(16, 0x02, 0x41)" << std::endl; 344 345 std::vector<uint8_t> small_seg_expected = l2cap_expected->get_l2cap_payload(); 346 std::vector<uint8_t> small_seg_received = l2cap_received->get_l2cap_payload(); 347 348 compare_fragmented_packets(small_seg_expected, small_seg_received); 349 350 sdu.clear(); 351 l2cap_expected.reset(nullptr); 352 l2cap_received.reset(nullptr); 353} // End Fragment Test1 354 355// Begin Fragment Test2 356TEST_F(L2capTest, fragmentLargeSegmentTest) { 357 std::vector<L2capSdu> sdu; 358 std::unique_ptr<L2capPacket> l2cap_expected; 359 std::unique_ptr<L2capPacket> l2cap_received; 360 361 sdu.push_back(L2capSdu(l2cap_test_packet_1)); 362 sdu.push_back(L2capSdu(l2cap_test_packet_2)); 363 sdu.push_back(L2capSdu(l2cap_test_packet_3)); 364 sdu.push_back(L2capSdu(l2cap_test_packet_4)); 365 sdu.push_back(L2capSdu(l2cap_test_packet_5)); 366 sdu.push_back(L2capSdu(l2cap_test_packet_6)); 367 sdu.push_back(L2capSdu(l2cap_test_packet_7)); 368 sdu.push_back(L2capSdu(l2cap_test_packet_8)); 369 sdu.push_back(L2capSdu(l2cap_test_packet_9)); 370 371 l2cap_expected = L2capPacket::assemble(sdu); 372 373 sdu.clear(); 374 375 // Test2: Large Segments 376 sdu = l2cap_expected->fragment(1024, 0x02, 0x41); 377 378 l2cap_received = L2capPacket::assemble(sdu); 379 ASSERT_NE(l2cap_received, nullptr) 380 << "packet reassembly failed after fragment" << std::endl 381 << "Test2: Large Segment request" << std::endl 382 << "sdu used: l2cap_test_packet[1-9]" << std::endl 383 << "function call: fragment(1024, 0x02, 0x41)" << std::endl; 384 385 std::vector<uint8_t> large_seg_expected = l2cap_expected->get_l2cap_payload(); 386 std::vector<uint8_t> large_seg_received = l2cap_received->get_l2cap_payload(); 387 388 compare_fragmented_packets(large_seg_expected, large_seg_received); 389 390 sdu.clear(); 391 l2cap_expected.reset(nullptr); 392 l2cap_received.reset(nullptr); 393} // End Fragment Test2 394 395// Begin Fragment Test3 396TEST_F(L2capTest, fragmentTxSeqTest) { 397 std::vector<L2capSdu> sdu; 398 std::unique_ptr<L2capPacket> l2cap_expected; 399 std::unique_ptr<L2capPacket> l2cap_received; 400 401 sdu.push_back(L2capSdu(good_sdu[0])); 402 sdu.push_back(L2capSdu(good_sdu[1])); 403 sdu.push_back(L2capSdu(good_sdu[2])); 404 405 l2cap_expected = L2capPacket::assemble(sdu); 406 407 sdu.clear(); 408 409 // Test3: Non-zero starting TxSeq 410 sdu = l2cap_expected->fragment(24, 0x08, 0x41); 411 412 l2cap_received = L2capPacket::assemble(sdu); 413 ASSERT_NE(l2cap_received, nullptr) 414 << "packet reassembly failed after fragment" << std::endl 415 << "Test3: Non-zero starting TxSeq" << std::endl 416 << "sdu used: good_sdu" << std::endl 417 << "function call: fragment(24, 0x08, 0x41)" << std::endl; 418 419 std::vector<uint8_t> txseq_expected = l2cap_expected->get_l2cap_payload(); 420 std::vector<uint8_t> txseq_received = l2cap_received->get_l2cap_payload(); 421 422 compare_fragmented_packets(txseq_expected, txseq_received); 423 424 sdu.clear(); 425 l2cap_expected.reset(nullptr); 426 l2cap_received.reset(nullptr); 427} // End Fragment Test3 428 429// Begin Fragment Test4 430TEST_F(L2capTest, fragmentPayloadTest) { 431 std::vector<L2capSdu> sdu; 432 std::unique_ptr<L2capPacket> l2cap_expected; 433 std::unique_ptr<L2capPacket> l2cap_received; 434 435 sdu.push_back(L2capSdu(empty_sdu_payload[0])); 436 sdu.push_back(L2capSdu(empty_sdu_payload[1])); 437 438 l2cap_expected = L2capPacket::assemble(sdu); 439 440 sdu.clear(); 441 442 // Test4: Packet with no payload 443 sdu = l2cap_expected->fragment(16, 0x02, 0x41); 444 445 l2cap_received = L2capPacket::assemble(sdu); 446 ASSERT_NE(l2cap_received, nullptr) 447 << "packet reassembly failed after fragment" << std::endl 448 << "Test4: Packet with no payload" << std::endl 449 << "sdu used: empty_sdu_payload" << std::endl 450 << "function call: fragment(16, 0x02, 0x41)" << std::endl; 451 452 std::vector<uint8_t> empty_expected = l2cap_expected->get_l2cap_payload(); 453 std::vector<uint8_t> empty_received = l2cap_received->get_l2cap_payload(); 454 455 compare_fragmented_packets(empty_expected, empty_received); 456 457 sdu.clear(); 458 l2cap_expected.reset(nullptr); 459 l2cap_received.reset(nullptr); 460} // End Fragment Test4 461 462// Begin Fragment Test5 463TEST_F(L2capTest, fragmentSegmentSizeTest) { 464 std::vector<L2capSdu> sdu; 465 std::unique_ptr<L2capPacket> l2cap_expected; 466 std::unique_ptr<L2capPacket> l2cap_received; 467 468 sdu.push_back(L2capSdu(good_sdu[0])); 469 sdu.push_back(L2capSdu(good_sdu[1])); 470 sdu.push_back(L2capSdu(good_sdu[2])); 471 472 l2cap_expected = L2capPacket::assemble(sdu); 473 474 sdu.clear(); 475 476 // Test5: Larger segment size than packet size 477 sdu = l2cap_expected->fragment(256, 0x02, 0x41); 478 479 l2cap_received = L2capPacket::assemble(sdu); 480 ASSERT_NE(l2cap_received, nullptr) 481 << "packet reassembly failed after fragment" << std::endl 482 << "Test5: Segment size > Payload" << std::endl 483 << "sdu used: good_sdu" << std::endl 484 << "function call: fragment(256, 0x02, 0x41)" << std::endl; 485 486 std::vector<uint8_t> big_segs_exp = l2cap_expected->get_l2cap_payload(); 487 std::vector<uint8_t> big_segs_rcvd = l2cap_received->get_l2cap_payload(); 488 489 compare_fragmented_packets(big_segs_exp, big_segs_rcvd); 490 491 sdu.clear(); 492 l2cap_expected.reset(nullptr); 493 l2cap_received.reset(nullptr); 494} // End Fragment Test5 495 496// Begin Fragment Test6 497TEST_F(L2capTest, fragmentSegmentSizeTest2) { 498 std::vector<L2capSdu> sdu; 499 std::unique_ptr<L2capPacket> l2cap_expected; 500 std::unique_ptr<L2capPacket> l2cap_received; 501 502 sdu.push_back(L2capSdu(l2cap_test_packet_1)); 503 sdu.push_back(L2capSdu(l2cap_test_packet_2)); 504 sdu.push_back(L2capSdu(l2cap_test_packet_3)); 505 sdu.push_back(L2capSdu(l2cap_test_packet_4)); 506 sdu.push_back(L2capSdu(l2cap_test_packet_5)); 507 sdu.push_back(L2capSdu(l2cap_test_packet_6)); 508 sdu.push_back(L2capSdu(l2cap_test_packet_7)); 509 sdu.push_back(L2capSdu(l2cap_test_packet_8)); 510 sdu.push_back(L2capSdu(l2cap_test_packet_9)); 511 512 l2cap_expected = L2capPacket::assemble(sdu); 513 sdu.clear(); 514 515 // Test6: Small segment size on large packet. 516 sdu = l2cap_expected->fragment(512, 0x02, 0x41); 517 518 l2cap_received = L2capPacket::assemble(sdu); 519 ASSERT_NE(l2cap_received, nullptr) 520 << "packet reassembly failed after fragment" << std::endl 521 << "Test6: Small Segment request on large packet" << std::endl 522 << "sdu used: l2cap_test_packet_[1-9]" << std::endl 523 << "function call: fragment(64, 0x02, 0x41)" << std::endl; 524 525 std::vector<uint8_t> small_segs_exp = l2cap_expected->get_l2cap_payload(); 526 std::vector<uint8_t> small_segs_rcvd = l2cap_received->get_l2cap_payload(); 527 528 compare_fragmented_packets(small_segs_exp, small_segs_rcvd); 529 530 sdu.clear(); 531 l2cap_expected.reset(nullptr); 532 l2cap_received.reset(nullptr); 533} // End Fragment Test6 534 535} // namespace test_vendor_lib 536