zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

dcsctp: Ensure packet size doesn't exceed MTU

Browse Source 
Due to a previous refactoring, the SCTP packet header is only added when
the first chunk is written. This wasn't reflected in the
`bytes_remaining`, which made it add more than could fit within the MTU.

Additionally, the maximum packet size must be even divisible by four as
padding will be added to chunks that are not even divisble by four (up
to three bytes of padding). So compensate for that.

Bug: webrtc:12614
Change-Id: I6b57dfbf88d1fcfcbf443038915dd180e796191a
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/215145
Reviewed-by: Tommi <tommi@webrtc.org>
Reviewed-by: Florent Castelli <orphis@webrtc.org>
Commit-Queue: Victor Boivie <boivie@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#33760}
This commit is contained in:
Victor Boivie
2021-04-13 23:42:39 +02:00
committed by Commit Bot
parent 7af57c6e48
commit 78aa5cd359
5 changed files with 178 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
net/dcsctp/common/math_test.cc
View File

@ -15,17 +15,101 @@ namespace dcsctp {
namespace {
TEST(MathUtilTest, CanRoundUpTo4) {
EXPECT_EQ(RoundUpTo4(0), 0);
EXPECT_EQ(RoundUpTo4(1), 4);
EXPECT_EQ(RoundUpTo4(2), 4);
EXPECT_EQ(RoundUpTo4(3), 4);
EXPECT_EQ(RoundUpTo4(4), 4);
EXPECT_EQ(RoundUpTo4(5), 8);
EXPECT_EQ(RoundUpTo4(6), 8);
EXPECT_EQ(RoundUpTo4(7), 8);
EXPECT_EQ(RoundUpTo4(8), 8);
EXPECT_EQ(RoundUpTo4(10000000000), 10000000000);
EXPECT_EQ(RoundUpTo4(10000000001), 10000000004);
// Signed numbers
EXPECT_EQ(RoundUpTo4(static_cast<int>(-5)), -4);
EXPECT_EQ(RoundUpTo4(static_cast<int>(-4)), -4);
EXPECT_EQ(RoundUpTo4(static_cast<int>(-3)), 0);
EXPECT_EQ(RoundUpTo4(static_cast<int>(-2)), 0);
EXPECT_EQ(RoundUpTo4(static_cast<int>(-1)), 0);
EXPECT_EQ(RoundUpTo4(static_cast<int>(0)), 0);
EXPECT_EQ(RoundUpTo4(static_cast<int>(1)), 4);
EXPECT_EQ(RoundUpTo4(static_cast<int>(2)), 4);
EXPECT_EQ(RoundUpTo4(static_cast<int>(3)), 4);
EXPECT_EQ(RoundUpTo4(static_cast<int>(4)), 4);
EXPECT_EQ(RoundUpTo4(static_cast<int>(5)), 8);
EXPECT_EQ(RoundUpTo4(static_cast<int>(6)), 8);
EXPECT_EQ(RoundUpTo4(static_cast<int>(7)), 8);
EXPECT_EQ(RoundUpTo4(static_cast<int>(8)), 8);
EXPECT_EQ(RoundUpTo4(static_cast<int64_t>(10000000000)), 10000000000);
EXPECT_EQ(RoundUpTo4(static_cast<int64_t>(10000000001)), 10000000004);
// Unsigned numbers
EXPECT_EQ(RoundUpTo4(static_cast<unsigned int>(0)), 0u);
EXPECT_EQ(RoundUpTo4(static_cast<unsigned int>(1)), 4u);
EXPECT_EQ(RoundUpTo4(static_cast<unsigned int>(2)), 4u);
EXPECT_EQ(RoundUpTo4(static_cast<unsigned int>(3)), 4u);
EXPECT_EQ(RoundUpTo4(static_cast<unsigned int>(4)), 4u);
EXPECT_EQ(RoundUpTo4(static_cast<unsigned int>(5)), 8u);
EXPECT_EQ(RoundUpTo4(static_cast<unsigned int>(6)), 8u);
EXPECT_EQ(RoundUpTo4(static_cast<unsigned int>(7)), 8u);
EXPECT_EQ(RoundUpTo4(static_cast<unsigned int>(8)), 8u);
EXPECT_EQ(RoundUpTo4(static_cast<uint64_t>(10000000000)), 10000000000u);
EXPECT_EQ(RoundUpTo4(static_cast<uint64_t>(10000000001)), 10000000004u);
}
TEST(MathUtilTest, CanRoundDownTo4) {
// Signed numbers
EXPECT_EQ(RoundDownTo4(static_cast<int>(-5)), -8);
EXPECT_EQ(RoundDownTo4(static_cast<int>(-4)), -4);
EXPECT_EQ(RoundDownTo4(static_cast<int>(-3)), -4);
EXPECT_EQ(RoundDownTo4(static_cast<int>(-2)), -4);
EXPECT_EQ(RoundDownTo4(static_cast<int>(-1)), -4);
EXPECT_EQ(RoundDownTo4(static_cast<int>(0)), 0);
EXPECT_EQ(RoundDownTo4(static_cast<int>(1)), 0);
EXPECT_EQ(RoundDownTo4(static_cast<int>(2)), 0);
EXPECT_EQ(RoundDownTo4(static_cast<int>(3)), 0);
EXPECT_EQ(RoundDownTo4(static_cast<int>(4)), 4);
EXPECT_EQ(RoundDownTo4(static_cast<int>(5)), 4);
EXPECT_EQ(RoundDownTo4(static_cast<int>(6)), 4);
EXPECT_EQ(RoundDownTo4(static_cast<int>(7)), 4);
EXPECT_EQ(RoundDownTo4(static_cast<int>(8)), 8);
EXPECT_EQ(RoundDownTo4(static_cast<int64_t>(10000000000)), 10000000000);
EXPECT_EQ(RoundDownTo4(static_cast<int64_t>(10000000001)), 10000000000);
// Unsigned numbers
EXPECT_EQ(RoundDownTo4(static_cast<unsigned int>(0)), 0u);
EXPECT_EQ(RoundDownTo4(static_cast<unsigned int>(1)), 0u);
EXPECT_EQ(RoundDownTo4(static_cast<unsigned int>(2)), 0u);
EXPECT_EQ(RoundDownTo4(static_cast<unsigned int>(3)), 0u);
EXPECT_EQ(RoundDownTo4(static_cast<unsigned int>(4)), 4u);
EXPECT_EQ(RoundDownTo4(static_cast<unsigned int>(5)), 4u);
EXPECT_EQ(RoundDownTo4(static_cast<unsigned int>(6)), 4u);
EXPECT_EQ(RoundDownTo4(static_cast<unsigned int>(7)), 4u);
EXPECT_EQ(RoundDownTo4(static_cast<unsigned int>(8)), 8u);
EXPECT_EQ(RoundDownTo4(static_cast<uint64_t>(10000000000)), 10000000000u);
EXPECT_EQ(RoundDownTo4(static_cast<uint64_t>(10000000001)), 10000000000u);
}
TEST(MathUtilTest, IsDivisibleBy4) {
// Signed numbers
EXPECT_EQ(IsDivisibleBy4(static_cast<int>(-4)), true);
EXPECT_EQ(IsDivisibleBy4(static_cast<int>(-3)), false);
EXPECT_EQ(IsDivisibleBy4(static_cast<int>(-2)), false);
EXPECT_EQ(IsDivisibleBy4(static_cast<int>(-1)), false);
EXPECT_EQ(IsDivisibleBy4(static_cast<int>(0)), true);
EXPECT_EQ(IsDivisibleBy4(static_cast<int>(1)), false);
EXPECT_EQ(IsDivisibleBy4(static_cast<int>(2)), false);
EXPECT_EQ(IsDivisibleBy4(static_cast<int>(3)), false);
EXPECT_EQ(IsDivisibleBy4(static_cast<int>(4)), true);
EXPECT_EQ(IsDivisibleBy4(static_cast<int>(5)), false);
EXPECT_EQ(IsDivisibleBy4(static_cast<int>(6)), false);
EXPECT_EQ(IsDivisibleBy4(static_cast<int>(7)), false);
EXPECT_EQ(IsDivisibleBy4(static_cast<int>(8)), true);
EXPECT_EQ(IsDivisibleBy4(static_cast<int64_t>(10000000000)), true);
EXPECT_EQ(IsDivisibleBy4(static_cast<int64_t>(10000000001)), false);
// Unsigned numbers
EXPECT_EQ(IsDivisibleBy4(static_cast<unsigned int>(0)), true);
EXPECT_EQ(IsDivisibleBy4(static_cast<unsigned int>(1)), false);
EXPECT_EQ(IsDivisibleBy4(static_cast<unsigned int>(2)), false);
EXPECT_EQ(IsDivisibleBy4(static_cast<unsigned int>(3)), false);
EXPECT_EQ(IsDivisibleBy4(static_cast<unsigned int>(4)), true);
EXPECT_EQ(IsDivisibleBy4(static_cast<unsigned int>(5)), false);
EXPECT_EQ(IsDivisibleBy4(static_cast<unsigned int>(6)), false);
EXPECT_EQ(IsDivisibleBy4(static_cast<unsigned int>(7)), false);
EXPECT_EQ(IsDivisibleBy4(static_cast<unsigned int>(8)), true);
EXPECT_EQ(IsDivisibleBy4(static_cast<uint64_t>(10000000000)), true);
EXPECT_EQ(IsDivisibleBy4(static_cast<uint64_t>(10000000001)), false);
}
} // namespace