1 /*
2 * Copyright 2019 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 "test/network/network_emulation.h"
12
13 #include <atomic>
14 #include <memory>
15 #include <set>
16
17 #include "api/test/simulated_network.h"
18 #include "api/units/time_delta.h"
19 #include "call/simulated_network.h"
20 #include "rtc_base/event.h"
21 #include "rtc_base/gunit.h"
22 #include "rtc_base/synchronization/mutex.h"
23 #include "rtc_base/task_queue_for_test.h"
24 #include "test/gmock.h"
25 #include "test/gtest.h"
26 #include "test/network/network_emulation_manager.h"
27
28 namespace webrtc {
29 namespace test {
30 namespace {
31
32 using ::testing::ElementsAreArray;
33
34 constexpr TimeDelta kNetworkPacketWaitTimeout = TimeDelta::Millis(100);
35 constexpr TimeDelta kStatsWaitTimeout = TimeDelta::Seconds(1);
36 constexpr int kOverheadIpv4Udp = 20 + 8;
37
38 class SocketReader : public sigslot::has_slots<> {
39 public:
SocketReader(rtc::Socket * socket,rtc::Thread * network_thread)40 explicit SocketReader(rtc::Socket* socket, rtc::Thread* network_thread)
41 : socket_(socket), network_thread_(network_thread) {
42 socket_->SignalReadEvent.connect(this, &SocketReader::OnReadEvent);
43 size_ = 128 * 1024;
44 buf_ = new char[size_];
45 }
~SocketReader()46 ~SocketReader() override { delete[] buf_; }
47
OnReadEvent(rtc::Socket * socket)48 void OnReadEvent(rtc::Socket* socket) {
49 RTC_DCHECK(socket_ == socket);
50 RTC_DCHECK(network_thread_->IsCurrent());
51 int64_t timestamp;
52 len_ = socket_->Recv(buf_, size_, ×tamp);
53
54 MutexLock lock(&lock_);
55 received_count_++;
56 }
57
ReceivedCount()58 int ReceivedCount() {
59 MutexLock lock(&lock_);
60 return received_count_;
61 }
62
63 private:
64 rtc::Socket* const socket_;
65 rtc::Thread* const network_thread_;
66 char* buf_;
67 size_t size_;
68 int len_;
69
70 Mutex lock_;
71 int received_count_ RTC_GUARDED_BY(lock_) = 0;
72 };
73
74 class MockReceiver : public EmulatedNetworkReceiverInterface {
75 public:
76 MOCK_METHOD(void, OnPacketReceived, (EmulatedIpPacket packet), (override));
77 };
78
79 class NetworkEmulationManagerThreeNodesRoutingTest : public ::testing::Test {
80 public:
NetworkEmulationManagerThreeNodesRoutingTest()81 NetworkEmulationManagerThreeNodesRoutingTest() {
82 e1_ = emulation_.CreateEndpoint(EmulatedEndpointConfig());
83 e2_ = emulation_.CreateEndpoint(EmulatedEndpointConfig());
84 e3_ = emulation_.CreateEndpoint(EmulatedEndpointConfig());
85 }
86
SetupRouting(std::function<void (EmulatedEndpoint *,EmulatedEndpoint *,EmulatedEndpoint *,NetworkEmulationManager *)> create_routing_func)87 void SetupRouting(
88 std::function<void(EmulatedEndpoint*,
89 EmulatedEndpoint*,
90 EmulatedEndpoint*,
91 NetworkEmulationManager*)> create_routing_func) {
92 create_routing_func(e1_, e2_, e3_, &emulation_);
93 }
94
SendPacketsAndValidateDelivery()95 void SendPacketsAndValidateDelivery() {
96 EXPECT_CALL(r_e1_e2_, OnPacketReceived(::testing::_)).Times(1);
97 EXPECT_CALL(r_e2_e1_, OnPacketReceived(::testing::_)).Times(1);
98 EXPECT_CALL(r_e1_e3_, OnPacketReceived(::testing::_)).Times(1);
99 EXPECT_CALL(r_e3_e1_, OnPacketReceived(::testing::_)).Times(1);
100
101 uint16_t common_send_port = 80;
102 uint16_t r_e1_e2_port = e2_->BindReceiver(0, &r_e1_e2_).value();
103 uint16_t r_e2_e1_port = e1_->BindReceiver(0, &r_e2_e1_).value();
104 uint16_t r_e1_e3_port = e3_->BindReceiver(0, &r_e1_e3_).value();
105 uint16_t r_e3_e1_port = e1_->BindReceiver(0, &r_e3_e1_).value();
106
107 // Next code is using API of EmulatedEndpoint, that is visible only for
108 // internals of network emulation layer. Don't use this API in other tests.
109 // Send packet from e1 to e2.
110 e1_->SendPacket(
111 rtc::SocketAddress(e1_->GetPeerLocalAddress(), common_send_port),
112 rtc::SocketAddress(e2_->GetPeerLocalAddress(), r_e1_e2_port),
113 rtc::CopyOnWriteBuffer(10));
114
115 // Send packet from e2 to e1.
116 e2_->SendPacket(
117 rtc::SocketAddress(e2_->GetPeerLocalAddress(), common_send_port),
118 rtc::SocketAddress(e1_->GetPeerLocalAddress(), r_e2_e1_port),
119 rtc::CopyOnWriteBuffer(10));
120
121 // Send packet from e1 to e3.
122 e1_->SendPacket(
123 rtc::SocketAddress(e1_->GetPeerLocalAddress(), common_send_port),
124 rtc::SocketAddress(e3_->GetPeerLocalAddress(), r_e1_e3_port),
125 rtc::CopyOnWriteBuffer(10));
126
127 // Send packet from e3 to e1.
128 e3_->SendPacket(
129 rtc::SocketAddress(e3_->GetPeerLocalAddress(), common_send_port),
130 rtc::SocketAddress(e1_->GetPeerLocalAddress(), r_e3_e1_port),
131 rtc::CopyOnWriteBuffer(10));
132
133 // Sleep at the end to wait for async packets delivery.
134 emulation_.time_controller()->AdvanceTime(kNetworkPacketWaitTimeout);
135 }
136
137 private:
138 // Receivers: r_<source endpoint>_<destination endpoint>
139 // They must be destroyed after emulation, so they should be declared before.
140 MockReceiver r_e1_e2_;
141 MockReceiver r_e2_e1_;
142 MockReceiver r_e1_e3_;
143 MockReceiver r_e3_e1_;
144
145 NetworkEmulationManagerImpl emulation_{
146 TimeMode::kRealTime, EmulatedNetworkStatsGatheringMode::kDefault};
147 EmulatedEndpoint* e1_;
148 EmulatedEndpoint* e2_;
149 EmulatedEndpoint* e3_;
150 };
151
CreateEmulatedNodeWithDefaultBuiltInConfig(NetworkEmulationManager * emulation)152 EmulatedNetworkNode* CreateEmulatedNodeWithDefaultBuiltInConfig(
153 NetworkEmulationManager* emulation) {
154 return emulation->CreateEmulatedNode(
155 std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig()));
156 }
157
158 } // namespace
159
160 using ::testing::_;
161
TEST(NetworkEmulationManagerTest,GeneratedIpv4AddressDoesNotCollide)162 TEST(NetworkEmulationManagerTest, GeneratedIpv4AddressDoesNotCollide) {
163 NetworkEmulationManagerImpl network_manager(
164 TimeMode::kRealTime, EmulatedNetworkStatsGatheringMode::kDefault);
165 std::set<rtc::IPAddress> ips;
166 EmulatedEndpointConfig config;
167 config.generated_ip_family = EmulatedEndpointConfig::IpAddressFamily::kIpv4;
168 for (int i = 0; i < 1000; i++) {
169 EmulatedEndpoint* endpoint = network_manager.CreateEndpoint(config);
170 ASSERT_EQ(endpoint->GetPeerLocalAddress().family(), AF_INET);
171 bool result = ips.insert(endpoint->GetPeerLocalAddress()).second;
172 ASSERT_TRUE(result);
173 }
174 }
175
TEST(NetworkEmulationManagerTest,GeneratedIpv6AddressDoesNotCollide)176 TEST(NetworkEmulationManagerTest, GeneratedIpv6AddressDoesNotCollide) {
177 NetworkEmulationManagerImpl network_manager(
178 TimeMode::kRealTime, EmulatedNetworkStatsGatheringMode::kDefault);
179 std::set<rtc::IPAddress> ips;
180 EmulatedEndpointConfig config;
181 config.generated_ip_family = EmulatedEndpointConfig::IpAddressFamily::kIpv6;
182 for (int i = 0; i < 1000; i++) {
183 EmulatedEndpoint* endpoint = network_manager.CreateEndpoint(config);
184 ASSERT_EQ(endpoint->GetPeerLocalAddress().family(), AF_INET6);
185 bool result = ips.insert(endpoint->GetPeerLocalAddress()).second;
186 ASSERT_TRUE(result);
187 }
188 }
189
TEST(NetworkEmulationManagerTest,Run)190 TEST(NetworkEmulationManagerTest, Run) {
191 NetworkEmulationManagerImpl network_manager(
192 TimeMode::kRealTime, EmulatedNetworkStatsGatheringMode::kDefault);
193
194 EmulatedNetworkNode* alice_node = network_manager.CreateEmulatedNode(
195 std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig()));
196 EmulatedNetworkNode* bob_node = network_manager.CreateEmulatedNode(
197 std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig()));
198 EmulatedEndpoint* alice_endpoint =
199 network_manager.CreateEndpoint(EmulatedEndpointConfig());
200 EmulatedEndpoint* bob_endpoint =
201 network_manager.CreateEndpoint(EmulatedEndpointConfig());
202 network_manager.CreateRoute(alice_endpoint, {alice_node}, bob_endpoint);
203 network_manager.CreateRoute(bob_endpoint, {bob_node}, alice_endpoint);
204
205 EmulatedNetworkManagerInterface* nt1 =
206 network_manager.CreateEmulatedNetworkManagerInterface({alice_endpoint});
207 EmulatedNetworkManagerInterface* nt2 =
208 network_manager.CreateEmulatedNetworkManagerInterface({bob_endpoint});
209
210 rtc::Thread* t1 = nt1->network_thread();
211 rtc::Thread* t2 = nt2->network_thread();
212
213 rtc::CopyOnWriteBuffer data("Hello");
214 for (uint64_t j = 0; j < 2; j++) {
215 rtc::Socket* s1 = nullptr;
216 rtc::Socket* s2 = nullptr;
217 SendTask(t1, [&] {
218 s1 = t1->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM);
219 });
220 SendTask(t2, [&] {
221 s2 = t2->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM);
222 });
223
224 SocketReader r1(s1, t1);
225 SocketReader r2(s2, t2);
226
227 rtc::SocketAddress a1(alice_endpoint->GetPeerLocalAddress(), 0);
228 rtc::SocketAddress a2(bob_endpoint->GetPeerLocalAddress(), 0);
229
230 SendTask(t1, [&] {
231 s1->Bind(a1);
232 a1 = s1->GetLocalAddress();
233 });
234 SendTask(t2, [&] {
235 s2->Bind(a2);
236 a2 = s2->GetLocalAddress();
237 });
238
239 SendTask(t1, [&] { s1->Connect(a2); });
240 SendTask(t2, [&] { s2->Connect(a1); });
241
242 for (uint64_t i = 0; i < 1000; i++) {
243 t1->PostTask([&]() { s1->Send(data.data(), data.size()); });
244 t2->PostTask([&]() { s2->Send(data.data(), data.size()); });
245 }
246
247 network_manager.time_controller()->AdvanceTime(TimeDelta::Seconds(1));
248
249 EXPECT_EQ(r1.ReceivedCount(), 1000);
250 EXPECT_EQ(r2.ReceivedCount(), 1000);
251
252 SendTask(t1, [&] { delete s1; });
253 SendTask(t2, [&] { delete s2; });
254 }
255
256 const int64_t single_packet_size = data.size() + kOverheadIpv4Udp;
257 std::atomic<int> received_stats_count{0};
258 nt1->GetStats([&](EmulatedNetworkStats st) {
259 EXPECT_EQ(st.PacketsSent(), 2000l);
260 EXPECT_EQ(st.BytesSent().bytes(), single_packet_size * 2000l);
261 EXPECT_THAT(st.local_addresses,
262 ElementsAreArray({alice_endpoint->GetPeerLocalAddress()}));
263 EXPECT_EQ(st.PacketsReceived(), 2000l);
264 EXPECT_EQ(st.BytesReceived().bytes(), single_packet_size * 2000l);
265 EXPECT_EQ(st.PacketsDiscardedNoReceiver(), 0l);
266 EXPECT_EQ(st.BytesDiscardedNoReceiver().bytes(), 0l);
267
268 rtc::IPAddress bob_ip = bob_endpoint->GetPeerLocalAddress();
269 std::map<rtc::IPAddress, EmulatedNetworkIncomingStats> source_st =
270 st.incoming_stats_per_source;
271 ASSERT_EQ(source_st.size(), 1lu);
272 EXPECT_EQ(source_st.at(bob_ip).packets_received, 2000l);
273 EXPECT_EQ(source_st.at(bob_ip).bytes_received.bytes(),
274 single_packet_size * 2000l);
275 EXPECT_EQ(source_st.at(bob_ip).packets_discarded_no_receiver, 0l);
276 EXPECT_EQ(source_st.at(bob_ip).bytes_discarded_no_receiver.bytes(), 0l);
277
278 std::map<rtc::IPAddress, EmulatedNetworkOutgoingStats> dest_st =
279 st.outgoing_stats_per_destination;
280 ASSERT_EQ(dest_st.size(), 1lu);
281 EXPECT_EQ(dest_st.at(bob_ip).packets_sent, 2000l);
282 EXPECT_EQ(dest_st.at(bob_ip).bytes_sent.bytes(),
283 single_packet_size * 2000l);
284
285 // No debug stats are collected by default.
286 EXPECT_TRUE(st.SentPacketsSizeCounter().IsEmpty());
287 EXPECT_TRUE(st.sent_packets_queue_wait_time_us.IsEmpty());
288 EXPECT_TRUE(st.ReceivedPacketsSizeCounter().IsEmpty());
289 EXPECT_TRUE(st.PacketsDiscardedNoReceiverSizeCounter().IsEmpty());
290 EXPECT_TRUE(dest_st.at(bob_ip).sent_packets_size.IsEmpty());
291 EXPECT_TRUE(source_st.at(bob_ip).received_packets_size.IsEmpty());
292 EXPECT_TRUE(
293 source_st.at(bob_ip).packets_discarded_no_receiver_size.IsEmpty());
294
295 received_stats_count++;
296 });
297 nt2->GetStats([&](EmulatedNetworkStats st) {
298 EXPECT_EQ(st.PacketsSent(), 2000l);
299 EXPECT_EQ(st.BytesSent().bytes(), single_packet_size * 2000l);
300 EXPECT_THAT(st.local_addresses,
301 ElementsAreArray({bob_endpoint->GetPeerLocalAddress()}));
302 EXPECT_EQ(st.PacketsReceived(), 2000l);
303 EXPECT_EQ(st.BytesReceived().bytes(), single_packet_size * 2000l);
304 EXPECT_EQ(st.PacketsDiscardedNoReceiver(), 0l);
305 EXPECT_EQ(st.BytesDiscardedNoReceiver().bytes(), 0l);
306 EXPECT_GT(st.FirstReceivedPacketSize(), DataSize::Zero());
307 EXPECT_TRUE(st.FirstPacketReceivedTime().IsFinite());
308 EXPECT_TRUE(st.LastPacketReceivedTime().IsFinite());
309
310 rtc::IPAddress alice_ip = alice_endpoint->GetPeerLocalAddress();
311 std::map<rtc::IPAddress, EmulatedNetworkIncomingStats> source_st =
312 st.incoming_stats_per_source;
313 ASSERT_EQ(source_st.size(), 1lu);
314 EXPECT_EQ(source_st.at(alice_ip).packets_received, 2000l);
315 EXPECT_EQ(source_st.at(alice_ip).bytes_received.bytes(),
316 single_packet_size * 2000l);
317 EXPECT_EQ(source_st.at(alice_ip).packets_discarded_no_receiver, 0l);
318 EXPECT_EQ(source_st.at(alice_ip).bytes_discarded_no_receiver.bytes(), 0l);
319
320 std::map<rtc::IPAddress, EmulatedNetworkOutgoingStats> dest_st =
321 st.outgoing_stats_per_destination;
322 ASSERT_EQ(dest_st.size(), 1lu);
323 EXPECT_EQ(dest_st.at(alice_ip).packets_sent, 2000l);
324 EXPECT_EQ(dest_st.at(alice_ip).bytes_sent.bytes(),
325 single_packet_size * 2000l);
326
327 // No debug stats are collected by default.
328 EXPECT_TRUE(st.SentPacketsSizeCounter().IsEmpty());
329 EXPECT_TRUE(st.sent_packets_queue_wait_time_us.IsEmpty());
330 EXPECT_TRUE(st.ReceivedPacketsSizeCounter().IsEmpty());
331 EXPECT_TRUE(st.PacketsDiscardedNoReceiverSizeCounter().IsEmpty());
332 EXPECT_TRUE(dest_st.at(alice_ip).sent_packets_size.IsEmpty());
333 EXPECT_TRUE(source_st.at(alice_ip).received_packets_size.IsEmpty());
334 EXPECT_TRUE(
335 source_st.at(alice_ip).packets_discarded_no_receiver_size.IsEmpty());
336
337 received_stats_count++;
338 });
339 ASSERT_EQ_SIMULATED_WAIT(received_stats_count.load(), 2,
340 kStatsWaitTimeout.ms(),
341 *network_manager.time_controller());
342 }
343
TEST(NetworkEmulationManagerTest,DebugStatsCollectedInDebugMode)344 TEST(NetworkEmulationManagerTest, DebugStatsCollectedInDebugMode) {
345 NetworkEmulationManagerImpl network_manager(
346 TimeMode::kSimulated, EmulatedNetworkStatsGatheringMode::kDebug);
347
348 EmulatedNetworkNode* alice_node = network_manager.CreateEmulatedNode(
349 std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig()));
350 EmulatedNetworkNode* bob_node = network_manager.CreateEmulatedNode(
351 std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig()));
352 EmulatedEndpoint* alice_endpoint =
353 network_manager.CreateEndpoint(EmulatedEndpointConfig());
354 EmulatedEndpoint* bob_endpoint =
355 network_manager.CreateEndpoint(EmulatedEndpointConfig());
356 network_manager.CreateRoute(alice_endpoint, {alice_node}, bob_endpoint);
357 network_manager.CreateRoute(bob_endpoint, {bob_node}, alice_endpoint);
358
359 EmulatedNetworkManagerInterface* nt1 =
360 network_manager.CreateEmulatedNetworkManagerInterface({alice_endpoint});
361 EmulatedNetworkManagerInterface* nt2 =
362 network_manager.CreateEmulatedNetworkManagerInterface({bob_endpoint});
363
364 rtc::Thread* t1 = nt1->network_thread();
365 rtc::Thread* t2 = nt2->network_thread();
366
367 rtc::CopyOnWriteBuffer data("Hello");
368 for (uint64_t j = 0; j < 2; j++) {
369 rtc::Socket* s1 = nullptr;
370 rtc::Socket* s2 = nullptr;
371 SendTask(t1, [&] {
372 s1 = t1->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM);
373 });
374 SendTask(t2, [&] {
375 s2 = t2->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM);
376 });
377
378 SocketReader r1(s1, t1);
379 SocketReader r2(s2, t2);
380
381 rtc::SocketAddress a1(alice_endpoint->GetPeerLocalAddress(), 0);
382 rtc::SocketAddress a2(bob_endpoint->GetPeerLocalAddress(), 0);
383
384 SendTask(t1, [&] {
385 s1->Bind(a1);
386 a1 = s1->GetLocalAddress();
387 });
388 SendTask(t2, [&] {
389 s2->Bind(a2);
390 a2 = s2->GetLocalAddress();
391 });
392
393 SendTask(t1, [&] { s1->Connect(a2); });
394 SendTask(t2, [&] { s2->Connect(a1); });
395
396 for (uint64_t i = 0; i < 1000; i++) {
397 t1->PostTask([&]() { s1->Send(data.data(), data.size()); });
398 t2->PostTask([&]() { s2->Send(data.data(), data.size()); });
399 }
400
401 network_manager.time_controller()->AdvanceTime(TimeDelta::Seconds(1));
402
403 EXPECT_EQ(r1.ReceivedCount(), 1000);
404 EXPECT_EQ(r2.ReceivedCount(), 1000);
405
406 SendTask(t1, [&] { delete s1; });
407 SendTask(t2, [&] { delete s2; });
408 }
409
410 const int64_t single_packet_size = data.size() + kOverheadIpv4Udp;
411 std::atomic<int> received_stats_count{0};
412 nt1->GetStats([&](EmulatedNetworkStats st) {
413 rtc::IPAddress bob_ip = bob_endpoint->GetPeerLocalAddress();
414 std::map<rtc::IPAddress, EmulatedNetworkIncomingStats> source_st =
415 st.incoming_stats_per_source;
416 ASSERT_EQ(source_st.size(), 1lu);
417
418 std::map<rtc::IPAddress, EmulatedNetworkOutgoingStats> dest_st =
419 st.outgoing_stats_per_destination;
420 ASSERT_EQ(dest_st.size(), 1lu);
421
422 // No debug stats are collected by default.
423 EXPECT_EQ(st.SentPacketsSizeCounter().NumSamples(), 2000l);
424 EXPECT_EQ(st.ReceivedPacketsSizeCounter().GetAverage(), single_packet_size);
425 EXPECT_EQ(st.sent_packets_queue_wait_time_us.NumSamples(), 2000l);
426 EXPECT_LT(st.sent_packets_queue_wait_time_us.GetMax(), 1);
427 EXPECT_TRUE(st.PacketsDiscardedNoReceiverSizeCounter().IsEmpty());
428 EXPECT_EQ(dest_st.at(bob_ip).sent_packets_size.NumSamples(), 2000l);
429 EXPECT_EQ(dest_st.at(bob_ip).sent_packets_size.GetAverage(),
430 single_packet_size);
431 EXPECT_EQ(source_st.at(bob_ip).received_packets_size.NumSamples(), 2000l);
432 EXPECT_EQ(source_st.at(bob_ip).received_packets_size.GetAverage(),
433 single_packet_size);
434 EXPECT_TRUE(
435 source_st.at(bob_ip).packets_discarded_no_receiver_size.IsEmpty());
436
437 received_stats_count++;
438 });
439 ASSERT_EQ_SIMULATED_WAIT(received_stats_count.load(), 1,
440 kStatsWaitTimeout.ms(),
441 *network_manager.time_controller());
442 }
443
TEST(NetworkEmulationManagerTest,ThroughputStats)444 TEST(NetworkEmulationManagerTest, ThroughputStats) {
445 NetworkEmulationManagerImpl network_manager(
446 TimeMode::kRealTime, EmulatedNetworkStatsGatheringMode::kDefault);
447
448 EmulatedNetworkNode* alice_node = network_manager.CreateEmulatedNode(
449 std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig()));
450 EmulatedNetworkNode* bob_node = network_manager.CreateEmulatedNode(
451 std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig()));
452 EmulatedEndpoint* alice_endpoint =
453 network_manager.CreateEndpoint(EmulatedEndpointConfig());
454 EmulatedEndpoint* bob_endpoint =
455 network_manager.CreateEndpoint(EmulatedEndpointConfig());
456 network_manager.CreateRoute(alice_endpoint, {alice_node}, bob_endpoint);
457 network_manager.CreateRoute(bob_endpoint, {bob_node}, alice_endpoint);
458
459 EmulatedNetworkManagerInterface* nt1 =
460 network_manager.CreateEmulatedNetworkManagerInterface({alice_endpoint});
461 EmulatedNetworkManagerInterface* nt2 =
462 network_manager.CreateEmulatedNetworkManagerInterface({bob_endpoint});
463
464 rtc::Thread* t1 = nt1->network_thread();
465 rtc::Thread* t2 = nt2->network_thread();
466
467 constexpr int64_t kUdpPayloadSize = 100;
468 constexpr int64_t kSinglePacketSize = kUdpPayloadSize + kOverheadIpv4Udp;
469 rtc::CopyOnWriteBuffer data(kUdpPayloadSize);
470
471 rtc::Socket* s1 = nullptr;
472 rtc::Socket* s2 = nullptr;
473 SendTask(t1,
474 [&] { s1 = t1->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM); });
475 SendTask(t2,
476 [&] { s2 = t2->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM); });
477
478 SocketReader r1(s1, t1);
479 SocketReader r2(s2, t2);
480
481 rtc::SocketAddress a1(alice_endpoint->GetPeerLocalAddress(), 0);
482 rtc::SocketAddress a2(bob_endpoint->GetPeerLocalAddress(), 0);
483
484 SendTask(t1, [&] {
485 s1->Bind(a1);
486 a1 = s1->GetLocalAddress();
487 });
488 SendTask(t2, [&] {
489 s2->Bind(a2);
490 a2 = s2->GetLocalAddress();
491 });
492
493 SendTask(t1, [&] { s1->Connect(a2); });
494 SendTask(t2, [&] { s2->Connect(a1); });
495
496 // Send 11 packets, totalizing 1 second between the first and the last->
497 const int kNumPacketsSent = 11;
498 const TimeDelta kDelay = TimeDelta::Millis(100);
499 for (int i = 0; i < kNumPacketsSent; i++) {
500 t1->PostTask([&]() { s1->Send(data.data(), data.size()); });
501 t2->PostTask([&]() { s2->Send(data.data(), data.size()); });
502 network_manager.time_controller()->AdvanceTime(kDelay);
503 }
504
505 std::atomic<int> received_stats_count{0};
506 nt1->GetStats([&](EmulatedNetworkStats st) {
507 EXPECT_EQ(st.PacketsSent(), kNumPacketsSent);
508 EXPECT_EQ(st.BytesSent().bytes(), kSinglePacketSize * kNumPacketsSent);
509
510 const double tolerance = 0.95; // Accept 5% tolerance for timing.
511 EXPECT_GE(st.LastPacketSentTime() - st.FirstPacketSentTime(),
512 (kNumPacketsSent - 1) * kDelay * tolerance);
513 EXPECT_GT(st.AverageSendRate().bps(), 0);
514 received_stats_count++;
515 });
516
517 ASSERT_EQ_SIMULATED_WAIT(received_stats_count.load(), 1,
518 kStatsWaitTimeout.ms(),
519 *network_manager.time_controller());
520
521 EXPECT_EQ(r1.ReceivedCount(), 11);
522 EXPECT_EQ(r2.ReceivedCount(), 11);
523
524 SendTask(t1, [&] { delete s1; });
525 SendTask(t2, [&] { delete s2; });
526 }
527
528 // Testing that packets are delivered via all routes using a routing scheme as
529 // follows:
530 // * e1 -> n1 -> e2
531 // * e2 -> n2 -> e1
532 // * e1 -> n3 -> e3
533 // * e3 -> n4 -> e1
TEST_F(NetworkEmulationManagerThreeNodesRoutingTest,PacketsAreDeliveredInBothWaysWhenConnectedToTwoPeers)534 TEST_F(NetworkEmulationManagerThreeNodesRoutingTest,
535 PacketsAreDeliveredInBothWaysWhenConnectedToTwoPeers) {
536 SetupRouting([](EmulatedEndpoint* e1, EmulatedEndpoint* e2,
537 EmulatedEndpoint* e3, NetworkEmulationManager* emulation) {
538 auto* node1 = CreateEmulatedNodeWithDefaultBuiltInConfig(emulation);
539 auto* node2 = CreateEmulatedNodeWithDefaultBuiltInConfig(emulation);
540 auto* node3 = CreateEmulatedNodeWithDefaultBuiltInConfig(emulation);
541 auto* node4 = CreateEmulatedNodeWithDefaultBuiltInConfig(emulation);
542
543 emulation->CreateRoute(e1, {node1}, e2);
544 emulation->CreateRoute(e2, {node2}, e1);
545
546 emulation->CreateRoute(e1, {node3}, e3);
547 emulation->CreateRoute(e3, {node4}, e1);
548 });
549 SendPacketsAndValidateDelivery();
550 }
551
552 // Testing that packets are delivered via all routes using a routing scheme as
553 // follows:
554 // * e1 -> n1 -> e2
555 // * e2 -> n2 -> e1
556 // * e1 -> n1 -> e3
557 // * e3 -> n4 -> e1
TEST_F(NetworkEmulationManagerThreeNodesRoutingTest,PacketsAreDeliveredInBothWaysWhenConnectedToTwoPeersOverSameSendLink)558 TEST_F(NetworkEmulationManagerThreeNodesRoutingTest,
559 PacketsAreDeliveredInBothWaysWhenConnectedToTwoPeersOverSameSendLink) {
560 SetupRouting([](EmulatedEndpoint* e1, EmulatedEndpoint* e2,
561 EmulatedEndpoint* e3, NetworkEmulationManager* emulation) {
562 auto* node1 = CreateEmulatedNodeWithDefaultBuiltInConfig(emulation);
563 auto* node2 = CreateEmulatedNodeWithDefaultBuiltInConfig(emulation);
564 auto* node3 = CreateEmulatedNodeWithDefaultBuiltInConfig(emulation);
565
566 emulation->CreateRoute(e1, {node1}, e2);
567 emulation->CreateRoute(e2, {node2}, e1);
568
569 emulation->CreateRoute(e1, {node1}, e3);
570 emulation->CreateRoute(e3, {node3}, e1);
571 });
572 SendPacketsAndValidateDelivery();
573 }
574
TEST(NetworkEmulationManagerTest,EndpointLoopback)575 TEST(NetworkEmulationManagerTest, EndpointLoopback) {
576 NetworkEmulationManagerImpl network_manager(
577 TimeMode::kSimulated, EmulatedNetworkStatsGatheringMode::kDefault);
578 auto endpoint = network_manager.CreateEndpoint(EmulatedEndpointConfig());
579
580 MockReceiver receiver;
581 EXPECT_CALL(receiver, OnPacketReceived(::testing::_)).Times(1);
582 ASSERT_EQ(endpoint->BindReceiver(80, &receiver), 80);
583
584 endpoint->SendPacket(rtc::SocketAddress(endpoint->GetPeerLocalAddress(), 80),
585 rtc::SocketAddress(endpoint->GetPeerLocalAddress(), 80),
586 "Hello");
587 network_manager.time_controller()->AdvanceTime(TimeDelta::Seconds(1));
588 }
589
TEST(NetworkEmulationManagerTest,EndpointCanSendWithDifferentSourceIp)590 TEST(NetworkEmulationManagerTest, EndpointCanSendWithDifferentSourceIp) {
591 constexpr uint32_t kEndpointIp = 0xC0A80011; // 192.168.0.17
592 constexpr uint32_t kSourceIp = 0xC0A80012; // 192.168.0.18
593 NetworkEmulationManagerImpl network_manager(
594 TimeMode::kSimulated, EmulatedNetworkStatsGatheringMode::kDefault);
595 EmulatedEndpointConfig endpoint_config;
596 endpoint_config.ip = rtc::IPAddress(kEndpointIp);
597 endpoint_config.allow_send_packet_with_different_source_ip = true;
598 auto endpoint = network_manager.CreateEndpoint(endpoint_config);
599
600 MockReceiver receiver;
601 EXPECT_CALL(receiver, OnPacketReceived(::testing::_)).Times(1);
602 ASSERT_EQ(endpoint->BindReceiver(80, &receiver), 80);
603
604 endpoint->SendPacket(rtc::SocketAddress(kSourceIp, 80),
605 rtc::SocketAddress(endpoint->GetPeerLocalAddress(), 80),
606 "Hello");
607 network_manager.time_controller()->AdvanceTime(TimeDelta::Seconds(1));
608 }
609
TEST(NetworkEmulationManagerTest,EndpointCanReceiveWithDifferentDestIpThroughDefaultRoute)610 TEST(NetworkEmulationManagerTest,
611 EndpointCanReceiveWithDifferentDestIpThroughDefaultRoute) {
612 constexpr uint32_t kDestEndpointIp = 0xC0A80011; // 192.168.0.17
613 constexpr uint32_t kDestIp = 0xC0A80012; // 192.168.0.18
614 NetworkEmulationManagerImpl network_manager(
615 TimeMode::kSimulated, EmulatedNetworkStatsGatheringMode::kDefault);
616 auto sender_endpoint =
617 network_manager.CreateEndpoint(EmulatedEndpointConfig());
618 EmulatedEndpointConfig endpoint_config;
619 endpoint_config.ip = rtc::IPAddress(kDestEndpointIp);
620 endpoint_config.allow_receive_packets_with_different_dest_ip = true;
621 auto receiver_endpoint = network_manager.CreateEndpoint(endpoint_config);
622
623 MockReceiver receiver;
624 EXPECT_CALL(receiver, OnPacketReceived(::testing::_)).Times(1);
625 ASSERT_EQ(receiver_endpoint->BindReceiver(80, &receiver), 80);
626
627 network_manager.CreateDefaultRoute(
628 sender_endpoint, {network_manager.NodeBuilder().Build().node},
629 receiver_endpoint);
630
631 sender_endpoint->SendPacket(
632 rtc::SocketAddress(sender_endpoint->GetPeerLocalAddress(), 80),
633 rtc::SocketAddress(kDestIp, 80), "Hello");
634 network_manager.time_controller()->AdvanceTime(TimeDelta::Seconds(1));
635 }
636
TEST(NetworkEmulationManagerTURNTest,GetIceServerConfig)637 TEST(NetworkEmulationManagerTURNTest, GetIceServerConfig) {
638 NetworkEmulationManagerImpl network_manager(
639 TimeMode::kRealTime, EmulatedNetworkStatsGatheringMode::kDefault);
640 auto turn = network_manager.CreateTURNServer(EmulatedTURNServerConfig());
641
642 EXPECT_GT(turn->GetIceServerConfig().username.size(), 0u);
643 EXPECT_GT(turn->GetIceServerConfig().password.size(), 0u);
644 EXPECT_NE(turn->GetIceServerConfig().url.find(
645 turn->GetClientEndpoint()->GetPeerLocalAddress().ToString()),
646 std::string::npos);
647 }
648
TEST(NetworkEmulationManagerTURNTest,ClientTraffic)649 TEST(NetworkEmulationManagerTURNTest, ClientTraffic) {
650 NetworkEmulationManagerImpl emulation(
651 TimeMode::kSimulated, EmulatedNetworkStatsGatheringMode::kDefault);
652 auto* ep = emulation.CreateEndpoint(EmulatedEndpointConfig());
653 auto* turn = emulation.CreateTURNServer(EmulatedTURNServerConfig());
654 auto* node = CreateEmulatedNodeWithDefaultBuiltInConfig(&emulation);
655 emulation.CreateRoute(ep, {node}, turn->GetClientEndpoint());
656 emulation.CreateRoute(turn->GetClientEndpoint(), {node}, ep);
657
658 MockReceiver recv;
659 int port = ep->BindReceiver(0, &recv).value();
660
661 // Construct a STUN BINDING.
662 cricket::StunMessage ping(cricket::STUN_BINDING_REQUEST);
663 rtc::ByteBufferWriter buf;
664 ping.Write(&buf);
665 rtc::CopyOnWriteBuffer packet(buf.Data(), buf.Length());
666
667 // We expect to get a ping reply.
668 EXPECT_CALL(recv, OnPacketReceived(::testing::_)).Times(1);
669
670 ep->SendPacket(rtc::SocketAddress(ep->GetPeerLocalAddress(), port),
671 turn->GetClientEndpointAddress(), packet);
672 emulation.time_controller()->AdvanceTime(TimeDelta::Seconds(1));
673 }
674
675 } // namespace test
676 } // namespace webrtc
677