In RtpPacket do not keep pointer to RtpHeaderExtensionMap

webrtc/modules/rtp_rtcp/source/rtp_packet.cc

 /*
  *  Copyright (c) 2016 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.
  */
 
@@ skipping 34 matching lines @@
 // |One-byte eXtensions id = 0xbede|       length in 32bits        |
 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 // |                          Extensions                           |
 // |                             ....                              |
 // +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 // |                           Payload                             |
 // |             ....              :  padding...                   |
 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 // |               padding         | Padding size  |
 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+Packet::Packet() : Packet(nullptr, kDefaultPacketSize) {}
+
 Packet::Packet(const ExtensionManager* extensions)
-    : extensions_(extensions), buffer_(kDefaultPacketSize) {
-  Clear();
-}
+    : Packet(extensions, kDefaultPacketSize) {}
 
 Packet::Packet(const ExtensionManager* extensions, size_t capacity)
-    : extensions_(extensions), buffer_(capacity) {
+    : buffer_(capacity) {
   RTC_DCHECK_GE(capacity, kFixedHeaderSize);
   Clear();
+  if (extensions) {
+    IdentifyExtensions(*extensions);
+  } else {
+    for (size_t i = 0; i < kMaxExtensionHeaders; ++i)
+      extension_entries_[i].type = ExtensionManager::kInvalidType;
+  }
 }
 
 Packet::~Packet() {}
 
-void Packet::IdentifyExtensions(const ExtensionManager* extensions) {
-  RTC_DCHECK(extensions);
-  extensions_ = extensions;
-  for (size_t i = 0; i < num_extensions_; ++i) {
-    uint8_t id = data()[extension_entries_[i].offset - 1] >> 4;
-    extension_entries_[i].type = extensions_->GetType(id);
-  }
+void Packet::IdentifyExtensions(const ExtensionManager& extensions) {
+  for (size_t i = 0; i < kMaxExtensionHeaders; ++i)
+    extension_entries_[i].type = extensions.GetType(i + 1);
 }
 
 bool Packet::Parse(const uint8_t* buffer, size_t buffer_size) {
   if (!ParseBuffer(buffer, buffer_size)) {
     Clear();
     return false;
   }
   buffer_.SetData(buffer, buffer_size);
   RTC_DCHECK_EQ(size(), buffer_size);
   return true;
@@ skipping 119 matching lines @@
 
 void Packet::CopyHeaderFrom(const Packet& packet) {
   RTC_DCHECK_GE(capacity(), packet.headers_size());
 
   marker_ = packet.marker_;
   payload_type_ = packet.payload_type_;
   sequence_number_ = packet.sequence_number_;
   timestamp_ = packet.timestamp_;
   ssrc_ = packet.ssrc_;
   payload_offset_ = packet.payload_offset_;
-  num_extensions_ = packet.num_extensions_;
-  for (size_t i = 0; i < num_extensions_; ++i) {
+  for (size_t i = 0; i < kMaxExtensionHeaders; ++i) {
     extension_entries_[i] = packet.extension_entries_[i];
   }
   extensions_size_ = packet.extensions_size_;
   buffer_.SetData(packet.data(), packet.headers_size());
   // Reset payload and padding.
   payload_size_ = 0;
   padding_size_ = 0;
 }
 
 void Packet::SetMarker(bool marker_bit) {
@@ skipping 20 matching lines @@
   timestamp_ = timestamp;
   ByteWriter<uint32_t>::WriteBigEndian(WriteAt(4), timestamp);
 }
 
 void Packet::SetSsrc(uint32_t ssrc) {
   ssrc_ = ssrc;
   ByteWriter<uint32_t>::WriteBigEndian(WriteAt(8), ssrc);
 }
 
 void Packet::SetCsrcs(const std::vector<uint32_t>& csrcs) {
-  RTC_DCHECK_EQ(num_extensions_, 0);
+  RTC_DCHECK_EQ(extensions_size_, 0);
   RTC_DCHECK_EQ(payload_size_, 0);
   RTC_DCHECK_EQ(padding_size_, 0);
   RTC_DCHECK_LE(csrcs.size(), 0x0fu);
   RTC_DCHECK_LE(kFixedHeaderSize + 4 * csrcs.size(), capacity());
   payload_offset_ = kFixedHeaderSize + 4 * csrcs.size();
   WriteAt(0, (data()[0] & 0xF0) | csrcs.size());
   size_t offset = kFixedHeaderSize;
   for (uint32_t csrc : csrcs) {
     ByteWriter<uint32_t>::WriteBigEndian(WriteAt(offset), csrc);
     offset += 4;
@@ skipping 48 matching lines @@
 
 void Packet::Clear() {
   marker_ = false;
   payload_type_ = 0;
   sequence_number_ = 0;
   timestamp_ = 0;
   ssrc_ = 0;
   payload_offset_ = kFixedHeaderSize;
   payload_size_ = 0;
   padding_size_ = 0;
-  num_extensions_ = 0;
   extensions_size_ = 0;
+  for (ExtensionInfo& location : extension_entries_) {
+    location.offset = 0;
+    location.length = 0;
+  }
 
   memset(WriteAt(0), 0, kFixedHeaderSize);
   buffer_.SetSize(kFixedHeaderSize);
   WriteAt(0, kRtpVersion << 6);
 }
 
 bool Packet::ParseBuffer(const uint8_t* buffer, size_t size) {
   if (size < kFixedHeaderSize) {
     return false;
   }
@@ skipping 18 matching lines @@
   if (has_padding) {
     padding_size_ = buffer[size - 1];
     if (padding_size_ == 0) {
       LOG(LS_WARNING) << "Padding was set, but padding size is zero";
       return false;
     }
   } else {
     padding_size_ = 0;
   }
 
-  num_extensions_ = 0;
   extensions_size_ = 0;
+  for (ExtensionInfo& location : extension_entries_) {
+    location.offset = 0;
+    location.length = 0;
+  }
   if (has_extension) {
     /* RTP header extension, RFC 3550.
      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
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |      defined by profile       |           length              |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |                        header extension                       |
     |                             ....                              |
     */
     size_t extension_offset = payload_offset_ + 4;
     if (extension_offset > size) {
       return false;
     }
     uint16_t profile =
         ByteReader<uint16_t>::ReadBigEndian(&buffer[payload_offset_]);
     size_t extensions_capacity =
         ByteReader<uint16_t>::ReadBigEndian(&buffer[payload_offset_ + 2]);
     extensions_capacity *= 4;
     if (extension_offset + extensions_capacity > size) {
       return false;
     }
     if (profile != kOneByteExtensionId) {
       LOG(LS_WARNING) << "Unsupported rtp extension " << profile;
     } else {
       constexpr uint8_t kPaddingId = 0;
       constexpr uint8_t kReservedId = 15;
       while (extensions_size_ + kOneByteHeaderSize < extensions_capacity) {
-        uint8_t id = buffer[extension_offset + extensions_size_] >> 4;
+        int id = buffer[extension_offset + extensions_size_] >> 4;
         if (id == kReservedId) {
           break;
         } else if (id == kPaddingId) {
           extensions_size_++;
           continue;
         }
         uint8_t length =
             1 + (buffer[extension_offset + extensions_size_] & 0xf);
         if (extensions_size_ + kOneByteHeaderSize + length >
             extensions_capacity) {
           LOG(LS_WARNING) << "Oversized rtp header extension.";
           break;
         }
-        if (num_extensions_ >= kMaxExtensionHeaders) {
-          LOG(LS_WARNING) << "Too many rtp header extensions.";
-          break;
+
+        size_t idx = id - 1;
+        if (extension_entries_[idx].length != 0) {
+          LOG(LS_VERBOSE) << "Duplicate rtp header extension id " << id
+                          << ". Overwriting.";
         }
+
         extensions_size_ += kOneByteHeaderSize;
-        extension_entries_[num_extensions_].type =
-            extensions_ ? extensions_->GetType(id)
-                        : ExtensionManager::kInvalidType;
-        extension_entries_[num_extensions_].length = length;
-        extension_entries_[num_extensions_].offset =
-            extension_offset + extensions_size_;
-        num_extensions_++;
+        extension_entries_[idx].offset = extension_offset + extensions_size_;
+        extension_entries_[idx].length = length;
         extensions_size_ += length;
       }
     }
     payload_offset_ = extension_offset + extensions_capacity;
   }
 
   if (payload_offset_ + padding_size_ > size) {
     return false;
   }
   payload_size_ = size - payload_offset_ - padding_size_;
   return true;
 }
 
 bool Packet::FindExtension(ExtensionType type,
                            uint8_t length,
                            uint16_t* offset) const {
   RTC_DCHECK(offset);
-  for (size_t i = 0; i < num_extensions_; ++i) {
-    if (extension_entries_[i].type == type) {
-      if (length != extension_entries_[i].length) {
+  for (const ExtensionInfo& extension : extension_entries_) {
+    if (extension.type == type) {
+      if (extension.length == 0) {
+        // Extension is registered but not set.
+        return false;
+      }
+      if (length != extension.length) {
         LOG(LS_WARNING) << "Length mismatch for extension '" << type
                         << "': expected " << static_cast<int>(length)
-                        << ", received "
-                        << static_cast<int>(extension_entries_[i].length);
+                        << ", received " << static_cast<int>(extension.length);
         return false;
       }
-      *offset = extension_entries_[i].offset;
+      *offset = extension.offset;
       return true;
     }
   }
   return false;
 }
 
 bool Packet::AllocateExtension(ExtensionType type,
                                uint8_t length,
                                uint16_t* offset) {
-  if (!extensions_) {
+  uint8_t extension_id = ExtensionManager::kInvalidId;
+  ExtensionInfo* extension_entry = nullptr;
+  for (size_t i = 0; i < kMaxExtensionHeaders; ++i) {
+    if (extension_entries_[i].type == type) {
+      extension_id = i + 1;
+      extension_entry = &extension_entries_[i];
+      break;
+    }
+  }
+
+  if (!extension_entry)  // Extension not registered.
     return false;
-  }
-  if (FindExtension(type, length, offset)) {
+
+  if (extension_entry->length != 0) {  // Already allocated.
+    if (length != extension_entry->length) {
+      LOG(LS_WARNING) << "Length mismatch for extension '" << type
+                      << "': expected " << static_cast<int>(length)
+                      << ", received "
+                      << static_cast<int>(extension_entry->length);
+      return false;
+    }
+    *offset = extension_entry->offset;
     return true;
   }
 
   // Can't add new extension after payload/padding was set.
   if (payload_size_ > 0) {
     return false;
   }
   if (padding_size_ > 0) {
     return false;
   }
 
-  uint8_t extension_id = extensions_->GetId(type);
-  if (extension_id == ExtensionManager::kInvalidId) {
-    return false;
-  }
   RTC_DCHECK_GT(length, 0);
   RTC_DCHECK_LE(length, 16);
 
   size_t num_csrc = data()[0] & 0x0F;
   size_t extensions_offset = kFixedHeaderSize + (num_csrc * 4) + 4;
   if (extensions_offset + extensions_size_ + kOneByteHeaderSize + length >
       capacity()) {
     LOG(LS_WARNING) << "Extension cannot be registered: "
                        "Not enough space left in buffer.";
     return false;
   }
 
   uint16_t new_extensions_size =
       extensions_size_ + kOneByteHeaderSize + length;
   uint16_t extensions_words =
       (new_extensions_size + 3) / 4;  // Wrap up to 32bit.
 
   // All checks passed, write down the extension.
-  if (num_extensions_ == 0) {
+  if (extensions_size_ == 0) {
     RTC_DCHECK_EQ(payload_offset_, kFixedHeaderSize + (num_csrc * 4));
-    RTC_DCHECK_EQ(extensions_size_, 0);
     WriteAt(0, data()[0] | 0x10);  // Set extension bit.
     // Profile specific ID always set to OneByteExtensionHeader.
     ByteWriter<uint16_t>::WriteBigEndian(WriteAt(extensions_offset - 4),
                                          kOneByteExtensionId);
   }
 
   WriteAt(extensions_offset + extensions_size_,
           (extension_id << 4) | (length - 1));
-  RTC_DCHECK(num_extensions_ < kMaxExtensionHeaders);
-  extension_entries_[num_extensions_].type = type;
-  extension_entries_[num_extensions_].length = length;
+
+  extension_entry->length = length;
   *offset = extensions_offset + kOneByteHeaderSize + extensions_size_;
-  extension_entries_[num_extensions_].offset = *offset;
-  ++num_extensions_;
+  extension_entry->offset = *offset;
   extensions_size_ = new_extensions_size;
 
   // Update header length field.
   ByteWriter<uint16_t>::WriteBigEndian(WriteAt(extensions_offset - 2),
                                        extensions_words);
   // Fill extension padding place with zeroes.
   size_t extension_padding_size = 4 * extensions_words - extensions_size_;
   memset(WriteAt(extensions_offset + extensions_size_), 0,
          extension_padding_size);
   payload_offset_ = extensions_offset + 4 * extensions_words;
   buffer_.SetSize(payload_offset_);
   return true;
 }
 
 uint8_t* Packet::WriteAt(size_t offset) {
   return buffer_.data() + offset;
 }
 
 void Packet::WriteAt(size_t offset, uint8_t byte) {
   buffer_.data()[offset] = byte;
 }
 
 }  // namespace rtp
 }  // namespace webrtc