Add a ParseHeader method to RtcpPacket, for parsing common RTCP header.

webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc

 /*
  *  Copyright (c) 2015 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 "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 
 namespace webrtc {
 namespace rtcp {
 
 // Header size:
 // * 12 bytes Common Packet Format for RTCP Feedback Messages
 // * 8 bytes FeedbackPacket header
 static const uint32_t kHeaderSizeBytes = 12 + 8;
 static const uint32_t kChunkSizeBytes = 2;
 static const uint32_t kOneBitVectorCapacity = 14;
@@ skipping 629 matching lines @@
     size_t length) {
   rtc::scoped_ptr<TransportFeedback> packet(new TransportFeedback());
 
   if (length < kMinSizeBytes) {
     LOG(LS_WARNING) << "Buffer too small (" << length
                     << " bytes) to fit a "
                        "FeedbackPacket. Minimum size = " << kMinSizeBytes;
     return nullptr;
   }
 
-  size_t packet_size_words =
-      ByteReader<uint16_t>::ReadBigEndian(&buffer[2]) + 1;
-  if (length < packet_size_words * 4) {
-    LOG(LS_WARNING) << "Buffer too small (" << length
-                    << " bytes) to fit a FeedbackPacket of "
-                    << packet_size_words << " 32bit words.";
+  RTCPUtility::RtcpCommonHeader header;
+  if (!RtcpParseCommonHeader(buffer, length, &header))
+    return nullptr;
+
+  if (header.count_or_format != kFeedbackMessageType) {
+    LOG(LS_WARNING) << "Invalid RTCP header: FMT must be "
+                    << kFeedbackMessageType << " but was "
+                    << header.count_or_format;
     return nullptr;
   }
 
-  // TODO(sprang): Break this out and generalize when implementing parsing of
-  // other RtcpPacket subclasses.
-
-  const uint8_t kRtcpVersion = 2;
-  uint8_t version = buffer[0] >> 6;
-  if (version != kRtcpVersion) {
-    LOG(LS_WARNING) << "Invalid RTCP header: Version must be " << kRtcpVersion
-                    << " but was " << version;
+  if (header.packet_type != kPayloadType) {
+    LOG(LS_WARNING) << "Invalid RTCP header: PT must be " << kPayloadType
+                    << " but was " << header.packet_type;
     return nullptr;
   }
 
-  bool has_padding = (buffer[0] & 0x20) != 0;
-
-  uint8_t format = buffer[0] & 0x1F;
-  if (format != kFeedbackMessageType) {
-    LOG(LS_WARNING) << "Invalid RTCP header: FMT must be "
-                    << kFeedbackMessageType << " but was " << format;
-    return nullptr;
-  }
-
-  uint8_t payload_type = buffer[1];
-  if (payload_type != kPayloadType) {
-    LOG(LS_WARNING) << "Invalid RTCP header: PT must be " << kPayloadType
-                    << " but was " << payload_type;
-    return nullptr;
-  }
-
-  size_t payload_size = packet_size_words * 4;
-  if (has_padding) {
-    uint8_t padding_bytes = buffer[payload_size - 1];
-    if (payload_size < kMinSizeBytes + padding_bytes) {
-      LOG(LS_WARNING) << "Invalid RTCP header: Too many padding bytes ("
-                      << padding_bytes << ") for a packet size of "
-                      << payload_size << "bytes.";
-      return nullptr;
-    }
-    payload_size -= padding_bytes;
-  }
-
   packet->packet_sender_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(&buffer[4]);
   packet->media_source_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(&buffer[8]);
   packet->base_seq_ = ByteReader<uint16_t>::ReadBigEndian(&buffer[12]);
   uint16_t num_packets = ByteReader<uint16_t>::ReadBigEndian(&buffer[14]);
   packet->base_time_ = ByteReader<int32_t, 3>::ReadBigEndian(&buffer[16]);
   packet->feedback_seq_ = buffer[19];
   size_t index = 20;
+  const size_t end_index = kHeaderLength + header.payload_size_bytes;
 
   if (num_packets == 0) {
     LOG(LS_WARNING) << "Empty feedback messages not allowed.";
     return nullptr;
   }
   packet->last_seq_ = packet->base_seq_ + num_packets - 1;
 
   size_t packets_read = 0;
   while (packets_read < num_packets) {
-    if (index + 2 > payload_size) {
+    if (index + 2 > end_index) {
       LOG(LS_WARNING) << "Buffer overflow while parsing packet.";
       return nullptr;
     }
 
     PacketStatusChunk* chunk =
         ParseChunk(&buffer[index], num_packets - packets_read);
     if (chunk == nullptr)
       return nullptr;
 
     index += 2;
     packet->status_chunks_.push_back(chunk);
     packets_read += chunk->NumSymbols();
   }
 
   std::vector<StatusSymbol> symbols = packet->GetStatusVector();
 
   DCHECK_EQ(num_packets, symbols.size());
 
   for (StatusSymbol symbol : symbols) {
     switch (symbol) {
       case StatusSymbol::kReceivedSmallDelta:
-        if (index + 1 > payload_size) {
+        if (index + 1 > end_index) {
           LOG(LS_WARNING) << "Buffer overflow while parsing packet.";
           return nullptr;
         }
         packet->receive_deltas_.push_back(buffer[index]);
         ++index;
         break;
       case StatusSymbol::kReceivedLargeDelta:
-        if (index + 2 > payload_size) {
+        if (index + 2 > end_index) {
           LOG(LS_WARNING) << "Buffer overflow while parsing packet.";
           return nullptr;
         }
         packet->receive_deltas_.push_back(
             ByteReader<int16_t>::ReadBigEndian(&buffer[index]));
         index += 2;
         break;
       default:
         continue;
     }
   }
 
-  DCHECK_GE(index, payload_size - 3);
-  DCHECK_LE(index, payload_size);
+  DCHECK_GE(index, end_index - 3);
+  DCHECK_LE(index, end_index);
 
   return packet;
 }
 
 PacketStatusChunk* TransportFeedback::ParseChunk(const uint8_t* buffer,
                                                  size_t max_size) {
   if (buffer[0] & 0x80) {
     // First bit set => vector chunk.
     std::deque<StatusSymbol> symbols;
     if (buffer[0] & 0x40) {
@@ skipping 12 matching lines @@
                        "RLE block of size " << rle_chunk->NumSymbols()
                     << " but only " << max_size << " left to read.";
     delete rle_chunk;
     return nullptr;
   }
   return rle_chunk;
 }
 
 }  // namespace rtcp
 }  // namespace webrtc