Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 218 insertions, 0 deletions

diff --git a/third_party/libwebrtc/call/rtp_demuxer.h b/third_party/libwebrtc/call/rtp_demuxer.h
new file mode 100644
index 0000000000..53eeb0b6b6
--- /dev/null
+++ b/third_party/libwebrtc/call/rtp_demuxer.h
@@ -0,0 +1,218 @@
+/*
+ *  Copyright (c) 2017 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.
+ */
+
+#ifndef CALL_RTP_DEMUXER_H_
+#define CALL_RTP_DEMUXER_H_
+
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "rtc_base/containers/flat_map.h"
+#include "rtc_base/containers/flat_set.h"
+
+namespace webrtc {
+
+class RtpPacketReceived;
+class RtpPacketSinkInterface;
+
+// This struct describes the criteria that will be used to match packets to a
+// specific sink.
+class RtpDemuxerCriteria {
+ public:
+  explicit RtpDemuxerCriteria(absl::string_view mid,
+                              absl::string_view rsid = absl::string_view());
+  RtpDemuxerCriteria();
+  ~RtpDemuxerCriteria();
+
+  bool operator==(const RtpDemuxerCriteria& other) const;
+  bool operator!=(const RtpDemuxerCriteria& other) const;
+
+  // If not the empty string, will match packets with this MID.
+  const std::string& mid() const { return mid_; }
+
+  // Return string representation of demux criteria to facilitate logging
+  std::string ToString() const;
+
+  // If not the empty string, will match packets with this as their RTP stream
+  // ID or repaired RTP stream ID.
+  // Note that if both MID and RSID are specified, this will only match packets
+  // that have both specified (either through RTP header extensions, SSRC
+  // latching or RTCP).
+  const std::string& rsid() const { return rsid_; }
+
+  // The criteria will match packets with any of these SSRCs.
+  const flat_set<uint32_t>& ssrcs() const { return ssrcs_; }
+
+  // Writable accessor for directly modifying the list of ssrcs.
+  flat_set<uint32_t>& ssrcs() { return ssrcs_; }
+
+  // The criteria will match packets with any of these payload types.
+  const flat_set<uint8_t>& payload_types() const { return payload_types_; }
+
+  // Writable accessor for directly modifying the list of payload types.
+  flat_set<uint8_t>& payload_types() { return payload_types_; }
+
+ private:
+  // Intentionally private member variables to encourage specifying them via the
+  // constructor and consider them to be const as much as possible.
+  const std::string mid_;
+  const std::string rsid_;
+  flat_set<uint32_t> ssrcs_;
+  flat_set<uint8_t> payload_types_;
+};
+
+// This class represents the RTP demuxing, for a single RTP session (i.e., one
+// SSRC space, see RFC 7656). It isn't thread aware, leaving responsibility of
+// multithreading issues to the user of this class.
+// The demuxing algorithm follows the sketch given in the BUNDLE draft:
+// https://tools.ietf.org/html/draft-ietf-mmusic-sdp-bundle-negotiation-38#section-10.2
+// with modifications to support RTP stream IDs also.
+//
+// When a packet is received, the RtpDemuxer will route according to the
+// following rules:
+// 1. If the packet contains the MID header extension, and no sink has been
+//    added with that MID as a criteria, the packet is not routed.
+// 2. If the packet has the MID header extension, but no RSID or RRID extension,
+//    and the MID is bound to a sink, then bind its SSRC to the same sink and
+//    forward the packet to that sink. Note that rebinding to the same sink is
+//    not an error. (Later packets with that SSRC would therefore be forwarded
+//    to the same sink, whether they have the MID header extension or not.)
+// 3. If the packet has the MID header extension and either the RSID or RRID
+//    extension, and the MID, RSID (or RRID) pair is bound to a sink, then bind
+//    its SSRC to the same sink and forward the packet to that sink. Later
+//    packets with that SSRC will be forwarded to the same sink.
+// 4. If the packet has the RSID or RRID header extension, but no MID extension,
+//    and the RSID or RRID is bound to an RSID sink, then bind its SSRC to the
+//    same sink and forward the packet to that sink. Later packets with that
+//    SSRC will be forwarded to the same sink.
+// 5. If the packet's SSRC is bound to an SSRC through a previous call to
+//    AddSink, then forward the packet to that sink. Note that the RtpDemuxer
+//    will not verify the payload type even if included in the sink's criteria.
+//    The sink is expected to do the check in its handler.
+// 6. If the packet's payload type is bound to exactly one payload type sink
+//    through an earlier call to AddSink, then forward the packet to that sink.
+// 7. Otherwise, the packet is not routed.
+//
+// In summary, the routing algorithm will always try to first match MID and RSID
+// (including through SSRC binding), match SSRC directly as needed, and use
+// payload types only if all else fails.
+class RtpDemuxer {
+ public:
+  // Maximum number of unique SSRC bindings allowed. This limit is to prevent
+  // memory overuse attacks due to a malicious peer sending many packets with
+  // different SSRCs.
+  static constexpr int kMaxSsrcBindings = 1000;
+
+  // Returns a string that contains all the attributes of the given packet
+  // relevant for demuxing.
+  static std::string DescribePacket(const RtpPacketReceived& packet);
+
+  explicit RtpDemuxer(bool use_mid = true);
+  ~RtpDemuxer();
+
+  RtpDemuxer(const RtpDemuxer&) = delete;
+  void operator=(const RtpDemuxer&) = delete;
+
+  // Registers a sink that will be notified when RTP packets match its given
+  // criteria according to the algorithm described in the class description.
+  // Returns true if the sink was successfully added.
+  // Returns false in the following situations:
+  // - Only MID is specified and the MID is already registered.
+  // - Only RSID is specified and the RSID is already registered.
+  // - Both MID and RSID is specified and the (MID, RSID) pair is already
+  //   registered.
+  // - Any of the criteria SSRCs are already registered.
+  // If false is returned, no changes are made to the demuxer state.
+  bool AddSink(const RtpDemuxerCriteria& criteria,
+               RtpPacketSinkInterface* sink);
+
+  // Registers a sink. Multiple SSRCs may be mapped to the same sink, but
+  // each SSRC may only be mapped to one sink. The return value reports
+  // whether the association has been recorded or rejected. Rejection may occur
+  // if the SSRC has already been associated with a sink. The previously added
+  // sink is *not* forgotten.
+  bool AddSink(uint32_t ssrc, RtpPacketSinkInterface* sink);
+
+  // Registers a sink's association to an RSID. Only one sink may be associated
+  // with a given RSID. Null pointer is not allowed.
+  void AddSink(absl::string_view rsid, RtpPacketSinkInterface* sink);
+
+  // Removes a sink. Return value reports if anything was actually removed.
+  // Null pointer is not allowed.
+  bool RemoveSink(const RtpPacketSinkInterface* sink);
+
+  // Demuxes the given packet and forwards it to the chosen sink. Returns true
+  // if the packet was forwarded and false if the packet was dropped.
+  bool OnRtpPacket(const RtpPacketReceived& packet);
+
+ private:
+  // Returns true if adding a sink with the given criteria would cause conflicts
+  // with the existing criteria and should be rejected.
+  bool CriteriaWouldConflict(const RtpDemuxerCriteria& criteria) const;
+
+  // Runs the demux algorithm on the given packet and returns the sink that
+  // should receive the packet.
+  // Will record any SSRC<->ID associations along the way.
+  // If the packet should be dropped, this method returns null.
+  RtpPacketSinkInterface* ResolveSink(const RtpPacketReceived& packet);
+
+  // Used by the ResolveSink algorithm.
+  RtpPacketSinkInterface* ResolveSinkByMid(absl::string_view mid,
+                                           uint32_t ssrc);
+  RtpPacketSinkInterface* ResolveSinkByMidRsid(absl::string_view mid,
+                                               absl::string_view rsid,
+                                               uint32_t ssrc);
+  RtpPacketSinkInterface* ResolveSinkByRsid(absl::string_view rsid,
+                                            uint32_t ssrc);
+  RtpPacketSinkInterface* ResolveSinkByPayloadType(uint8_t payload_type,
+                                                   uint32_t ssrc);
+
+  // Regenerate the known_mids_ set from information in the sink_by_mid_ and
+  // sink_by_mid_and_rsid_ maps.
+  void RefreshKnownMids();
+
+  // Map each sink by its component attributes to facilitate quick lookups.
+  // Payload Type mapping is a multimap because if two sinks register for the
+  // same payload type, both AddSinks succeed but we must know not to demux on
+  // that attribute since it is ambiguous.
+  // Note: Mappings are only modified by AddSink/RemoveSink (except for
+  // SSRC mapping which receives all MID, payload type, or RSID to SSRC bindings
+  // discovered when demuxing packets).
+  flat_map<std::string, RtpPacketSinkInterface*> sink_by_mid_;
+  flat_map<uint32_t, RtpPacketSinkInterface*> sink_by_ssrc_;
+  std::multimap<uint8_t, RtpPacketSinkInterface*> sinks_by_pt_;
+  flat_map<std::pair<std::string, std::string>, RtpPacketSinkInterface*>
+      sink_by_mid_and_rsid_;
+  flat_map<std::string, RtpPacketSinkInterface*> sink_by_rsid_;
+
+  // Tracks all the MIDs that have been identified in added criteria. Used to
+  // determine if a packet should be dropped right away because the MID is
+  // unknown.
+  flat_set<std::string> known_mids_;
+
+  // Records learned mappings of MID --> SSRC and RSID --> SSRC as packets are
+  // received.
+  // This is stored separately from the sink mappings because if a sink is
+  // removed we want to still remember these associations.
+  flat_map<uint32_t, std::string> mid_by_ssrc_;
+  flat_map<uint32_t, std::string> rsid_by_ssrc_;
+
+  // Adds a binding from the SSRC to the given sink.
+  void AddSsrcSinkBinding(uint32_t ssrc, RtpPacketSinkInterface* sink);
+
+  const bool use_mid_;
+};
+
+}  // namespace webrtc
+
+#endif  // CALL_RTP_DEMUXER_H_