| /* | |
| * Copyright (c) 2021 The WebRTC project authors. All Rights Reserved. | |
| * | |
| * Use of this source code is governed by a BSD-style license | |
| * that can be found in the LICENSE file in the root of the source | |
| * tree. An additional intellectual property rights grant can be found | |
| * in the file PATENTS. All contributing project authors may | |
| * be found in the AUTHORS file in the root of the source tree. | |
| */ | |
| #include "net/dcsctp/packet/sctp_packet.h" | |
| #include <cstdint> | |
| #include <utility> | |
| #include <vector> | |
| #include "api/array_view.h" | |
| #include "net/dcsctp/common/internal_types.h" | |
| #include "net/dcsctp/common/math.h" | |
| #include "net/dcsctp/packet/chunk/abort_chunk.h" | |
| #include "net/dcsctp/packet/chunk/cookie_ack_chunk.h" | |
| #include "net/dcsctp/packet/chunk/data_chunk.h" | |
| #include "net/dcsctp/packet/chunk/init_chunk.h" | |
| #include "net/dcsctp/packet/chunk/sack_chunk.h" | |
| #include "net/dcsctp/packet/error_cause/error_cause.h" | |
| #include "net/dcsctp/packet/error_cause/user_initiated_abort_cause.h" | |
| #include "net/dcsctp/packet/parameter/parameter.h" | |
| #include "net/dcsctp/packet/tlv_trait.h" | |
| #include "net/dcsctp/public/dcsctp_options.h" | |
| #include "net/dcsctp/testing/testing_macros.h" | |
| #include "rtc_base/gunit.h" | |
| #include "test/gmock.h" | |
| namespace dcsctp { | |
| namespace { | |
| using ::testing::ElementsAre; | |
| using ::testing::SizeIs; | |
| constexpr VerificationTag kVerificationTag = VerificationTag(0x12345678); | |
| constexpr DcSctpOptions kVerifyChecksumOptions = | |
| DcSctpOptions{.disable_checksum_verification = false, | |
| .zero_checksum_alternate_error_detection_method = | |
| ZeroChecksumAlternateErrorDetectionMethod::None()}; | |
| TEST(SctpPacketTest, DeserializeSimplePacketFromCapture) { | |
| /* | |
| Stream Control Transmission Protocol, Src Port: 5000 (5000), Dst Port: 5000 | |
| (5000) Source port: 5000 Destination port: 5000 Verification tag: 0x00000000 | |
| [Association index: 1] | |
| Checksum: 0xaa019d33 [unverified] | |
| [Checksum Status: Unverified] | |
| INIT chunk (Outbound streams: 1000, inbound streams: 1000) | |
| Chunk type: INIT (1) | |
| Chunk flags: 0x00 | |
| Chunk length: 90 | |
| Initiate tag: 0x0eddca08 | |
| Advertised receiver window credit (a_rwnd): 131072 | |
| Number of outbound streams: 1000 | |
| Number of inbound streams: 1000 | |
| Initial TSN: 1426601527 | |
| ECN parameter | |
| Parameter type: ECN (0x8000) | |
| Parameter length: 4 | |
| Forward TSN supported parameter | |
| Parameter type: Forward TSN supported (0xc000) | |
| Parameter length: 4 | |
| Supported Extensions parameter (Supported types: FORWARD_TSN, AUTH, | |
| ASCONF, ASCONF_ACK, RE_CONFIG) Parameter type: Supported Extensions | |
| (0x8008) Parameter length: 9 Supported chunk type: FORWARD_TSN (192) Supported | |
| chunk type: AUTH (15) Supported chunk type: ASCONF (193) Supported chunk type: | |
| ASCONF_ACK (128) Supported chunk type: RE_CONFIG (130) Parameter padding: | |
| 000000 Random parameter Parameter type: Random (0x8002) Parameter length: 36 | |
| Random number: c5a86155090e6f420050634cc8d6b908dfd53e17c99cb143… | |
| Requested HMAC Algorithm parameter (Supported HMACs: SHA-1) | |
| Parameter type: Requested HMAC Algorithm (0x8004) | |
| Parameter length: 6 | |
| HMAC identifier: SHA-1 (1) | |
| Parameter padding: 0000 | |
| Authenticated Chunk list parameter (Chunk types to be authenticated: | |
| ASCONF_ACK, ASCONF) Parameter type: Authenticated Chunk list | |
| (0x8003) Parameter length: 6 Chunk type: ASCONF_ACK (128) Chunk type: ASCONF | |
| (193) Chunk padding: 0000 | |
| */ | |
| uint8_t data[] = { | |
| 0x13, 0x88, 0x13, 0x88, 0x00, 0x00, 0x00, 0x00, 0xaa, 0x01, 0x9d, 0x33, | |
| 0x01, 0x00, 0x00, 0x5a, 0x0e, 0xdd, 0xca, 0x08, 0x00, 0x02, 0x00, 0x00, | |
| 0x03, 0xe8, 0x03, 0xe8, 0x55, 0x08, 0x36, 0x37, 0x80, 0x00, 0x00, 0x04, | |
| 0xc0, 0x00, 0x00, 0x04, 0x80, 0x08, 0x00, 0x09, 0xc0, 0x0f, 0xc1, 0x80, | |
| 0x82, 0x00, 0x00, 0x00, 0x80, 0x02, 0x00, 0x24, 0xc5, 0xa8, 0x61, 0x55, | |
| 0x09, 0x0e, 0x6f, 0x42, 0x00, 0x50, 0x63, 0x4c, 0xc8, 0xd6, 0xb9, 0x08, | |
| 0xdf, 0xd5, 0x3e, 0x17, 0xc9, 0x9c, 0xb1, 0x43, 0x28, 0x4e, 0xaf, 0x64, | |
| 0x68, 0x2a, 0xc2, 0x97, 0x80, 0x04, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, | |
| 0x80, 0x03, 0x00, 0x06, 0x80, 0xc1, 0x00, 0x00}; | |
| ASSERT_HAS_VALUE_AND_ASSIGN(SctpPacket packet, | |
| SctpPacket::Parse(data, kVerifyChecksumOptions)); | |
| EXPECT_EQ(packet.common_header().source_port, 5000); | |
| EXPECT_EQ(packet.common_header().destination_port, 5000); | |
| EXPECT_EQ(packet.common_header().verification_tag, VerificationTag(0)); | |
| EXPECT_EQ(packet.common_header().checksum, 0xaa019d33); | |
| EXPECT_THAT(packet.descriptors(), SizeIs(1)); | |
| EXPECT_EQ(packet.descriptors()[0].type, InitChunk::kType); | |
| ASSERT_HAS_VALUE_AND_ASSIGN(InitChunk init, | |
| InitChunk::Parse(packet.descriptors()[0].data)); | |
| EXPECT_EQ(init.initial_tsn(), TSN(1426601527)); | |
| } | |
| TEST(SctpPacketTest, DeserializePacketWithTwoChunks) { | |
| /* | |
| Stream Control Transmission Protocol, Src Port: 1234 (1234), | |
| Dst Port: 4321 (4321) | |
| Source port: 1234 | |
| Destination port: 4321 | |
| Verification tag: 0x697e3a4e | |
| [Association index: 3] | |
| Checksum: 0xc06e8b36 [unverified] | |
| [Checksum Status: Unverified] | |
| COOKIE_ACK chunk | |
| Chunk type: COOKIE_ACK (11) | |
| Chunk flags: 0x00 | |
| Chunk length: 4 | |
| SACK chunk (Cumulative TSN: 2930332242, a_rwnd: 131072, | |
| gaps: 0, duplicate TSNs: 0) | |
| Chunk type: SACK (3) | |
| Chunk flags: 0x00 | |
| Chunk length: 16 | |
| Cumulative TSN ACK: 2930332242 | |
| Advertised receiver window credit (a_rwnd): 131072 | |
| Number of gap acknowledgement blocks: 0 | |
| Number of duplicated TSNs: 0 | |
| */ | |
| uint8_t data[] = {0x04, 0xd2, 0x10, 0xe1, 0x69, 0x7e, 0x3a, 0x4e, | |
| 0xc0, 0x6e, 0x8b, 0x36, 0x0b, 0x00, 0x00, 0x04, | |
| 0x03, 0x00, 0x00, 0x10, 0xae, 0xa9, 0x52, 0x52, | |
| 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; | |
| ASSERT_HAS_VALUE_AND_ASSIGN(SctpPacket packet, | |
| SctpPacket::Parse(data, kVerifyChecksumOptions)); | |
| EXPECT_EQ(packet.common_header().source_port, 1234); | |
| EXPECT_EQ(packet.common_header().destination_port, 4321); | |
| EXPECT_EQ(packet.common_header().verification_tag, | |
| VerificationTag(0x697e3a4eu)); | |
| EXPECT_EQ(packet.common_header().checksum, 0xc06e8b36u); | |
| EXPECT_THAT(packet.descriptors(), SizeIs(2)); | |
| EXPECT_EQ(packet.descriptors()[0].type, CookieAckChunk::kType); | |
| EXPECT_EQ(packet.descriptors()[1].type, SackChunk::kType); | |
| ASSERT_HAS_VALUE_AND_ASSIGN( | |
| CookieAckChunk cookie_ack, | |
| CookieAckChunk::Parse(packet.descriptors()[0].data)); | |
| ASSERT_HAS_VALUE_AND_ASSIGN(SackChunk sack, | |
| SackChunk::Parse(packet.descriptors()[1].data)); | |
| } | |
| TEST(SctpPacketTest, DeserializePacketWithWrongChecksum) { | |
| /* | |
| Stream Control Transmission Protocol, Src Port: 5000 (5000), | |
| Dst Port: 5000 (5000) | |
| Source port: 5000 | |
| Destination port: 5000 | |
| Verification tag: 0x0eddca08 | |
| [Association index: 1] | |
| Checksum: 0x2a81f531 [unverified] | |
| [Checksum Status: Unverified] | |
| SACK chunk (Cumulative TSN: 1426601536, a_rwnd: 131072, | |
| gaps: 0, duplicate TSNs: 0) | |
| Chunk type: SACK (3) | |
| Chunk flags: 0x00 | |
| Chunk length: 16 | |
| Cumulative TSN ACK: 1426601536 | |
| Advertised receiver window credit (a_rwnd): 131072 | |
| Number of gap acknowledgement blocks: 0 | |
| Number of duplicated TSNs: 0 | |
| */ | |
| uint8_t data[] = {0x13, 0x88, 0x13, 0x88, 0x0e, 0xdd, 0xca, 0x08, 0x2a, 0x81, | |
| 0xf5, 0x31, 0x03, 0x00, 0x00, 0x10, 0x55, 0x08, 0x36, 0x40, | |
| 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; | |
| EXPECT_FALSE(SctpPacket::Parse(data, kVerifyChecksumOptions).has_value()); | |
| } | |
| TEST(SctpPacketTest, DeserializePacketDontValidateChecksum) { | |
| /* | |
| Stream Control Transmission Protocol, Src Port: 5000 (5000), | |
| Dst Port: 5000 (5000) | |
| Source port: 5000 | |
| Destination port: 5000 | |
| Verification tag: 0x0eddca08 | |
| [Association index: 1] | |
| Checksum: 0x2a81f531 [unverified] | |
| [Checksum Status: Unverified] | |
| SACK chunk (Cumulative TSN: 1426601536, a_rwnd: 131072, | |
| gaps: 0, duplicate TSNs: 0) | |
| Chunk type: SACK (3) | |
| Chunk flags: 0x00 | |
| Chunk length: 16 | |
| Cumulative TSN ACK: 1426601536 | |
| Advertised receiver window credit (a_rwnd): 131072 | |
| Number of gap acknowledgement blocks: 0 | |
| Number of duplicated TSNs: 0 | |
| */ | |
| uint8_t data[] = {0x13, 0x88, 0x13, 0x88, 0x0e, 0xdd, 0xca, 0x08, 0x2a, 0x81, | |
| 0xf5, 0x31, 0x03, 0x00, 0x00, 0x10, 0x55, 0x08, 0x36, 0x40, | |
| 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; | |
| ASSERT_HAS_VALUE_AND_ASSIGN( | |
| SctpPacket packet, | |
| SctpPacket::Parse( | |
| data, {.disable_checksum_verification = true, | |
| .zero_checksum_alternate_error_detection_method = | |
| ZeroChecksumAlternateErrorDetectionMethod::None()})); | |
| EXPECT_EQ(packet.common_header().source_port, 5000); | |
| EXPECT_EQ(packet.common_header().destination_port, 5000); | |
| EXPECT_EQ(packet.common_header().verification_tag, | |
| VerificationTag(0x0eddca08u)); | |
| EXPECT_EQ(packet.common_header().checksum, 0x2a81f531u); | |
| } | |
| TEST(SctpPacketTest, SerializeAndDeserializeSingleChunk) { | |
| SctpPacket::Builder b(kVerificationTag, {}); | |
| InitChunk init(/*initiate_tag=*/VerificationTag(123), /*a_rwnd=*/456, | |
| /*nbr_outbound_streams=*/65535, | |
| /*nbr_inbound_streams=*/65534, /*initial_tsn=*/TSN(789), | |
| /*parameters=*/Parameters()); | |
| b.Add(init); | |
| std::vector<uint8_t> serialized = b.Build(); | |
| ASSERT_HAS_VALUE_AND_ASSIGN( | |
| SctpPacket packet, SctpPacket::Parse(serialized, kVerifyChecksumOptions)); | |
| EXPECT_EQ(packet.common_header().verification_tag, kVerificationTag); | |
| ASSERT_THAT(packet.descriptors(), SizeIs(1)); | |
| EXPECT_EQ(packet.descriptors()[0].type, InitChunk::kType); | |
| ASSERT_HAS_VALUE_AND_ASSIGN(InitChunk deserialized, | |
| InitChunk::Parse(packet.descriptors()[0].data)); | |
| EXPECT_EQ(deserialized.initiate_tag(), VerificationTag(123)); | |
| EXPECT_EQ(deserialized.a_rwnd(), 456u); | |
| EXPECT_EQ(deserialized.nbr_outbound_streams(), 65535u); | |
| EXPECT_EQ(deserialized.nbr_inbound_streams(), 65534u); | |
| EXPECT_EQ(deserialized.initial_tsn(), TSN(789)); | |
| } | |
| TEST(SctpPacketTest, SerializeAndDeserializeThreeChunks) { | |
| SctpPacket::Builder b(kVerificationTag, {}); | |
| b.Add(SackChunk(/*cumulative_tsn_ack=*/TSN(999), /*a_rwnd=*/456, | |
| {SackChunk::GapAckBlock(2, 3)}, | |
| /*duplicate_tsns=*/{TSN(1), TSN(2), TSN(3)})); | |
| b.Add(DataChunk(TSN(123), StreamID(456), SSN(789), PPID(9090), | |
| /*payload=*/{1, 2, 3, 4, 5}, | |
| /*options=*/{})); | |
| b.Add(DataChunk(TSN(124), StreamID(654), SSN(987), PPID(909), | |
| /*payload=*/{5, 4, 3, 3, 1}, | |
| /*options=*/{})); | |
| std::vector<uint8_t> serialized = b.Build(); | |
| ASSERT_HAS_VALUE_AND_ASSIGN( | |
| SctpPacket packet, SctpPacket::Parse(serialized, kVerifyChecksumOptions)); | |
| EXPECT_EQ(packet.common_header().verification_tag, kVerificationTag); | |
| ASSERT_THAT(packet.descriptors(), SizeIs(3)); | |
| EXPECT_EQ(packet.descriptors()[0].type, SackChunk::kType); | |
| EXPECT_EQ(packet.descriptors()[1].type, DataChunk::kType); | |
| EXPECT_EQ(packet.descriptors()[2].type, DataChunk::kType); | |
| ASSERT_HAS_VALUE_AND_ASSIGN(SackChunk sack, | |
| SackChunk::Parse(packet.descriptors()[0].data)); | |
| EXPECT_EQ(sack.cumulative_tsn_ack(), TSN(999)); | |
| EXPECT_EQ(sack.a_rwnd(), 456u); | |
| ASSERT_HAS_VALUE_AND_ASSIGN(DataChunk data1, | |
| DataChunk::Parse(packet.descriptors()[1].data)); | |
| EXPECT_EQ(data1.tsn(), TSN(123)); | |
| ASSERT_HAS_VALUE_AND_ASSIGN(DataChunk data2, | |
| DataChunk::Parse(packet.descriptors()[2].data)); | |
| EXPECT_EQ(data2.tsn(), TSN(124)); | |
| } | |
| TEST(SctpPacketTest, ParseAbortWithEmptyCause) { | |
| SctpPacket::Builder b(kVerificationTag, {}); | |
| b.Add(AbortChunk( | |
| /*filled_in_verification_tag=*/true, | |
| Parameters::Builder().Add(UserInitiatedAbortCause("")).Build())); | |
| ASSERT_HAS_VALUE_AND_ASSIGN( | |
| SctpPacket packet, SctpPacket::Parse(b.Build(), kVerifyChecksumOptions)); | |
| EXPECT_EQ(packet.common_header().verification_tag, kVerificationTag); | |
| ASSERT_THAT(packet.descriptors(), SizeIs(1)); | |
| EXPECT_EQ(packet.descriptors()[0].type, AbortChunk::kType); | |
| ASSERT_HAS_VALUE_AND_ASSIGN(AbortChunk abort, | |
| AbortChunk::Parse(packet.descriptors()[0].data)); | |
| ASSERT_HAS_VALUE_AND_ASSIGN( | |
| UserInitiatedAbortCause cause, | |
| abort.error_causes().get<UserInitiatedAbortCause>()); | |
| EXPECT_EQ(cause.upper_layer_abort_reason(), ""); | |
| } | |
| TEST(SctpPacketTest, DetectPacketWithZeroSizeChunk) { | |
| uint8_t data[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0x0a, 0x0a, 0x0a, 0x5c, | |
| 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x00, 0x00, 0x00}; | |
| EXPECT_FALSE(SctpPacket::Parse(data, kVerifyChecksumOptions).has_value()); | |
| } | |
| TEST(SctpPacketTest, ReturnsCorrectSpaceAvailableToStayWithinMTU) { | |
| DcSctpOptions options; | |
| options.mtu = 1191; | |
| SctpPacket::Builder builder(VerificationTag(123), options); | |
| // Chunks will be padded to an even 4 bytes, so the maximum packet size should | |
| // be rounded down. | |
| const size_t kMaxPacketSize = RoundDownTo4(options.mtu); | |
| EXPECT_EQ(kMaxPacketSize, 1188u); | |
| const size_t kSctpHeaderSize = 12; | |
| EXPECT_EQ(builder.bytes_remaining(), kMaxPacketSize - kSctpHeaderSize); | |
| EXPECT_EQ(builder.bytes_remaining(), 1176u); | |
| // Add a smaller packet first. | |
| DataChunk::Options data_options; | |
| std::vector<uint8_t> payload1(183); | |
| builder.Add( | |
| DataChunk(TSN(1), StreamID(1), SSN(0), PPID(53), payload1, data_options)); | |
| size_t chunk1_size = RoundUpTo4(DataChunk::kHeaderSize + payload1.size()); | |
| EXPECT_EQ(builder.bytes_remaining(), | |
| kMaxPacketSize - kSctpHeaderSize - chunk1_size); | |
| EXPECT_EQ(builder.bytes_remaining(), 976u); // Hand-calculated. | |
| std::vector<uint8_t> payload2(957); | |
| builder.Add( | |
| DataChunk(TSN(1), StreamID(1), SSN(0), PPID(53), payload2, data_options)); | |
| size_t chunk2_size = RoundUpTo4(DataChunk::kHeaderSize + payload2.size()); | |
| EXPECT_EQ(builder.bytes_remaining(), | |
| kMaxPacketSize - kSctpHeaderSize - chunk1_size - chunk2_size); | |
| EXPECT_EQ(builder.bytes_remaining(), 0u); // Hand-calculated. | |
| } | |
| TEST(SctpPacketTest, AcceptsZeroSetZeroChecksum) { | |
| /* | |
| Stream Control Transmission Protocol, Src Port: 5000 (5000), | |
| Dst Port: 5000 (5000) | |
| Source port: 5000 | |
| Destination port: 5000 | |
| Verification tag: 0x0eddca08 | |
| [Association index: 1] | |
| Checksum: 0x00000000 [unverified] | |
| [Checksum Status: Unverified] | |
| SACK chunk (Cumulative TSN: 1426601536, a_rwnd: 131072, | |
| gaps: 0, duplicate TSNs: 0) | |
| Chunk type: SACK (3) | |
| Chunk flags: 0x00 | |
| Chunk length: 16 | |
| Cumulative TSN ACK: 1426601536 | |
| Advertised receiver window credit (a_rwnd): 131072 | |
| Number of gap acknowledgement blocks: 0 | |
| Number of duplicated TSNs: 0 | |
| */ | |
| uint8_t data[] = {0x13, 0x88, 0x13, 0x88, 0x0e, 0xdd, 0xca, 0x08, 0x00, 0x00, | |
| 0x00, 0x00, 0x03, 0x00, 0x00, 0x10, 0x55, 0x08, 0x36, 0x40, | |
| 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; | |
| ASSERT_HAS_VALUE_AND_ASSIGN( | |
| SctpPacket packet, | |
| SctpPacket::Parse( | |
| data, | |
| {.disable_checksum_verification = false, | |
| .zero_checksum_alternate_error_detection_method = | |
| ZeroChecksumAlternateErrorDetectionMethod::LowerLayerDtls()})); | |
| EXPECT_EQ(packet.common_header().source_port, 5000); | |
| EXPECT_EQ(packet.common_header().destination_port, 5000); | |
| EXPECT_EQ(packet.common_header().verification_tag, | |
| VerificationTag(0x0eddca08u)); | |
| EXPECT_EQ(packet.common_header().checksum, 0x00000000u); | |
| } | |
| TEST(SctpPacketTest, RejectsNonZeroIncorrectChecksumWhenZeroChecksumIsActive) { | |
| /* | |
| Stream Control Transmission Protocol, Src Port: 5000 (5000), | |
| Dst Port: 5000 (5000) | |
| Source port: 5000 | |
| Destination port: 5000 | |
| Verification tag: 0x0eddca08 | |
| [Association index: 1] | |
| Checksum: 0x00000001 [unverified] | |
| [Checksum Status: Unverified] | |
| SACK chunk (Cumulative TSN: 1426601536, a_rwnd: 131072, | |
| gaps: 0, duplicate TSNs: 0) | |
| Chunk type: SACK (3) | |
| Chunk flags: 0x00 | |
| Chunk length: 16 | |
| Cumulative TSN ACK: 1426601536 | |
| Advertised receiver window credit (a_rwnd): 131072 | |
| Number of gap acknowledgement blocks: 0 | |
| Number of duplicated TSNs: 0 | |
| */ | |
| uint8_t data[] = {0x13, 0x88, 0x13, 0x88, 0x0e, 0xdd, 0xca, 0x08, 0x01, 0x00, | |
| 0x00, 0x00, 0x03, 0x00, 0x00, 0x10, 0x55, 0x08, 0x36, 0x40, | |
| 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; | |
| EXPECT_FALSE( | |
| SctpPacket::Parse( | |
| data, | |
| {.disable_checksum_verification = false, | |
| .zero_checksum_alternate_error_detection_method = | |
| ZeroChecksumAlternateErrorDetectionMethod::LowerLayerDtls()}) | |
| .has_value()); | |
| } | |
| TEST(SctpPacketTest, WritePacketWithCalculatedChecksum) { | |
| SctpPacket::Builder b(kVerificationTag, {}); | |
| b.Add(SackChunk(/*cumulative_tsn_ack=*/TSN(999), /*a_rwnd=*/456, | |
| /*gap_ack_blocks=*/{}, | |
| /*duplicate_tsns=*/{})); | |
| EXPECT_THAT(b.Build(), | |
| ElementsAre(0x13, 0x88, 0x13, 0x88, 0x12, 0x34, 0x56, 0x78, // | |
| 0x07, 0xe8, 0x38, 0x77, // checksum | |
| 0x03, 0x00, 0x00, 0x10, 0x00, 0x00, 0x03, 0xe7, 0x00, | |
| 0x00, 0x01, 0xc8, 0x00, 0x00, 0x00, 0x00)); | |
| } | |
| TEST(SctpPacketTest, WritePacketWithZeroChecksum) { | |
| SctpPacket::Builder b(kVerificationTag, {}); | |
| b.Add(SackChunk(/*cumulative_tsn_ack=*/TSN(999), /*a_rwnd=*/456, | |
| /*gap_ack_blocks=*/{}, | |
| /*duplicate_tsns=*/{})); | |
| EXPECT_THAT(b.Build(/*write_checksum=*/false), | |
| ElementsAre(0x13, 0x88, 0x13, 0x88, 0x12, 0x34, 0x56, 0x78, // | |
| 0x00, 0x00, 0x00, 0x00, // checksum | |
| 0x03, 0x00, 0x00, 0x10, 0x00, 0x00, 0x03, 0xe7, 0x00, | |
| 0x00, 0x01, 0xc8, 0x00, 0x00, 0x00, 0x00)); | |
| } | |
| } // namespace | |
| } // namespace dcsctp |