1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
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_
|
