1 /*
2 * Copyright 2017 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "pc/rtp_transport.h"
12
13 #include "p2p/base/fake_packet_transport.h"
14 #include "pc/test/rtp_transport_test_util.h"
15 #include "rtc_base/buffer.h"
16 #include "rtc_base/containers/flat_set.h"
17 #include "rtc_base/third_party/sigslot/sigslot.h"
18 #include "test/gtest.h"
19
20 namespace webrtc {
21
22 constexpr bool kMuxDisabled = false;
23 constexpr bool kMuxEnabled = true;
24 constexpr uint16_t kLocalNetId = 1;
25 constexpr uint16_t kRemoteNetId = 2;
26 constexpr int kLastPacketId = 100;
27 constexpr int kTransportOverheadPerPacket = 28; // Ipv4(20) + UDP(8).
28
29 class SignalObserver : public sigslot::has_slots<> {
30 public:
SignalObserver(RtpTransport * transport)31 explicit SignalObserver(RtpTransport* transport) {
32 transport_ = transport;
33 transport->SignalReadyToSend.connect(this, &SignalObserver::OnReadyToSend);
34 transport->SignalNetworkRouteChanged.connect(
35 this, &SignalObserver::OnNetworkRouteChanged);
36 if (transport->rtp_packet_transport()) {
37 transport->rtp_packet_transport()->SignalSentPacket.connect(
38 this, &SignalObserver::OnSentPacket);
39 }
40
41 if (transport->rtcp_packet_transport()) {
42 transport->rtcp_packet_transport()->SignalSentPacket.connect(
43 this, &SignalObserver::OnSentPacket);
44 }
45 }
46
ready() const47 bool ready() const { return ready_; }
OnReadyToSend(bool ready)48 void OnReadyToSend(bool ready) { ready_ = ready; }
49
network_route()50 absl::optional<rtc::NetworkRoute> network_route() { return network_route_; }
OnNetworkRouteChanged(absl::optional<rtc::NetworkRoute> network_route)51 void OnNetworkRouteChanged(absl::optional<rtc::NetworkRoute> network_route) {
52 network_route_ = network_route;
53 }
54
OnSentPacket(rtc::PacketTransportInternal * packet_transport,const rtc::SentPacket & sent_packet)55 void OnSentPacket(rtc::PacketTransportInternal* packet_transport,
56 const rtc::SentPacket& sent_packet) {
57 if (packet_transport == transport_->rtp_packet_transport()) {
58 rtp_transport_sent_count_++;
59 } else {
60 ASSERT_EQ(transport_->rtcp_packet_transport(), packet_transport);
61 rtcp_transport_sent_count_++;
62 }
63 }
64
rtp_transport_sent_count()65 int rtp_transport_sent_count() { return rtp_transport_sent_count_; }
66
rtcp_transport_sent_count()67 int rtcp_transport_sent_count() { return rtcp_transport_sent_count_; }
68
69 private:
70 int rtp_transport_sent_count_ = 0;
71 int rtcp_transport_sent_count_ = 0;
72 RtpTransport* transport_ = nullptr;
73 bool ready_ = false;
74 absl::optional<rtc::NetworkRoute> network_route_;
75 };
76
TEST(RtpTransportTest,SettingRtcpAndRtpSignalsReady)77 TEST(RtpTransportTest, SettingRtcpAndRtpSignalsReady) {
78 RtpTransport transport(kMuxDisabled);
79 SignalObserver observer(&transport);
80 rtc::FakePacketTransport fake_rtcp("fake_rtcp");
81 fake_rtcp.SetWritable(true);
82 rtc::FakePacketTransport fake_rtp("fake_rtp");
83 fake_rtp.SetWritable(true);
84
85 transport.SetRtcpPacketTransport(&fake_rtcp); // rtcp ready
86 EXPECT_FALSE(observer.ready());
87 transport.SetRtpPacketTransport(&fake_rtp); // rtp ready
88 EXPECT_TRUE(observer.ready());
89 }
90
TEST(RtpTransportTest,SettingRtpAndRtcpSignalsReady)91 TEST(RtpTransportTest, SettingRtpAndRtcpSignalsReady) {
92 RtpTransport transport(kMuxDisabled);
93 SignalObserver observer(&transport);
94 rtc::FakePacketTransport fake_rtcp("fake_rtcp");
95 fake_rtcp.SetWritable(true);
96 rtc::FakePacketTransport fake_rtp("fake_rtp");
97 fake_rtp.SetWritable(true);
98
99 transport.SetRtpPacketTransport(&fake_rtp); // rtp ready
100 EXPECT_FALSE(observer.ready());
101 transport.SetRtcpPacketTransport(&fake_rtcp); // rtcp ready
102 EXPECT_TRUE(observer.ready());
103 }
104
TEST(RtpTransportTest,SettingRtpWithRtcpMuxEnabledSignalsReady)105 TEST(RtpTransportTest, SettingRtpWithRtcpMuxEnabledSignalsReady) {
106 RtpTransport transport(kMuxEnabled);
107 SignalObserver observer(&transport);
108 rtc::FakePacketTransport fake_rtp("fake_rtp");
109 fake_rtp.SetWritable(true);
110
111 transport.SetRtpPacketTransport(&fake_rtp); // rtp ready
112 EXPECT_TRUE(observer.ready());
113 }
114
TEST(RtpTransportTest,DisablingRtcpMuxSignalsNotReady)115 TEST(RtpTransportTest, DisablingRtcpMuxSignalsNotReady) {
116 RtpTransport transport(kMuxEnabled);
117 SignalObserver observer(&transport);
118 rtc::FakePacketTransport fake_rtp("fake_rtp");
119 fake_rtp.SetWritable(true);
120
121 transport.SetRtpPacketTransport(&fake_rtp); // rtp ready
122 EXPECT_TRUE(observer.ready());
123
124 transport.SetRtcpMuxEnabled(false);
125 EXPECT_FALSE(observer.ready());
126 }
127
TEST(RtpTransportTest,EnablingRtcpMuxSignalsReady)128 TEST(RtpTransportTest, EnablingRtcpMuxSignalsReady) {
129 RtpTransport transport(kMuxDisabled);
130 SignalObserver observer(&transport);
131 rtc::FakePacketTransport fake_rtp("fake_rtp");
132 fake_rtp.SetWritable(true);
133
134 transport.SetRtpPacketTransport(&fake_rtp); // rtp ready
135 EXPECT_FALSE(observer.ready());
136
137 transport.SetRtcpMuxEnabled(true);
138 EXPECT_TRUE(observer.ready());
139 }
140
141 // Tests the SignalNetworkRoute is fired when setting a packet transport.
TEST(RtpTransportTest,SetRtpTransportWithNetworkRouteChanged)142 TEST(RtpTransportTest, SetRtpTransportWithNetworkRouteChanged) {
143 RtpTransport transport(kMuxDisabled);
144 SignalObserver observer(&transport);
145 rtc::FakePacketTransport fake_rtp("fake_rtp");
146
147 EXPECT_FALSE(observer.network_route());
148
149 rtc::NetworkRoute network_route;
150 // Set a non-null RTP transport with a new network route.
151 network_route.connected = true;
152 network_route.local = rtc::RouteEndpoint::CreateWithNetworkId(kLocalNetId);
153 network_route.remote = rtc::RouteEndpoint::CreateWithNetworkId(kRemoteNetId);
154 network_route.last_sent_packet_id = kLastPacketId;
155 network_route.packet_overhead = kTransportOverheadPerPacket;
156 fake_rtp.SetNetworkRoute(absl::optional<rtc::NetworkRoute>(network_route));
157 transport.SetRtpPacketTransport(&fake_rtp);
158 ASSERT_TRUE(observer.network_route());
159 EXPECT_TRUE(observer.network_route()->connected);
160 EXPECT_EQ(kLocalNetId, observer.network_route()->local.network_id());
161 EXPECT_EQ(kRemoteNetId, observer.network_route()->remote.network_id());
162 EXPECT_EQ(kTransportOverheadPerPacket,
163 observer.network_route()->packet_overhead);
164 EXPECT_EQ(kLastPacketId, observer.network_route()->last_sent_packet_id);
165
166 // Set a null RTP transport.
167 transport.SetRtpPacketTransport(nullptr);
168 EXPECT_FALSE(observer.network_route());
169 }
170
TEST(RtpTransportTest,SetRtcpTransportWithNetworkRouteChanged)171 TEST(RtpTransportTest, SetRtcpTransportWithNetworkRouteChanged) {
172 RtpTransport transport(kMuxDisabled);
173 SignalObserver observer(&transport);
174 rtc::FakePacketTransport fake_rtcp("fake_rtcp");
175
176 EXPECT_FALSE(observer.network_route());
177
178 rtc::NetworkRoute network_route;
179 // Set a non-null RTCP transport with a new network route.
180 network_route.connected = true;
181 network_route.local = rtc::RouteEndpoint::CreateWithNetworkId(kLocalNetId);
182 network_route.remote = rtc::RouteEndpoint::CreateWithNetworkId(kRemoteNetId);
183 network_route.last_sent_packet_id = kLastPacketId;
184 network_route.packet_overhead = kTransportOverheadPerPacket;
185 fake_rtcp.SetNetworkRoute(absl::optional<rtc::NetworkRoute>(network_route));
186 transport.SetRtcpPacketTransport(&fake_rtcp);
187 ASSERT_TRUE(observer.network_route());
188 EXPECT_TRUE(observer.network_route()->connected);
189 EXPECT_EQ(kLocalNetId, observer.network_route()->local.network_id());
190 EXPECT_EQ(kRemoteNetId, observer.network_route()->remote.network_id());
191 EXPECT_EQ(kTransportOverheadPerPacket,
192 observer.network_route()->packet_overhead);
193 EXPECT_EQ(kLastPacketId, observer.network_route()->last_sent_packet_id);
194
195 // Set a null RTCP transport.
196 transport.SetRtcpPacketTransport(nullptr);
197 EXPECT_FALSE(observer.network_route());
198 }
199
200 // Test that RTCP packets are sent over correct transport based on the RTCP-mux
201 // status.
TEST(RtpTransportTest,RtcpPacketSentOverCorrectTransport)202 TEST(RtpTransportTest, RtcpPacketSentOverCorrectTransport) {
203 // If the RTCP-mux is not enabled, RTCP packets are expected to be sent over
204 // the RtcpPacketTransport.
205 RtpTransport transport(kMuxDisabled);
206 rtc::FakePacketTransport fake_rtcp("fake_rtcp");
207 rtc::FakePacketTransport fake_rtp("fake_rtp");
208 transport.SetRtcpPacketTransport(&fake_rtcp); // rtcp ready
209 transport.SetRtpPacketTransport(&fake_rtp); // rtp ready
210 SignalObserver observer(&transport);
211
212 fake_rtp.SetDestination(&fake_rtp, true);
213 fake_rtcp.SetDestination(&fake_rtcp, true);
214
215 rtc::CopyOnWriteBuffer packet;
216 EXPECT_TRUE(transport.SendRtcpPacket(&packet, rtc::PacketOptions(), 0));
217 EXPECT_EQ(1, observer.rtcp_transport_sent_count());
218
219 // The RTCP packets are expected to be sent over RtpPacketTransport if
220 // RTCP-mux is enabled.
221 transport.SetRtcpMuxEnabled(true);
222 EXPECT_TRUE(transport.SendRtcpPacket(&packet, rtc::PacketOptions(), 0));
223 EXPECT_EQ(1, observer.rtp_transport_sent_count());
224 }
225
TEST(RtpTransportTest,ChangingReadyToSendStateOnlySignalsWhenChanged)226 TEST(RtpTransportTest, ChangingReadyToSendStateOnlySignalsWhenChanged) {
227 RtpTransport transport(kMuxEnabled);
228 TransportObserver observer(&transport);
229 rtc::FakePacketTransport fake_rtp("fake_rtp");
230 fake_rtp.SetWritable(true);
231
232 // State changes, so we should signal.
233 transport.SetRtpPacketTransport(&fake_rtp);
234 EXPECT_EQ(observer.ready_to_send_signal_count(), 1);
235
236 // State does not change, so we should not signal.
237 transport.SetRtpPacketTransport(&fake_rtp);
238 EXPECT_EQ(observer.ready_to_send_signal_count(), 1);
239
240 // State does not change, so we should not signal.
241 transport.SetRtcpMuxEnabled(true);
242 EXPECT_EQ(observer.ready_to_send_signal_count(), 1);
243
244 // State changes, so we should signal.
245 transport.SetRtcpMuxEnabled(false);
246 EXPECT_EQ(observer.ready_to_send_signal_count(), 2);
247 }
248
249 // Test that SignalPacketReceived fires with rtcp=true when a RTCP packet is
250 // received.
TEST(RtpTransportTest,SignalDemuxedRtcp)251 TEST(RtpTransportTest, SignalDemuxedRtcp) {
252 RtpTransport transport(kMuxDisabled);
253 rtc::FakePacketTransport fake_rtp("fake_rtp");
254 fake_rtp.SetDestination(&fake_rtp, true);
255 transport.SetRtpPacketTransport(&fake_rtp);
256 TransportObserver observer(&transport);
257
258 // An rtcp packet.
259 const unsigned char data[] = {0x80, 73, 0, 0};
260 const int len = 4;
261 const rtc::PacketOptions options;
262 const int flags = 0;
263 fake_rtp.SendPacket(reinterpret_cast<const char*>(data), len, options, flags);
264 EXPECT_EQ(0, observer.rtp_count());
265 EXPECT_EQ(1, observer.rtcp_count());
266 }
267
268 static const unsigned char kRtpData[] = {0x80, 0x11, 0, 0, 0, 0,
269 0, 0, 0, 0, 0, 0};
270 static const int kRtpLen = 12;
271
272 // Test that SignalPacketReceived fires with rtcp=false when a RTP packet with a
273 // handled payload type is received.
TEST(RtpTransportTest,SignalHandledRtpPayloadType)274 TEST(RtpTransportTest, SignalHandledRtpPayloadType) {
275 RtpTransport transport(kMuxDisabled);
276 rtc::FakePacketTransport fake_rtp("fake_rtp");
277 fake_rtp.SetDestination(&fake_rtp, true);
278 transport.SetRtpPacketTransport(&fake_rtp);
279 TransportObserver observer(&transport);
280 RtpDemuxerCriteria demuxer_criteria;
281 // Add a handled payload type.
282 demuxer_criteria.payload_types().insert(0x11);
283 transport.RegisterRtpDemuxerSink(demuxer_criteria, &observer);
284
285 // An rtp packet.
286 const rtc::PacketOptions options;
287 const int flags = 0;
288 rtc::Buffer rtp_data(kRtpData, kRtpLen);
289 fake_rtp.SendPacket(rtp_data.data<char>(), kRtpLen, options, flags);
290 EXPECT_EQ(1, observer.rtp_count());
291 EXPECT_EQ(0, observer.rtcp_count());
292 // Remove the sink before destroying the transport.
293 transport.UnregisterRtpDemuxerSink(&observer);
294 }
295
296 // Test that SignalPacketReceived does not fire when a RTP packet with an
297 // unhandled payload type is received.
TEST(RtpTransportTest,DontSignalUnhandledRtpPayloadType)298 TEST(RtpTransportTest, DontSignalUnhandledRtpPayloadType) {
299 RtpTransport transport(kMuxDisabled);
300 rtc::FakePacketTransport fake_rtp("fake_rtp");
301 fake_rtp.SetDestination(&fake_rtp, true);
302 transport.SetRtpPacketTransport(&fake_rtp);
303 TransportObserver observer(&transport);
304 RtpDemuxerCriteria demuxer_criteria;
305 // Add an unhandled payload type.
306 demuxer_criteria.payload_types().insert(0x12);
307 transport.RegisterRtpDemuxerSink(demuxer_criteria, &observer);
308
309 const rtc::PacketOptions options;
310 const int flags = 0;
311 rtc::Buffer rtp_data(kRtpData, kRtpLen);
312 fake_rtp.SendPacket(rtp_data.data<char>(), kRtpLen, options, flags);
313 EXPECT_EQ(0, observer.rtp_count());
314 EXPECT_EQ(0, observer.rtcp_count());
315 // Remove the sink before destroying the transport.
316 transport.UnregisterRtpDemuxerSink(&observer);
317 }
318
319 } // namespace webrtc
320