Fix boundary check problems in socket_host.cc.

content/browser/renderer_host/p2p/socket_host_unittest.cc

 // Copyright (c) 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/p2p/socket_host.h"
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "content/browser/renderer_host/p2p/socket_host_test_utils.h"
@@ skipping 134 matching lines @@
   0x32, 0xaa, 0xbb, 0xcc,
 };
 
 // Index of AbsSendTimeExtn data in message |kRtpMsgWithAbsSendTimeExtension|.
 static const int kAstIndexInRtpMsg = 21;
 
 namespace content {
 
 // This test verifies parsing of all invalid raw packets.
 TEST(P2PSocketHostTest, TestInvalidRawRtpMessages) {
-  int start_pos = INT_MAX, rtp_length = INT_MAX;
+  size_t start_pos = SIZE_MAX, rtp_length = SIZE_MAX;
   EXPECT_FALSE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
       reinterpret_cast<char*>(kRtpMsgWithInvalidLength),
       sizeof(kRtpMsgWithInvalidLength),
       &start_pos, &rtp_length));
-  EXPECT_EQ(INT_MAX, start_pos);
-  EXPECT_EQ(INT_MAX, rtp_length);
+  EXPECT_EQ(SIZE_MAX, start_pos);
+  EXPECT_EQ(SIZE_MAX, rtp_length);
 
   EXPECT_FALSE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
       reinterpret_cast<char*>(kRtpMsgWithInvalidExtnLength),
       sizeof(kRtpMsgWithInvalidExtnLength),
       &start_pos, &rtp_length));
-  EXPECT_EQ(INT_MAX, start_pos);
-  EXPECT_EQ(INT_MAX, rtp_length);
+  EXPECT_EQ(SIZE_MAX, start_pos);
+  EXPECT_EQ(SIZE_MAX, rtp_length);
 }
 
 // Verify invalid TURN send indication messages. Messages are proper STUN
 // messages with incorrect values in attributes.
 TEST(P2PSocketHostTest, TestInvalidTurnSendIndicationMessages) {
   // Initializing out params to very large value.
-  int start_pos = INT_MAX, rtp_length = INT_MAX;
+  size_t start_pos = SIZE_MAX, rtp_length = SIZE_MAX;
   EXPECT_FALSE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
       reinterpret_cast<char*>(kTurnSendIndicationMsgWithNoAttributes),
       sizeof(kTurnSendIndicationMsgWithNoAttributes),
       &start_pos, &rtp_length));
-  EXPECT_EQ(INT_MAX, start_pos);
-  EXPECT_EQ(INT_MAX, rtp_length);
+  EXPECT_EQ(SIZE_MAX, start_pos);
+  EXPECT_EQ(SIZE_MAX, rtp_length);
 
   EXPECT_FALSE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
       reinterpret_cast<char*>(kTurnSendIndicationMsgWithInvalidLength),
       sizeof(kTurnSendIndicationMsgWithInvalidLength),
       &start_pos, &rtp_length));
-  EXPECT_EQ(INT_MAX, start_pos);
-  EXPECT_EQ(INT_MAX, rtp_length);
+  EXPECT_EQ(SIZE_MAX, start_pos);
+  EXPECT_EQ(SIZE_MAX, rtp_length);
 
   EXPECT_FALSE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
       reinterpret_cast<char*>(kTurnSendIndicatinMsgWithNoDataAttribute),
       sizeof(kTurnSendIndicatinMsgWithNoDataAttribute),
       &start_pos, &rtp_length));
-  EXPECT_EQ(INT_MAX, start_pos);
-  EXPECT_EQ(INT_MAX, rtp_length);
+  EXPECT_EQ(SIZE_MAX, start_pos);
+  EXPECT_EQ(SIZE_MAX, rtp_length);
 }
 
 // This test verifies incorrectly formed TURN channel messages.
 TEST(P2PSocketHostTest, TestInvalidTurnChannelMessages) {
-  int start_pos = INT_MAX, rtp_length = INT_MAX;
+  size_t start_pos = SIZE_MAX, rtp_length = SIZE_MAX;
   EXPECT_FALSE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
       reinterpret_cast<char*>(kTurnChannelMsgNoRtpPacket),
       sizeof(kTurnChannelMsgNoRtpPacket),
       &start_pos, &rtp_length));
-  EXPECT_EQ(INT_MAX, start_pos);
-  EXPECT_EQ(INT_MAX, rtp_length);
+  EXPECT_EQ(SIZE_MAX, start_pos);
+  EXPECT_EQ(SIZE_MAX, rtp_length);
 
   EXPECT_FALSE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
       reinterpret_cast<char*>(kTurnChannelMsgWithZeroLength),
       sizeof(kTurnChannelMsgWithZeroLength),
       &start_pos, &rtp_length));
-  EXPECT_EQ(INT_MAX, start_pos);
-  EXPECT_EQ(INT_MAX, rtp_length);
+  EXPECT_EQ(SIZE_MAX, start_pos);
+  EXPECT_EQ(SIZE_MAX, rtp_length);
 }
 
 // This test verifies parsing of a valid RTP packet which has 2byte header
 // extension instead of a 1 byte header extension.
 TEST(P2PSocketHostTest, TestValid2ByteExtnHdrRtpMessage) {
-  int start_pos = INT_MAX, rtp_length = INT_MAX;
+  size_t start_pos = SIZE_MAX, rtp_length = SIZE_MAX;
   EXPECT_TRUE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
       reinterpret_cast<char*>(kRtpMsgWith2ByteExtnHeader),
       sizeof(kRtpMsgWith2ByteExtnHeader),
       &start_pos, &rtp_length));
-  EXPECT_EQ(20, rtp_length);
-  EXPECT_EQ(0, start_pos);
+  EXPECT_EQ(20U, rtp_length);
+  EXPECT_EQ(0U, start_pos);
 }
 
 // This test verifies parsing of a valid RTP packet which has 1 byte header
 // AbsSendTime extension in it.
 TEST(P2PSocketHostTest, TestValidRtpPacketWithAbsSendTimeExtension) {
-  int start_pos = INT_MAX, rtp_length = INT_MAX;
+  size_t start_pos = SIZE_MAX, rtp_length = SIZE_MAX;
   EXPECT_TRUE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
       reinterpret_cast<char*>(kRtpMsgWithAbsSendTimeExtension),
       sizeof(kRtpMsgWithAbsSendTimeExtension),
       &start_pos, &rtp_length));
-  EXPECT_EQ(24, rtp_length);
-  EXPECT_EQ(0, start_pos);
+  EXPECT_EQ(24U, rtp_length);
+  EXPECT_EQ(0U, start_pos);
 }
 
 // This test verifies parsing of a valid TURN Send Indication messages.
 TEST(P2PSocketHostTest, TestValidTurnSendIndicationMessages) {
-  int start_pos = INT_MAX, rtp_length = INT_MAX;
+  size_t start_pos = SIZE_MAX, rtp_length = SIZE_MAX;
   EXPECT_TRUE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
       reinterpret_cast<char*>(kTurnSendIndicationMsgWithoutRtpExtension),
       sizeof(kTurnSendIndicationMsgWithoutRtpExtension),
       &start_pos, &rtp_length));
-  EXPECT_EQ(12, rtp_length);
-  EXPECT_EQ(32, start_pos);
+  EXPECT_EQ(12U, rtp_length);
+  EXPECT_EQ(32U, start_pos);
 
-  start_pos = INT_MAX, rtp_length = INT_MAX;
+  start_pos = SIZE_MAX, rtp_length = SIZE_MAX;
   EXPECT_TRUE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
       reinterpret_cast<char*>(kTurnSendIndicationMsgWithAbsSendTimeExtension),
       sizeof(kTurnSendIndicationMsgWithAbsSendTimeExtension),
       &start_pos, &rtp_length));
-  EXPECT_EQ(24, rtp_length);
-  EXPECT_EQ(32, start_pos);
+  EXPECT_EQ(24U, rtp_length);
+  EXPECT_EQ(32U, start_pos);
 }
 
 // This test verifies parsing of valid TURN Channel Messages.
 TEST(P2PSocketHostTest, TestValidTurnChannelMessages) {
-  int start_pos = -1, rtp_length = -1;
+  size_t start_pos = 0, rtp_length = 0;
   EXPECT_TRUE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
       reinterpret_cast<char*>(kTurnChannelMsgWithRtpPacket),
       sizeof(kTurnChannelMsgWithRtpPacket), &start_pos, &rtp_length));
-  EXPECT_EQ(12, rtp_length);
-  EXPECT_EQ(4, start_pos);
+  EXPECT_EQ(12U, rtp_length);
+  EXPECT_EQ(4U, start_pos);
 
-  start_pos = -1, rtp_length = -1;
+  start_pos = 0, rtp_length = 0;
   EXPECT_TRUE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
       reinterpret_cast<char*>(kTurnChannelMsgWithAbsSendTimeExtension),
       sizeof(kTurnChannelMsgWithAbsSendTimeExtension),
       &start_pos, &rtp_length));
-  EXPECT_EQ(20, rtp_length);
-  EXPECT_EQ(4, start_pos);
+  EXPECT_EQ(20U, rtp_length);
+  EXPECT_EQ(4U, start_pos);
 }
 
 // Verify handling of a 2 byte extension header RTP messsage. Currently we don't
 // handle this kind of message.
 TEST(P2PSocketHostTest, TestUpdateAbsSendTimeExtensionIn2ByteHeaderExtn) {
-  EXPECT_FALSE(packet_processing_helpers::UpdateRtpAbsSendTimeExtn(
-    reinterpret_cast<char*>(kRtpMsgWith2ByteExtnHeader),
-    sizeof(kRtpMsgWith2ByteExtnHeader), 3, 0));
+  EXPECT_FALSE(packet_processing_helpers::UpdateRtpAbsSendTimeExtension(
+      reinterpret_cast<char*>(kRtpMsgWith2ByteExtnHeader),
+      sizeof(kRtpMsgWith2ByteExtnHeader),
+      3,
+      0));
 }
 
 // Verify finding an extension ID in the TURN send indication message.
 TEST(P2PSocketHostTest, TestUpdateAbsSendTimeExtensionInTurnSendIndication) {
-  EXPECT_TRUE(packet_processing_helpers::UpdateRtpAbsSendTimeExtn(
+  EXPECT_TRUE(packet_processing_helpers::UpdateRtpAbsSendTimeExtension(
       reinterpret_cast<char*>(kTurnSendIndicationMsgWithoutRtpExtension),
-      sizeof(kTurnSendIndicationMsgWithoutRtpExtension), 3, 0));
+      sizeof(kTurnSendIndicationMsgWithoutRtpExtension),
+      3,
+      0));
 
-  EXPECT_TRUE(packet_processing_helpers::UpdateRtpAbsSendTimeExtn(
+  EXPECT_TRUE(packet_processing_helpers::UpdateRtpAbsSendTimeExtension(
       reinterpret_cast<char*>(kTurnSendIndicationMsgWithAbsSendTimeExtension),
-      sizeof(kTurnSendIndicationMsgWithAbsSendTimeExtension), 3, 0));
+      sizeof(kTurnSendIndicationMsgWithAbsSendTimeExtension),
+      3,
+      0));
 }
 
 // Test without any packet options variables set. This method should return
 // without HMAC value in the packet.
 TEST(P2PSocketHostTest, TestApplyPacketOptionsWithDefaultValues) {
   unsigned char fake_tag[4] = { 0xba, 0xdd, 0xba, 0xdd };
   rtc::PacketOptions options;
   std::vector<char> rtp_packet;
   rtp_packet.resize(sizeof(kRtpMsgWithAbsSendTimeExtension) + 4);  // tag length
   memcpy(&rtp_packet[0], kRtpMsgWithAbsSendTimeExtension,
@@ skipping 30 matching lines @@
   EXPECT_NE(0, memcmp(&rtp_packet[sizeof(kRtpMsgWithAbsSendTimeExtension)],
                       kFakeTag, sizeof(kFakeTag)));
 
    // Verify AbsouluteSendTime extension field is not modified.
   EXPECT_EQ(0, memcmp(&rtp_packet[kAstIndexInRtpMsg],
                       kTestAstValue, sizeof(kTestAstValue)));
 }
 
 // Verify finding an extension ID in a raw rtp message.
 TEST(P2PSocketHostTest, TestUpdateAbsSendTimeExtensionInRtpPacket) {
-  EXPECT_TRUE(packet_processing_helpers::UpdateRtpAbsSendTimeExtn(
+  EXPECT_TRUE(packet_processing_helpers::UpdateRtpAbsSendTimeExtension(
       reinterpret_cast<char*>(kRtpMsgWithAbsSendTimeExtension),
-      sizeof(kRtpMsgWithAbsSendTimeExtension), 3, 0));
+      sizeof(kRtpMsgWithAbsSendTimeExtension),
+      3,
+      0));
 }
 
 // Verify we update both AbsSendTime extension header and HMAC.
 TEST(P2PSocketHostTest, TestApplyPacketOptionsWithAuthParamsAndAbsSendTime) {
   rtc::PacketOptions options;
   options.packet_time_params.srtp_auth_key.resize(20);
   options.packet_time_params.srtp_auth_key.assign(
       kTestKey, kTestKey + sizeof(kTestKey));
   options.packet_time_params.srtp_auth_tag_len = 4;
   options.packet_time_params.rtp_sendtime_extension_id = 3;
@@ skipping 10 matching lines @@
   EXPECT_NE(0, memcmp(&rtp_packet[sizeof(kRtpMsgWithAbsSendTimeExtension)],
                       kFakeTag, sizeof(kFakeTag)));
 
   // ApplyPackets should have the new timestamp passed as input.
   unsigned char timestamp_array[3] = { 0xcc, 0xbb, 0xaa };
   EXPECT_EQ(0, memcmp(&rtp_packet[kAstIndexInRtpMsg],
                       timestamp_array, sizeof(timestamp_array)));
 }
 
 }  // namespace content