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

webrtc/modules/rtp_rtcp/source/rtcp_utility.cc

 /*
  *  Copyright (c) 2012 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_utility.h"
 
 #include <assert.h>
 #include <math.h>   // ceil
 #include <string.h> // memcpy
 
+#include "webrtc/base/checks.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+
 namespace webrtc {
 
 namespace RTCPUtility {
 
 NackStats::NackStats()
     : max_sequence_number_(0),
       requests_(0),
       unique_requests_(0) {}
 
 NackStats::~NackStats() {}
@@ skipping 121 matching lines @@
         }
     }
     return _packetType;
 }
 
 void
 RTCPUtility::RTCPParserV2::IterateTopLevel()
 {
     for (;;)
     {
-        RTCPCommonHeader header;
+      RtcpCommonHeader header;
+      if (_ptrRTCPDataEnd <= _ptrRTCPData)
+        return;
 
-        const bool success = RTCPParseCommonHeader(_ptrRTCPData,
-                                                    _ptrRTCPDataEnd,
-                                                    header);
-
-        if (!success)
-        {
+      if (!RtcpParseCommonHeader(_ptrRTCPData, _ptrRTCPDataEnd - _ptrRTCPData,
+                                 &header)) {
             return;
         }
-        _ptrRTCPBlockEnd = _ptrRTCPData + header.LengthInOctets;
+        _ptrRTCPBlockEnd = _ptrRTCPData + header.BlockSize();
         if (_ptrRTCPBlockEnd > _ptrRTCPDataEnd)
         {
             // Bad block!
             return;
         }
 
-        switch (header.PT)
-        {
+        switch (header.packet_type) {
         case PT_SR:
         {
             // number of Report blocks
-            _numberOfBlocks = header.IC;
+            _numberOfBlocks = header.count_or_format;
             ParseSR();
             return;
         }
         case PT_RR:
         {
             // number of Report blocks
-            _numberOfBlocks = header.IC;
+            _numberOfBlocks = header.count_or_format;
             ParseRR();
             return;
         }
         case PT_SDES:
         {
             // number of SDES blocks
-            _numberOfBlocks = header.IC;
+            _numberOfBlocks = header.count_or_format;
             const bool ok = ParseSDES();
             if (!ok)
             {
                 // Nothing supported found, continue to next block!
                 break;
             }
             return;
         }
         case PT_BYE:
         {
-            _numberOfBlocks = header.IC;
+          _numberOfBlocks = header.count_or_format;
             const bool ok = ParseBYE();
             if (!ok)
             {
                 // Nothing supported found, continue to next block!
                 break;
             }
             return;
         }
         case PT_IJ:
         {
             // number of Report blocks
-            _numberOfBlocks = header.IC;
+            _numberOfBlocks = header.count_or_format;
             ParseIJ();
             return;
         }
         case PT_RTPFB: // Fall through!
         case PT_PSFB:
         {
             const bool ok = ParseFBCommon(header);
             if (!ok)
             {
                 // Nothing supported found, continue to next block!
@@ skipping 175 matching lines @@
     const bool success = ParseAPPItem();
     if (!success)
     {
         Iterate();
     }
 }
 
 void
 RTCPUtility::RTCPParserV2::Validate()
 {
-    if (_ptrRTCPData == NULL)
-    {
-        return; // NOT VALID
-    }
+  if (_ptrRTCPData == nullptr)
+    return;  // NOT VALID
 
-    RTCPCommonHeader header;
-    const bool success = RTCPParseCommonHeader(_ptrRTCPDataBegin,
-                                               _ptrRTCPDataEnd,
-                                               header);
+  RtcpCommonHeader header;
+  if (_ptrRTCPDataEnd <= _ptrRTCPDataBegin)
+    return;  // NOT VALID
 
-    if (!success)
-    {
-        return; // NOT VALID!
-    }
+  if (!RtcpParseCommonHeader(_ptrRTCPDataBegin,
+                             _ptrRTCPDataEnd - _ptrRTCPDataBegin, &header))
+    return;  // NOT VALID!
 
     // * if (!reducedSize) : first packet must be RR or SR.
     //
     // * The padding bit (P) should be zero for the first packet of a
     //   compound RTCP packet because padding should only be applied,
     //   if it is needed, to the last packet. (NOT CHECKED!)
     //
     // * The length fields of the individual RTCP packets must add up
     //   to the overall length of the compound RTCP packet as
     //   received.  This is a fairly strong check. (NOT CHECKED!)
 
     if (!_RTCPReducedSizeEnable)
     {
-        if ((header.PT != PT_SR) && (header.PT != PT_RR))
-        {
+      if ((header.packet_type != PT_SR) && (header.packet_type != PT_RR)) {
             return; // NOT VALID
         }
     }
 
     _validPacket = true;
 }
 
 bool
 RTCPUtility::RTCPParserV2::IsValid() const
 {
     return _validPacket;
 }
 
 void
 RTCPUtility::RTCPParserV2::EndCurrentBlock()
 {
     _ptrRTCPData = _ptrRTCPBlockEnd;
 }
 
-bool
-RTCPUtility::RTCPParseCommonHeader( const uint8_t* ptrDataBegin,
-                                    const uint8_t* ptrDataEnd,
-                                    RTCPCommonHeader& parsedHeader)
-{
-    if (!ptrDataBegin || !ptrDataEnd)
-    {
-        return false;
+//  0                   1                   2                   3
+//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |V=2|P|    IC   |      PT       |             length            |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Common header for all RTCP packets, 4 octets.
+
+bool RTCPUtility::RtcpParseCommonHeader(const uint8_t* packet,
+                                        size_t size_bytes,
+                                        RtcpCommonHeader* parsed_header) {
+  DCHECK(parsed_header != nullptr);
+  if (size_bytes < RtcpCommonHeader::kHeaderSizeBytes) {
+    LOG(LS_WARNING) << "Too little data (" << size_bytes << " byte"
+                    << (size_bytes != 1 ? "s" : "")
+                    << ") remaining in buffer to parse RTCP header (4 bytes).";
+    return false;
+  }
+
+  const uint8_t kRtcpVersion = 2;
+  uint8_t version = packet[0] >> 6;
+  if (version != kRtcpVersion) {
+    LOG(LS_WARNING) << "Invalid RTCP header: Version must be "
+                    << static_cast<int>(kRtcpVersion) << " but was "
+                    << static_cast<int>(version);
+    return false;
+  }
+
+  bool has_padding = (packet[0] & 0x20) != 0;
+  uint8_t format = packet[0] & 0x1F;
+  uint8_t packet_type = packet[1];
+  size_t packet_size_words =
+      ByteReader<uint16_t>::ReadBigEndian(&packet[2]) + 1;
+
+  if (size_bytes < packet_size_words * 4) {
+    LOG(LS_WARNING) << "Buffer too small (" << size_bytes
+                    << " bytes) to fit an RtcpPacket of " << packet_size_words
+                    << " 32bit words.";
+    return false;
+  }
+
+  size_t payload_size = packet_size_words * 4;
+  size_t padding_bytes = 0;
+  if (has_padding) {
+    if (payload_size <= RtcpCommonHeader::kHeaderSizeBytes) {
+      LOG(LS_WARNING) << "Invalid RTCP header: Padding bit set but 0 payload "
+                         "size specified.";
+      return false;
     }
 
-    //  0                   1                   2                   3
-    //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
-    // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-    // |V=2|P|    IC   |      PT       |             length            |
-    // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-    //
-    // Common header for all RTCP packets, 4 octets.
+    padding_bytes = packet[payload_size - 1];
+    if (RtcpCommonHeader::kHeaderSizeBytes + padding_bytes > payload_size) {
+      LOG(LS_WARNING) << "Invalid RTCP header: Too many padding bytes ("
+                      << padding_bytes << ") for a packet size of "
+                      << payload_size << "bytes.";
+      return false;
+    }
+    payload_size -= padding_bytes;
+  }
+  payload_size -= RtcpCommonHeader::kHeaderSizeBytes;
 
-    if ((ptrDataEnd - ptrDataBegin) < 4)
-    {
-        return false;
-    }
+  parsed_header->version = kRtcpVersion;
+  parsed_header->count_or_format = format;
+  parsed_header->packet_type = packet_type;
+  parsed_header->payload_size_bytes = payload_size;
+  parsed_header->padding_bytes = padding_bytes;
 
-    parsedHeader.V              = ptrDataBegin[0] >> 6;
-    parsedHeader.P              = ((ptrDataBegin[0] & 0x20) == 0) ? false : true;
-    parsedHeader.IC             = ptrDataBegin[0] & 0x1f;
-    parsedHeader.PT             = ptrDataBegin[1];
-
-    parsedHeader.LengthInOctets = (ptrDataBegin[2] << 8) + ptrDataBegin[3] + 1;
-    parsedHeader.LengthInOctets *= 4;
-
-    if(parsedHeader.LengthInOctets == 0)
-    {
-        return false;
-    }
-    // Check if RTP version field == 2
-    if (parsedHeader.V != 2)
-    {
-        return false;
-    }
-
-    return true;
+  return true;
 }
 
 bool
 RTCPUtility::RTCPParserV2::ParseRR()
 {
     const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
 
     if (length < 8)
     {
         return false;
@@ skipping 617 matching lines @@
     _state = ParseState::State_TopLevel;
     EndCurrentBlock();
     return false;
   }
   // Skip block.
   _ptrRTCPData += kBlockLengthInBytes;
   _state = ParseState::State_XRItem;
   return false;
 }
 
-bool
-RTCPUtility::RTCPParserV2::ParseFBCommon(const RTCPCommonHeader& header)
-{
-    assert((header.PT == PT_RTPFB) || (header.PT == PT_PSFB)); // Parser logic check
+bool RTCPUtility::RTCPParserV2::ParseFBCommon(const RtcpCommonHeader& header) {
+  assert((header.packet_type == PT_RTPFB) ||
+         (header.packet_type == PT_PSFB));  // Parser logic check
 
     const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
 
     if (length < 12) // 4 * 3, RFC4585 section 6.1
     {
         EndCurrentBlock();
         return false;
     }
 
     _ptrRTCPData += 4; // Skip RTCP header
 
     uint32_t senderSSRC = *_ptrRTCPData++ << 24;
     senderSSRC += *_ptrRTCPData++ << 16;
     senderSSRC += *_ptrRTCPData++ << 8;
     senderSSRC += *_ptrRTCPData++;
 
     uint32_t mediaSSRC = *_ptrRTCPData++ << 24;
     mediaSSRC += *_ptrRTCPData++ << 16;
     mediaSSRC += *_ptrRTCPData++ << 8;
     mediaSSRC += *_ptrRTCPData++;
 
-    if (header.PT == PT_RTPFB)
-    {
+    if (header.packet_type == PT_RTPFB) {
         // Transport layer feedback
 
-        switch (header.IC)
-        {
+        switch (header.count_or_format) {
         case 1:
         {
             // NACK
           _packetType = RTCPPacketTypes::kRtpfbNack;
             _packet.NACK.SenderSSRC = senderSSRC;
             _packet.NACK.MediaSSRC  = mediaSSRC;
 
             _state = ParseState::State_RTPFB_NACKItem;
 
             return true;
@@ skipping 34 matching lines @@
           _packetType = RTCPPacketTypes::kRtpfbSrReq;
 
             // Note: No state transition, SR REQ is empty!
             return true;
         }
         default:
             break;
         }
         EndCurrentBlock();
         return false;
-    }
-    else if (header.PT == PT_PSFB)
-    {
+    } else if (header.packet_type == PT_PSFB) {
         // Payload specific feedback
-        switch (header.IC)
-        {
+        switch (header.count_or_format) {
         case 1:
             // PLI
           _packetType = RTCPPacketTypes::kPsfbPli;
             _packet.PLI.SenderSSRC = senderSSRC;
             _packet.PLI.MediaSSRC  = mediaSSRC;
 
             // Note: No state transition, PLI FCI is empty!
             return true;
         case 2:
             // SLI
@@ skipping 331 matching lines @@
     _packet.FIRItem.SSRC = *_ptrRTCPData++ << 24;
     _packet.FIRItem.SSRC += *_ptrRTCPData++ << 16;
     _packet.FIRItem.SSRC += *_ptrRTCPData++ << 8;
     _packet.FIRItem.SSRC += *_ptrRTCPData++;
 
     _packet.FIRItem.CommandSequenceNumber = *_ptrRTCPData++;
     _ptrRTCPData += 3; // Skip "Reserved" bytes.
     return true;
 }
 
-bool
-RTCPUtility::RTCPParserV2::ParseAPP( const RTCPCommonHeader& header)
-{
+bool RTCPUtility::RTCPParserV2::ParseAPP(const RtcpCommonHeader& header) {
     ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
 
     if (length < 12) // 4 * 3, RFC 3550 6.7 APP: Application-Defined RTCP Packet
     {
         EndCurrentBlock();
         return false;
     }
 
     _ptrRTCPData += 4; // Skip RTCP header
 
     uint32_t senderSSRC = *_ptrRTCPData++ << 24;
     senderSSRC += *_ptrRTCPData++ << 16;
     senderSSRC += *_ptrRTCPData++ << 8;
     senderSSRC += *_ptrRTCPData++;
 
     uint32_t name = *_ptrRTCPData++ << 24;
     name += *_ptrRTCPData++ << 16;
     name += *_ptrRTCPData++ << 8;
     name += *_ptrRTCPData++;
 
     length  = _ptrRTCPBlockEnd - _ptrRTCPData;
 
     _packetType = RTCPPacketTypes::kApp;
 
-    _packet.APP.SubType = header.IC;
+    _packet.APP.SubType = header.count_or_format;
     _packet.APP.Name = name;
 
     _state = ParseState::State_AppItem;
     return true;
 }
 
 bool
 RTCPUtility::RTCPParserV2::ParseAPPItem()
 {
     const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
@@ skipping 24 matching lines @@
                                                     size_t rtcpDataLength)
     : _ptrBegin(rtcpData),
       _ptrEnd(rtcpData + rtcpDataLength),
       _ptrBlock(NULL) {
   memset(&_header, 0, sizeof(_header));
 }
 
 RTCPUtility::RTCPPacketIterator::~RTCPPacketIterator() {
 }
 
-const RTCPUtility::RTCPCommonHeader*
-RTCPUtility::RTCPPacketIterator::Begin()
-{
+const RTCPUtility::RtcpCommonHeader* RTCPUtility::RTCPPacketIterator::Begin() {
     _ptrBlock = _ptrBegin;
 
     return Iterate();
 }
 
-const RTCPUtility::RTCPCommonHeader*
-RTCPUtility::RTCPPacketIterator::Iterate()
-{
-    const bool success = RTCPParseCommonHeader(_ptrBlock, _ptrEnd, _header);
-    if (!success)
-    {
-        _ptrBlock = NULL;
-        return NULL;
-    }
-    _ptrBlock += _header.LengthInOctets;
+const RTCPUtility::RtcpCommonHeader*
+RTCPUtility::RTCPPacketIterator::Iterate() {
+  if ((_ptrEnd <= _ptrBlock) ||
+      !RtcpParseCommonHeader(_ptrBlock, _ptrEnd - _ptrBlock, &_header)) {
+    _ptrBlock = nullptr;
+    return nullptr;
+  }
+  _ptrBlock += _header.BlockSize();
 
-    if (_ptrBlock > _ptrEnd)
-    {
-        _ptrBlock = NULL;
-        return  NULL;
-    }
+  if (_ptrBlock > _ptrEnd) {
+    _ptrBlock = nullptr;
+    return nullptr;
+  }
 
-    return &_header;
+  return &_header;
 }
 
-const RTCPUtility::RTCPCommonHeader*
-RTCPUtility::RTCPPacketIterator::Current()
-{
+const RTCPUtility::RtcpCommonHeader*
+RTCPUtility::RTCPPacketIterator::Current() {
     if (!_ptrBlock)
     {
         return NULL;
     }
 
     return &_header;
 }
 }  // namespace webrtc