1 /*
2  *  Copyright 2006 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 <math.h>
12 #include <time.h>
13 #if defined(WEBRTC_POSIX)
14 #include <netinet/in.h>
15 #endif
16 
17 #include <memory>
18 
19 #include "rtc_base/arraysize.h"
20 #include "rtc_base/fakeclock.h"
21 #include "rtc_base/gunit.h"
22 #include "rtc_base/logging.h"
23 #include "rtc_base/ptr_util.h"
24 #include "rtc_base/testclient.h"
25 #include "rtc_base/testutils.h"
26 #include "rtc_base/thread.h"
27 #include "rtc_base/timeutils.h"
28 #include "rtc_base/virtualsocketserver.h"
29 
30 using namespace rtc;
31 
32 using webrtc::testing::SSE_CLOSE;
33 using webrtc::testing::SSE_ERROR;
34 using webrtc::testing::SSE_OPEN;
35 using webrtc::testing::SSE_READ;
36 using webrtc::testing::SSE_WRITE;
37 using webrtc::testing::StreamSink;
38 
39 // Sends at a constant rate but with random packet sizes.
40 struct Sender : public MessageHandler {
SenderSender41   Sender(Thread* th, AsyncSocket* s, uint32_t rt)
42       : thread(th),
43         socket(MakeUnique<AsyncUDPSocket>(s)),
44         done(false),
45         rate(rt),
46         count(0) {
47     last_send = rtc::TimeMillis();
48     thread->PostDelayed(RTC_FROM_HERE, NextDelay(), this, 1);
49   }
50 
NextDelaySender51   uint32_t NextDelay() {
52     uint32_t size = (rand() % 4096) + 1;
53     return 1000 * size / rate;
54   }
55 
OnMessageSender56   void OnMessage(Message* pmsg) override {
57     ASSERT_EQ(1u, pmsg->message_id);
58 
59     if (done)
60       return;
61 
62     int64_t cur_time = rtc::TimeMillis();
63     int64_t delay = cur_time - last_send;
64     uint32_t size = static_cast<uint32_t>(rate * delay / 1000);
65     size = std::min<uint32_t>(size, 4096);
66     size = std::max<uint32_t>(size, sizeof(uint32_t));
67 
68     count += size;
69     memcpy(dummy, &cur_time, sizeof(cur_time));
70     socket->Send(dummy, size, options);
71 
72     last_send = cur_time;
73     thread->PostDelayed(RTC_FROM_HERE, NextDelay(), this, 1);
74   }
75 
76   Thread* thread;
77   std::unique_ptr<AsyncUDPSocket> socket;
78   rtc::PacketOptions options;
79   bool done;
80   uint32_t rate;  // bytes per second
81   uint32_t count;
82   int64_t last_send;
83   char dummy[4096];
84 };
85 
86 struct Receiver : public MessageHandler, public sigslot::has_slots<> {
ReceiverReceiver87   Receiver(Thread* th, AsyncSocket* s, uint32_t bw)
88       : thread(th),
89         socket(MakeUnique<AsyncUDPSocket>(s)),
90         bandwidth(bw),
91         done(false),
92         count(0),
93         sec_count(0),
94         sum(0),
95         sum_sq(0),
96         samples(0) {
97     socket->SignalReadPacket.connect(this, &Receiver::OnReadPacket);
98     thread->PostDelayed(RTC_FROM_HERE, 1000, this, 1);
99   }
100 
~ReceiverReceiver101   ~Receiver() override { thread->Clear(this); }
102 
OnReadPacketReceiver103   void OnReadPacket(AsyncPacketSocket* s, const char* data, size_t size,
104                     const SocketAddress& remote_addr,
105                     const PacketTime& packet_time) {
106     ASSERT_EQ(socket.get(), s);
107     ASSERT_GE(size, 4U);
108 
109     count += size;
110     sec_count += size;
111 
112     uint32_t send_time = *reinterpret_cast<const uint32_t*>(data);
113     uint32_t recv_time = rtc::TimeMillis();
114     uint32_t delay = recv_time - send_time;
115     sum += delay;
116     sum_sq += delay * delay;
117     samples += 1;
118   }
119 
OnMessageReceiver120   void OnMessage(Message* pmsg) override {
121     ASSERT_EQ(1u, pmsg->message_id);
122 
123     if (done)
124       return;
125 
126     // It is always possible for us to receive more than expected because
127     // packets can be further delayed in delivery.
128     if (bandwidth > 0)
129       ASSERT_TRUE(sec_count <= 5 * bandwidth / 4);
130     sec_count = 0;
131     thread->PostDelayed(RTC_FROM_HERE, 1000, this, 1);
132   }
133 
134   Thread* thread;
135   std::unique_ptr<AsyncUDPSocket> socket;
136   uint32_t bandwidth;
137   bool done;
138   size_t count;
139   size_t sec_count;
140   double sum;
141   double sum_sq;
142   uint32_t samples;
143 };
144 
145 // Note: This test uses a fake clock in addition to a virtual network.
146 class VirtualSocketServerTest : public testing::Test {
147  public:
VirtualSocketServerTest()148   VirtualSocketServerTest()
149       : ss_(&fake_clock_),
150         thread_(&ss_),
151         kIPv4AnyAddress(IPAddress(INADDR_ANY), 0),
152         kIPv6AnyAddress(IPAddress(in6addr_any), 0) {}
153 
CheckPortIncrementalization(const SocketAddress & post,const SocketAddress & pre)154   void CheckPortIncrementalization(const SocketAddress& post,
155                                    const SocketAddress& pre) {
156     EXPECT_EQ(post.port(), pre.port() + 1);
157     IPAddress post_ip = post.ipaddr();
158     IPAddress pre_ip = pre.ipaddr();
159     EXPECT_EQ(pre_ip.family(), post_ip.family());
160     if (post_ip.family() == AF_INET) {
161       in_addr pre_ipv4 = pre_ip.ipv4_address();
162       in_addr post_ipv4 = post_ip.ipv4_address();
163       EXPECT_EQ(post_ipv4.s_addr, pre_ipv4.s_addr);
164     } else if (post_ip.family() == AF_INET6) {
165       in6_addr post_ip6 = post_ip.ipv6_address();
166       in6_addr pre_ip6 = pre_ip.ipv6_address();
167       uint32_t* post_as_ints = reinterpret_cast<uint32_t*>(&post_ip6.s6_addr);
168       uint32_t* pre_as_ints = reinterpret_cast<uint32_t*>(&pre_ip6.s6_addr);
169       EXPECT_EQ(post_as_ints[3], pre_as_ints[3]);
170     }
171   }
172 
173   // Test a client can bind to the any address, and all sent packets will have
174   // the default route as the source address. Also, it can receive packets sent
175   // to the default route.
TestDefaultRoute(const IPAddress & default_route)176   void TestDefaultRoute(const IPAddress& default_route) {
177     ss_.SetDefaultRoute(default_route);
178 
179     // Create client1 bound to the any address.
180     AsyncSocket* socket =
181         ss_.CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
182     socket->Bind(EmptySocketAddressWithFamily(default_route.family()));
183     SocketAddress client1_any_addr = socket->GetLocalAddress();
184     EXPECT_TRUE(client1_any_addr.IsAnyIP());
185     auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket),
186                                           &fake_clock_);
187 
188     // Create client2 bound to the default route.
189     AsyncSocket* socket2 =
190         ss_.CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
191     socket2->Bind(SocketAddress(default_route, 0));
192     SocketAddress client2_addr = socket2->GetLocalAddress();
193     EXPECT_FALSE(client2_addr.IsAnyIP());
194     auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2),
195                                           &fake_clock_);
196 
197     // Client1 sends to client2, client2 should see the default route as
198     // client1's address.
199     SocketAddress client1_addr;
200     EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
201     EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
202     EXPECT_EQ(client1_addr,
203               SocketAddress(default_route, client1_any_addr.port()));
204 
205     // Client2 can send back to client1's default route address.
206     EXPECT_EQ(3, client2->SendTo("foo", 3, client1_addr));
207     EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
208   }
209 
BasicTest(const SocketAddress & initial_addr)210   void BasicTest(const SocketAddress& initial_addr) {
211     AsyncSocket* socket =
212         ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
213     socket->Bind(initial_addr);
214     SocketAddress server_addr = socket->GetLocalAddress();
215     // Make sure VSS didn't switch families on us.
216     EXPECT_EQ(server_addr.family(), initial_addr.family());
217 
218     auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket),
219                                           &fake_clock_);
220     AsyncSocket* socket2 =
221         ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
222     auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2),
223                                           &fake_clock_);
224 
225     SocketAddress client2_addr;
226     EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
227     EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
228 
229     SocketAddress client1_addr;
230     EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
231     EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
232     EXPECT_EQ(client1_addr, server_addr);
233 
234     SocketAddress empty = EmptySocketAddressWithFamily(initial_addr.family());
235     for (int i = 0; i < 10; i++) {
236       client2 = MakeUnique<TestClient>(
237           WrapUnique(AsyncUDPSocket::Create(&ss_, empty)), &fake_clock_);
238 
239       SocketAddress next_client2_addr;
240       EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
241       EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &next_client2_addr));
242       CheckPortIncrementalization(next_client2_addr, client2_addr);
243       // EXPECT_EQ(next_client2_addr.port(), client2_addr.port() + 1);
244 
245       SocketAddress server_addr2;
246       EXPECT_EQ(6, client1->SendTo("bizbaz", 6, next_client2_addr));
247       EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &server_addr2));
248       EXPECT_EQ(server_addr2, server_addr);
249 
250       client2_addr = next_client2_addr;
251     }
252   }
253 
254   // initial_addr should be made from either INADDR_ANY or in6addr_any.
ConnectTest(const SocketAddress & initial_addr)255   void ConnectTest(const SocketAddress& initial_addr) {
256     StreamSink sink;
257     SocketAddress accept_addr;
258     const SocketAddress kEmptyAddr =
259         EmptySocketAddressWithFamily(initial_addr.family());
260 
261     // Create client
262     std::unique_ptr<AsyncSocket> client =
263         WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
264     sink.Monitor(client.get());
265     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
266     EXPECT_TRUE(client->GetLocalAddress().IsNil());
267 
268     // Create server
269     std::unique_ptr<AsyncSocket> server =
270         WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
271     sink.Monitor(server.get());
272     EXPECT_NE(0, server->Listen(5));  // Bind required
273     EXPECT_EQ(0, server->Bind(initial_addr));
274     EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
275     EXPECT_EQ(0, server->Listen(5));
276     EXPECT_EQ(server->GetState(), AsyncSocket::CS_CONNECTING);
277 
278     // No pending server connections
279     EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
280     EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
281     EXPECT_EQ(AF_UNSPEC, accept_addr.family());
282 
283     // Attempt connect to listening socket
284     EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
285     EXPECT_NE(client->GetLocalAddress(), kEmptyAddr);  // Implicit Bind
286     EXPECT_NE(AF_UNSPEC, client->GetLocalAddress().family());  // Implicit Bind
287     EXPECT_NE(client->GetLocalAddress(), server->GetLocalAddress());
288 
289     // Client is connecting
290     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
291     EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
292     EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
293 
294     ss_.ProcessMessagesUntilIdle();
295 
296     // Client still connecting
297     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
298     EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
299     EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
300 
301     // Server has pending connection
302     EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
303     std::unique_ptr<Socket> accepted = WrapUnique(server->Accept(&accept_addr));
304     EXPECT_TRUE(nullptr != accepted);
305     EXPECT_NE(accept_addr, kEmptyAddr);
306     EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
307 
308     EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED);
309     EXPECT_EQ(accepted->GetLocalAddress(), server->GetLocalAddress());
310     EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
311 
312     ss_.ProcessMessagesUntilIdle();
313 
314     // Client has connected
315     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTED);
316     EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
317     EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
318     EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
319     EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
320   }
321 
ConnectToNonListenerTest(const SocketAddress & initial_addr)322   void ConnectToNonListenerTest(const SocketAddress& initial_addr) {
323     StreamSink sink;
324     SocketAddress accept_addr;
325     const SocketAddress nil_addr;
326     const SocketAddress empty_addr =
327         EmptySocketAddressWithFamily(initial_addr.family());
328 
329     // Create client
330     std::unique_ptr<AsyncSocket> client =
331         WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
332     sink.Monitor(client.get());
333 
334     // Create server
335     std::unique_ptr<AsyncSocket> server =
336         WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
337     sink.Monitor(server.get());
338     EXPECT_EQ(0, server->Bind(initial_addr));
339     EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
340     // Attempt connect to non-listening socket
341     EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
342 
343     ss_.ProcessMessagesUntilIdle();
344 
345     // No pending server connections
346     EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
347     EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
348     EXPECT_EQ(accept_addr, nil_addr);
349 
350     // Connection failed
351     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
352     EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
353     EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
354     EXPECT_EQ(client->GetRemoteAddress(), nil_addr);
355   }
356 
CloseDuringConnectTest(const SocketAddress & initial_addr)357   void CloseDuringConnectTest(const SocketAddress& initial_addr) {
358     StreamSink sink;
359     SocketAddress accept_addr;
360     const SocketAddress empty_addr =
361         EmptySocketAddressWithFamily(initial_addr.family());
362 
363     // Create client and server
364     std::unique_ptr<AsyncSocket> client(
365         ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
366     sink.Monitor(client.get());
367     std::unique_ptr<AsyncSocket> server(
368         ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
369     sink.Monitor(server.get());
370 
371     // Initiate connect
372     EXPECT_EQ(0, server->Bind(initial_addr));
373     EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
374 
375     EXPECT_EQ(0, server->Listen(5));
376     EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
377 
378     // Server close before socket enters accept queue
379     EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
380     server->Close();
381 
382     ss_.ProcessMessagesUntilIdle();
383 
384     // Result: connection failed
385     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
386     EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
387 
388     server.reset(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
389     sink.Monitor(server.get());
390 
391     // Initiate connect
392     EXPECT_EQ(0, server->Bind(initial_addr));
393     EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
394 
395     EXPECT_EQ(0, server->Listen(5));
396     EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
397 
398     ss_.ProcessMessagesUntilIdle();
399 
400     // Server close while socket is in accept queue
401     EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
402     server->Close();
403 
404     ss_.ProcessMessagesUntilIdle();
405 
406     // Result: connection failed
407     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
408     EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
409 
410     // New server
411     server.reset(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
412     sink.Monitor(server.get());
413 
414     // Initiate connect
415     EXPECT_EQ(0, server->Bind(initial_addr));
416     EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
417 
418     EXPECT_EQ(0, server->Listen(5));
419     EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
420 
421     ss_.ProcessMessagesUntilIdle();
422 
423     // Server accepts connection
424     EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
425     std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
426     ASSERT_TRUE(nullptr != accepted.get());
427     sink.Monitor(accepted.get());
428 
429     // Client closes before connection complets
430     EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED);
431 
432     // Connected message has not been processed yet.
433     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
434     client->Close();
435 
436     ss_.ProcessMessagesUntilIdle();
437 
438     // Result: accepted socket closes
439     EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CLOSED);
440     EXPECT_TRUE(sink.Check(accepted.get(), SSE_CLOSE));
441     EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
442   }
443 
CloseTest(const SocketAddress & initial_addr)444   void CloseTest(const SocketAddress& initial_addr) {
445     StreamSink sink;
446     const SocketAddress kEmptyAddr;
447 
448     // Create clients
449     std::unique_ptr<AsyncSocket> a =
450         WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
451     sink.Monitor(a.get());
452     a->Bind(initial_addr);
453     EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
454 
455     std::unique_ptr<AsyncSocket> b =
456         WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
457     sink.Monitor(b.get());
458     b->Bind(initial_addr);
459     EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
460 
461     EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
462     EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
463 
464     ss_.ProcessMessagesUntilIdle();
465 
466     EXPECT_TRUE(sink.Check(a.get(), SSE_OPEN));
467     EXPECT_EQ(a->GetState(), AsyncSocket::CS_CONNECTED);
468     EXPECT_EQ(a->GetRemoteAddress(), b->GetLocalAddress());
469 
470     EXPECT_TRUE(sink.Check(b.get(), SSE_OPEN));
471     EXPECT_EQ(b->GetState(), AsyncSocket::CS_CONNECTED);
472     EXPECT_EQ(b->GetRemoteAddress(), a->GetLocalAddress());
473 
474     EXPECT_EQ(1, a->Send("a", 1));
475     b->Close();
476     EXPECT_EQ(1, a->Send("b", 1));
477 
478     ss_.ProcessMessagesUntilIdle();
479 
480     char buffer[10];
481     EXPECT_FALSE(sink.Check(b.get(), SSE_READ));
482     EXPECT_EQ(-1, b->Recv(buffer, 10, nullptr));
483 
484     EXPECT_TRUE(sink.Check(a.get(), SSE_CLOSE));
485     EXPECT_EQ(a->GetState(), AsyncSocket::CS_CLOSED);
486     EXPECT_EQ(a->GetRemoteAddress(), kEmptyAddr);
487 
488     // No signal for Closer
489     EXPECT_FALSE(sink.Check(b.get(), SSE_CLOSE));
490     EXPECT_EQ(b->GetState(), AsyncSocket::CS_CLOSED);
491     EXPECT_EQ(b->GetRemoteAddress(), kEmptyAddr);
492   }
493 
TcpSendTest(const SocketAddress & initial_addr)494   void TcpSendTest(const SocketAddress& initial_addr) {
495     StreamSink sink;
496     const SocketAddress kEmptyAddr;
497 
498     // Connect two sockets
499     std::unique_ptr<AsyncSocket> a =
500         WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
501     sink.Monitor(a.get());
502     a->Bind(initial_addr);
503     EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
504 
505     std::unique_ptr<AsyncSocket> b =
506         WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
507     sink.Monitor(b.get());
508     b->Bind(initial_addr);
509     EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
510 
511     EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
512     EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
513 
514     ss_.ProcessMessagesUntilIdle();
515 
516     const size_t kBufferSize = 2000;
517     ss_.set_send_buffer_capacity(kBufferSize);
518     ss_.set_recv_buffer_capacity(kBufferSize);
519 
520     const size_t kDataSize = 5000;
521     char send_buffer[kDataSize], recv_buffer[kDataSize];
522     for (size_t i = 0; i < kDataSize; ++i)
523       send_buffer[i] = static_cast<char>(i % 256);
524     memset(recv_buffer, 0, sizeof(recv_buffer));
525     size_t send_pos = 0, recv_pos = 0;
526 
527     // Can't send more than send buffer in one write
528     int result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
529     EXPECT_EQ(static_cast<int>(kBufferSize), result);
530     send_pos += result;
531 
532     ss_.ProcessMessagesUntilIdle();
533     EXPECT_FALSE(sink.Check(a.get(), SSE_WRITE));
534     EXPECT_TRUE(sink.Check(b.get(), SSE_READ));
535 
536     // Receive buffer is already filled, fill send buffer again
537     result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
538     EXPECT_EQ(static_cast<int>(kBufferSize), result);
539     send_pos += result;
540 
541     ss_.ProcessMessagesUntilIdle();
542     EXPECT_FALSE(sink.Check(a.get(), SSE_WRITE));
543     EXPECT_FALSE(sink.Check(b.get(), SSE_READ));
544 
545     // No more room in send or receive buffer
546     result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
547     EXPECT_EQ(-1, result);
548     EXPECT_TRUE(a->IsBlocking());
549 
550     // Read a subset of the data
551     result = b->Recv(recv_buffer + recv_pos, 500, nullptr);
552     EXPECT_EQ(500, result);
553     recv_pos += result;
554 
555     ss_.ProcessMessagesUntilIdle();
556     EXPECT_TRUE(sink.Check(a.get(), SSE_WRITE));
557     EXPECT_TRUE(sink.Check(b.get(), SSE_READ));
558 
559     // Room for more on the sending side
560     result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
561     EXPECT_EQ(500, result);
562     send_pos += result;
563 
564     // Empty the recv buffer
565     while (true) {
566       result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos, nullptr);
567       if (result < 0) {
568         EXPECT_EQ(-1, result);
569         EXPECT_TRUE(b->IsBlocking());
570         break;
571       }
572       recv_pos += result;
573     }
574 
575     ss_.ProcessMessagesUntilIdle();
576     EXPECT_TRUE(sink.Check(b.get(), SSE_READ));
577 
578     // Continue to empty the recv buffer
579     while (true) {
580       result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos, nullptr);
581       if (result < 0) {
582         EXPECT_EQ(-1, result);
583         EXPECT_TRUE(b->IsBlocking());
584         break;
585       }
586       recv_pos += result;
587     }
588 
589     // Send last of the data
590     result = a->Send(send_buffer + send_pos, kDataSize - send_pos);
591     EXPECT_EQ(500, result);
592     send_pos += result;
593 
594     ss_.ProcessMessagesUntilIdle();
595     EXPECT_TRUE(sink.Check(b.get(), SSE_READ));
596 
597     // Receive the last of the data
598     while (true) {
599       result = b->Recv(recv_buffer + recv_pos, kDataSize - recv_pos, nullptr);
600       if (result < 0) {
601         EXPECT_EQ(-1, result);
602         EXPECT_TRUE(b->IsBlocking());
603         break;
604       }
605       recv_pos += result;
606     }
607 
608     ss_.ProcessMessagesUntilIdle();
609     EXPECT_FALSE(sink.Check(b.get(), SSE_READ));
610 
611     // The received data matches the sent data
612     EXPECT_EQ(kDataSize, send_pos);
613     EXPECT_EQ(kDataSize, recv_pos);
614     EXPECT_EQ(0, memcmp(recv_buffer, send_buffer, kDataSize));
615   }
616 
TcpSendsPacketsInOrderTest(const SocketAddress & initial_addr)617   void TcpSendsPacketsInOrderTest(const SocketAddress& initial_addr) {
618     const SocketAddress kEmptyAddr;
619 
620     // Connect two sockets
621     std::unique_ptr<AsyncSocket> a =
622         WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
623     std::unique_ptr<AsyncSocket> b =
624         WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
625     a->Bind(initial_addr);
626     EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
627 
628     b->Bind(initial_addr);
629     EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
630 
631     EXPECT_EQ(0, a->Connect(b->GetLocalAddress()));
632     EXPECT_EQ(0, b->Connect(a->GetLocalAddress()));
633     ss_.ProcessMessagesUntilIdle();
634 
635     // First, deliver all packets in 0 ms.
636     char buffer[2] = { 0, 0 };
637     const char cNumPackets = 10;
638     for (char i = 0; i < cNumPackets; ++i) {
639       buffer[0] = '0' + i;
640       EXPECT_EQ(1, a->Send(buffer, 1));
641     }
642 
643     ss_.ProcessMessagesUntilIdle();
644 
645     for (char i = 0; i < cNumPackets; ++i) {
646       EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer), nullptr));
647       EXPECT_EQ(static_cast<char>('0' + i), buffer[0]);
648     }
649 
650     // Next, deliver packets at random intervals
651     const uint32_t mean = 50;
652     const uint32_t stddev = 50;
653 
654     ss_.set_delay_mean(mean);
655     ss_.set_delay_stddev(stddev);
656     ss_.UpdateDelayDistribution();
657 
658     for (char i = 0; i < cNumPackets; ++i) {
659       buffer[0] = 'A' + i;
660       EXPECT_EQ(1, a->Send(buffer, 1));
661     }
662 
663     ss_.ProcessMessagesUntilIdle();
664 
665     for (char i = 0; i < cNumPackets; ++i) {
666       EXPECT_EQ(1, b->Recv(buffer, sizeof(buffer), nullptr));
667       EXPECT_EQ(static_cast<char>('A' + i), buffer[0]);
668     }
669   }
670 
671   // It is important that initial_addr's port has to be 0 such that the
672   // incremental port behavior could ensure the 2 Binds result in different
673   // address.
BandwidthTest(const SocketAddress & initial_addr)674   void BandwidthTest(const SocketAddress& initial_addr) {
675     AsyncSocket* send_socket =
676         ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
677     AsyncSocket* recv_socket =
678         ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
679     ASSERT_EQ(0, send_socket->Bind(initial_addr));
680     ASSERT_EQ(0, recv_socket->Bind(initial_addr));
681     EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
682     EXPECT_EQ(recv_socket->GetLocalAddress().family(), initial_addr.family());
683     ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
684 
685     uint32_t bandwidth = 64 * 1024;
686     ss_.set_bandwidth(bandwidth);
687 
688     Thread* pthMain = Thread::Current();
689     Sender sender(pthMain, send_socket, 80 * 1024);
690     Receiver receiver(pthMain, recv_socket, bandwidth);
691 
692     // Allow the sender to run for 5 (simulated) seconds, then be stopped for 5
693     // seconds.
694     SIMULATED_WAIT(false, 5000, fake_clock_);
695     sender.done = true;
696     SIMULATED_WAIT(false, 5000, fake_clock_);
697 
698     // Ensure the observed bandwidth fell within a reasonable margin of error.
699     EXPECT_TRUE(receiver.count >= 5 * 3 * bandwidth / 4);
700     EXPECT_TRUE(receiver.count <= 6 * bandwidth);  // queue could drain for 1s
701 
702     ss_.set_bandwidth(0);
703   }
704 
705   // It is important that initial_addr's port has to be 0 such that the
706   // incremental port behavior could ensure the 2 Binds result in different
707   // address.
DelayTest(const SocketAddress & initial_addr)708   void DelayTest(const SocketAddress& initial_addr) {
709     time_t seed = ::time(nullptr);
710     RTC_LOG(LS_VERBOSE) << "seed = " << seed;
711     srand(static_cast<unsigned int>(seed));
712 
713     const uint32_t mean = 2000;
714     const uint32_t stddev = 500;
715 
716     ss_.set_delay_mean(mean);
717     ss_.set_delay_stddev(stddev);
718     ss_.UpdateDelayDistribution();
719 
720     AsyncSocket* send_socket =
721         ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
722     AsyncSocket* recv_socket =
723         ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
724     ASSERT_EQ(0, send_socket->Bind(initial_addr));
725     ASSERT_EQ(0, recv_socket->Bind(initial_addr));
726     EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
727     EXPECT_EQ(recv_socket->GetLocalAddress().family(), initial_addr.family());
728     ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
729 
730     Thread* pthMain = Thread::Current();
731     // Avg packet size is 2K, so at 200KB/s for 10s, we should see about
732     // 1000 packets, which is necessary to get a good distribution.
733     Sender sender(pthMain, send_socket, 100 * 2 * 1024);
734     Receiver receiver(pthMain, recv_socket, 0);
735 
736     // Simulate 10 seconds of packets being sent, then check the observed delay
737     // distribution.
738     SIMULATED_WAIT(false, 10000, fake_clock_);
739     sender.done = receiver.done = true;
740     ss_.ProcessMessagesUntilIdle();
741 
742     const double sample_mean = receiver.sum / receiver.samples;
743     double num =
744         receiver.samples * receiver.sum_sq - receiver.sum * receiver.sum;
745     double den = receiver.samples * (receiver.samples - 1);
746     const double sample_stddev = sqrt(num / den);
747     RTC_LOG(LS_VERBOSE) << "mean=" << sample_mean
748                         << " stddev=" << sample_stddev;
749 
750     EXPECT_LE(500u, receiver.samples);
751     // We initially used a 0.1 fudge factor, but on the build machine, we
752     // have seen the value differ by as much as 0.13.
753     EXPECT_NEAR(mean, sample_mean, 0.15 * mean);
754     EXPECT_NEAR(stddev, sample_stddev, 0.15 * stddev);
755 
756     ss_.set_delay_mean(0);
757     ss_.set_delay_stddev(0);
758     ss_.UpdateDelayDistribution();
759   }
760 
761   // Test cross-family communication between a client bound to client_addr and a
762   // server bound to server_addr. shouldSucceed indicates if communication is
763   // expected to work or not.
CrossFamilyConnectionTest(const SocketAddress & client_addr,const SocketAddress & server_addr,bool shouldSucceed)764   void CrossFamilyConnectionTest(const SocketAddress& client_addr,
765                                  const SocketAddress& server_addr,
766                                  bool shouldSucceed) {
767     StreamSink sink;
768     SocketAddress accept_address;
769     const SocketAddress kEmptyAddr;
770 
771     // Client gets a IPv4 address
772     std::unique_ptr<AsyncSocket> client =
773         WrapUnique(ss_.CreateAsyncSocket(client_addr.family(), SOCK_STREAM));
774     sink.Monitor(client.get());
775     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
776     EXPECT_EQ(client->GetLocalAddress(), kEmptyAddr);
777     client->Bind(client_addr);
778 
779     // Server gets a non-mapped non-any IPv6 address.
780     // IPv4 sockets should not be able to connect to this.
781     std::unique_ptr<AsyncSocket> server =
782         WrapUnique(ss_.CreateAsyncSocket(server_addr.family(), SOCK_STREAM));
783     sink.Monitor(server.get());
784     server->Bind(server_addr);
785     server->Listen(5);
786 
787     if (shouldSucceed) {
788       EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
789       ss_.ProcessMessagesUntilIdle();
790       EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
791       std::unique_ptr<Socket> accepted =
792           WrapUnique(server->Accept(&accept_address));
793       EXPECT_TRUE(nullptr != accepted);
794       EXPECT_NE(kEmptyAddr, accept_address);
795       ss_.ProcessMessagesUntilIdle();
796       EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
797       EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
798     } else {
799       // Check that the connection failed.
800       EXPECT_EQ(-1, client->Connect(server->GetLocalAddress()));
801       ss_.ProcessMessagesUntilIdle();
802 
803       EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
804       EXPECT_TRUE(nullptr == server->Accept(&accept_address));
805       EXPECT_EQ(accept_address, kEmptyAddr);
806       EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
807       EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
808       EXPECT_EQ(client->GetRemoteAddress(), kEmptyAddr);
809     }
810   }
811 
812   // Test cross-family datagram sending between a client bound to client_addr
813   // and a server bound to server_addr. shouldSucceed indicates if sending is
814   // expected to succeed or not.
CrossFamilyDatagramTest(const SocketAddress & client_addr,const SocketAddress & server_addr,bool shouldSucceed)815   void CrossFamilyDatagramTest(const SocketAddress& client_addr,
816                                const SocketAddress& server_addr,
817                                bool shouldSucceed) {
818     AsyncSocket* socket = ss_.CreateAsyncSocket(SOCK_DGRAM);
819     socket->Bind(server_addr);
820     SocketAddress bound_server_addr = socket->GetLocalAddress();
821     auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket),
822                                           &fake_clock_);
823 
824     AsyncSocket* socket2 = ss_.CreateAsyncSocket(SOCK_DGRAM);
825     socket2->Bind(client_addr);
826     auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2),
827                                           &fake_clock_);
828     SocketAddress client2_addr;
829 
830     if (shouldSucceed) {
831       EXPECT_EQ(3, client2->SendTo("foo", 3, bound_server_addr));
832       EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
833       SocketAddress client1_addr;
834       EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
835       EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
836       EXPECT_EQ(client1_addr, bound_server_addr);
837     } else {
838       EXPECT_EQ(-1, client2->SendTo("foo", 3, bound_server_addr));
839       EXPECT_TRUE(client1->CheckNoPacket());
840     }
841   }
842 
843  protected:
844   rtc::ScopedFakeClock fake_clock_;
845   VirtualSocketServer ss_;
846   AutoSocketServerThread thread_;
847   const SocketAddress kIPv4AnyAddress;
848   const SocketAddress kIPv6AnyAddress;
849 };
850 
TEST_F(VirtualSocketServerTest,basic_v4)851 TEST_F(VirtualSocketServerTest, basic_v4) {
852   SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 5000);
853   BasicTest(ipv4_test_addr);
854 }
855 
TEST_F(VirtualSocketServerTest,basic_v6)856 TEST_F(VirtualSocketServerTest, basic_v6) {
857   SocketAddress ipv6_test_addr(IPAddress(in6addr_any), 5000);
858   BasicTest(ipv6_test_addr);
859 }
860 
TEST_F(VirtualSocketServerTest,TestDefaultRoute_v4)861 TEST_F(VirtualSocketServerTest, TestDefaultRoute_v4) {
862   IPAddress ipv4_default_addr(0x01020304);
863   TestDefaultRoute(ipv4_default_addr);
864 }
865 
TEST_F(VirtualSocketServerTest,TestDefaultRoute_v6)866 TEST_F(VirtualSocketServerTest, TestDefaultRoute_v6) {
867   IPAddress ipv6_default_addr;
868   EXPECT_TRUE(
869       IPFromString("2401:fa00:4:1000:be30:5bff:fee5:c3", &ipv6_default_addr));
870   TestDefaultRoute(ipv6_default_addr);
871 }
872 
TEST_F(VirtualSocketServerTest,connect_v4)873 TEST_F(VirtualSocketServerTest, connect_v4) {
874   ConnectTest(kIPv4AnyAddress);
875 }
876 
TEST_F(VirtualSocketServerTest,connect_v6)877 TEST_F(VirtualSocketServerTest, connect_v6) {
878   ConnectTest(kIPv6AnyAddress);
879 }
880 
TEST_F(VirtualSocketServerTest,connect_to_non_listener_v4)881 TEST_F(VirtualSocketServerTest, connect_to_non_listener_v4) {
882   ConnectToNonListenerTest(kIPv4AnyAddress);
883 }
884 
TEST_F(VirtualSocketServerTest,connect_to_non_listener_v6)885 TEST_F(VirtualSocketServerTest, connect_to_non_listener_v6) {
886   ConnectToNonListenerTest(kIPv6AnyAddress);
887 }
888 
TEST_F(VirtualSocketServerTest,close_during_connect_v4)889 TEST_F(VirtualSocketServerTest, close_during_connect_v4) {
890   CloseDuringConnectTest(kIPv4AnyAddress);
891 }
892 
TEST_F(VirtualSocketServerTest,close_during_connect_v6)893 TEST_F(VirtualSocketServerTest, close_during_connect_v6) {
894   CloseDuringConnectTest(kIPv6AnyAddress);
895 }
896 
TEST_F(VirtualSocketServerTest,close_v4)897 TEST_F(VirtualSocketServerTest, close_v4) {
898   CloseTest(kIPv4AnyAddress);
899 }
900 
TEST_F(VirtualSocketServerTest,close_v6)901 TEST_F(VirtualSocketServerTest, close_v6) {
902   CloseTest(kIPv6AnyAddress);
903 }
904 
TEST_F(VirtualSocketServerTest,tcp_send_v4)905 TEST_F(VirtualSocketServerTest, tcp_send_v4) {
906   TcpSendTest(kIPv4AnyAddress);
907 }
908 
TEST_F(VirtualSocketServerTest,tcp_send_v6)909 TEST_F(VirtualSocketServerTest, tcp_send_v6) {
910   TcpSendTest(kIPv6AnyAddress);
911 }
912 
TEST_F(VirtualSocketServerTest,TcpSendsPacketsInOrder_v4)913 TEST_F(VirtualSocketServerTest, TcpSendsPacketsInOrder_v4) {
914   TcpSendsPacketsInOrderTest(kIPv4AnyAddress);
915 }
916 
TEST_F(VirtualSocketServerTest,TcpSendsPacketsInOrder_v6)917 TEST_F(VirtualSocketServerTest, TcpSendsPacketsInOrder_v6) {
918   TcpSendsPacketsInOrderTest(kIPv6AnyAddress);
919 }
920 
TEST_F(VirtualSocketServerTest,bandwidth_v4)921 TEST_F(VirtualSocketServerTest, bandwidth_v4) {
922   BandwidthTest(kIPv4AnyAddress);
923 }
924 
TEST_F(VirtualSocketServerTest,bandwidth_v6)925 TEST_F(VirtualSocketServerTest, bandwidth_v6) {
926   BandwidthTest(kIPv6AnyAddress);
927 }
928 
TEST_F(VirtualSocketServerTest,delay_v4)929 TEST_F(VirtualSocketServerTest, delay_v4) {
930   DelayTest(kIPv4AnyAddress);
931 }
932 
TEST_F(VirtualSocketServerTest,delay_v6)933 TEST_F(VirtualSocketServerTest, delay_v6) {
934   DelayTest(kIPv6AnyAddress);
935 }
936 
937 // Works, receiving socket sees 127.0.0.2.
TEST_F(VirtualSocketServerTest,CanConnectFromMappedIPv6ToIPv4Any)938 TEST_F(VirtualSocketServerTest, CanConnectFromMappedIPv6ToIPv4Any) {
939   CrossFamilyConnectionTest(SocketAddress("::ffff:127.0.0.2", 0),
940                             SocketAddress("0.0.0.0", 5000),
941                             true);
942 }
943 
944 // Fails.
TEST_F(VirtualSocketServerTest,CantConnectFromUnMappedIPv6ToIPv4Any)945 TEST_F(VirtualSocketServerTest, CantConnectFromUnMappedIPv6ToIPv4Any) {
946   CrossFamilyConnectionTest(SocketAddress("::2", 0),
947                             SocketAddress("0.0.0.0", 5000),
948                             false);
949 }
950 
951 // Fails.
TEST_F(VirtualSocketServerTest,CantConnectFromUnMappedIPv6ToMappedIPv6)952 TEST_F(VirtualSocketServerTest, CantConnectFromUnMappedIPv6ToMappedIPv6) {
953   CrossFamilyConnectionTest(SocketAddress("::2", 0),
954                             SocketAddress("::ffff:127.0.0.1", 5000),
955                             false);
956 }
957 
958 // Works. receiving socket sees ::ffff:127.0.0.2.
TEST_F(VirtualSocketServerTest,CanConnectFromIPv4ToIPv6Any)959 TEST_F(VirtualSocketServerTest, CanConnectFromIPv4ToIPv6Any) {
960   CrossFamilyConnectionTest(SocketAddress("127.0.0.2", 0),
961                             SocketAddress("::", 5000),
962                             true);
963 }
964 
965 // Fails.
TEST_F(VirtualSocketServerTest,CantConnectFromIPv4ToUnMappedIPv6)966 TEST_F(VirtualSocketServerTest, CantConnectFromIPv4ToUnMappedIPv6) {
967   CrossFamilyConnectionTest(SocketAddress("127.0.0.2", 0),
968                             SocketAddress("::1", 5000),
969                             false);
970 }
971 
972 // Works. Receiving socket sees ::ffff:127.0.0.1.
TEST_F(VirtualSocketServerTest,CanConnectFromIPv4ToMappedIPv6)973 TEST_F(VirtualSocketServerTest, CanConnectFromIPv4ToMappedIPv6) {
974   CrossFamilyConnectionTest(SocketAddress("127.0.0.1", 0),
975                             SocketAddress("::ffff:127.0.0.2", 5000),
976                             true);
977 }
978 
979 // Works, receiving socket sees a result from GetNextIP.
TEST_F(VirtualSocketServerTest,CanConnectFromUnboundIPv6ToIPv4Any)980 TEST_F(VirtualSocketServerTest, CanConnectFromUnboundIPv6ToIPv4Any) {
981   CrossFamilyConnectionTest(SocketAddress("::", 0),
982                             SocketAddress("0.0.0.0", 5000),
983                             true);
984 }
985 
986 // Works, receiving socket sees whatever GetNextIP gave the client.
TEST_F(VirtualSocketServerTest,CanConnectFromUnboundIPv4ToIPv6Any)987 TEST_F(VirtualSocketServerTest, CanConnectFromUnboundIPv4ToIPv6Any) {
988   CrossFamilyConnectionTest(SocketAddress("0.0.0.0", 0),
989                             SocketAddress("::", 5000),
990                             true);
991 }
992 
TEST_F(VirtualSocketServerTest,CanSendDatagramFromUnboundIPv4ToIPv6Any)993 TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv4ToIPv6Any) {
994   CrossFamilyDatagramTest(SocketAddress("0.0.0.0", 0),
995                           SocketAddress("::", 5000),
996                           true);
997 }
998 
TEST_F(VirtualSocketServerTest,CanSendDatagramFromMappedIPv6ToIPv4Any)999 TEST_F(VirtualSocketServerTest, CanSendDatagramFromMappedIPv6ToIPv4Any) {
1000   CrossFamilyDatagramTest(SocketAddress("::ffff:127.0.0.1", 0),
1001                           SocketAddress("0.0.0.0", 5000),
1002                           true);
1003 }
1004 
TEST_F(VirtualSocketServerTest,CantSendDatagramFromUnMappedIPv6ToIPv4Any)1005 TEST_F(VirtualSocketServerTest, CantSendDatagramFromUnMappedIPv6ToIPv4Any) {
1006   CrossFamilyDatagramTest(SocketAddress("::2", 0),
1007                           SocketAddress("0.0.0.0", 5000),
1008                           false);
1009 }
1010 
TEST_F(VirtualSocketServerTest,CantSendDatagramFromUnMappedIPv6ToMappedIPv6)1011 TEST_F(VirtualSocketServerTest, CantSendDatagramFromUnMappedIPv6ToMappedIPv6) {
1012   CrossFamilyDatagramTest(SocketAddress("::2", 0),
1013                           SocketAddress("::ffff:127.0.0.1", 5000),
1014                           false);
1015 }
1016 
TEST_F(VirtualSocketServerTest,CanSendDatagramFromIPv4ToIPv6Any)1017 TEST_F(VirtualSocketServerTest, CanSendDatagramFromIPv4ToIPv6Any) {
1018   CrossFamilyDatagramTest(SocketAddress("127.0.0.2", 0),
1019                           SocketAddress("::", 5000),
1020                           true);
1021 }
1022 
TEST_F(VirtualSocketServerTest,CantSendDatagramFromIPv4ToUnMappedIPv6)1023 TEST_F(VirtualSocketServerTest, CantSendDatagramFromIPv4ToUnMappedIPv6) {
1024   CrossFamilyDatagramTest(SocketAddress("127.0.0.2", 0),
1025                           SocketAddress("::1", 5000),
1026                           false);
1027 }
1028 
TEST_F(VirtualSocketServerTest,CanSendDatagramFromIPv4ToMappedIPv6)1029 TEST_F(VirtualSocketServerTest, CanSendDatagramFromIPv4ToMappedIPv6) {
1030   CrossFamilyDatagramTest(SocketAddress("127.0.0.1", 0),
1031                           SocketAddress("::ffff:127.0.0.2", 5000),
1032                           true);
1033 }
1034 
TEST_F(VirtualSocketServerTest,CanSendDatagramFromUnboundIPv6ToIPv4Any)1035 TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv6ToIPv4Any) {
1036   CrossFamilyDatagramTest(SocketAddress("::", 0),
1037                           SocketAddress("0.0.0.0", 5000),
1038                           true);
1039 }
1040 
TEST_F(VirtualSocketServerTest,SetSendingBlockedWithUdpSocket)1041 TEST_F(VirtualSocketServerTest, SetSendingBlockedWithUdpSocket) {
1042   AsyncSocket* socket1 =
1043       ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
1044   std::unique_ptr<AsyncSocket> socket2 =
1045       WrapUnique(ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM));
1046   socket1->Bind(kIPv4AnyAddress);
1047   socket2->Bind(kIPv4AnyAddress);
1048   auto client1 =
1049       MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket1), &fake_clock_);
1050 
1051   ss_.SetSendingBlocked(true);
1052   EXPECT_EQ(-1, client1->SendTo("foo", 3, socket2->GetLocalAddress()));
1053   EXPECT_TRUE(socket1->IsBlocking());
1054   EXPECT_EQ(0, client1->ready_to_send_count());
1055 
1056   ss_.SetSendingBlocked(false);
1057   EXPECT_EQ(1, client1->ready_to_send_count());
1058   EXPECT_EQ(3, client1->SendTo("foo", 3, socket2->GetLocalAddress()));
1059 }
1060 
TEST_F(VirtualSocketServerTest,SetSendingBlockedWithTcpSocket)1061 TEST_F(VirtualSocketServerTest, SetSendingBlockedWithTcpSocket) {
1062   constexpr size_t kBufferSize = 1024;
1063   ss_.set_send_buffer_capacity(kBufferSize);
1064   ss_.set_recv_buffer_capacity(kBufferSize);
1065 
1066   StreamSink sink;
1067   std::unique_ptr<AsyncSocket> socket1 =
1068       WrapUnique(ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
1069   std::unique_ptr<AsyncSocket> socket2 =
1070       WrapUnique(ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
1071   sink.Monitor(socket1.get());
1072   sink.Monitor(socket2.get());
1073   socket1->Bind(kIPv4AnyAddress);
1074   socket2->Bind(kIPv4AnyAddress);
1075 
1076   // Connect sockets.
1077   EXPECT_EQ(0, socket1->Connect(socket2->GetLocalAddress()));
1078   EXPECT_EQ(0, socket2->Connect(socket1->GetLocalAddress()));
1079   ss_.ProcessMessagesUntilIdle();
1080 
1081   char data[kBufferSize] = {};
1082 
1083   // First Send call will fill the send buffer but not send anything.
1084   ss_.SetSendingBlocked(true);
1085   EXPECT_EQ(static_cast<int>(kBufferSize), socket1->Send(data, kBufferSize));
1086   ss_.ProcessMessagesUntilIdle();
1087   EXPECT_FALSE(sink.Check(socket1.get(), SSE_WRITE));
1088   EXPECT_FALSE(sink.Check(socket2.get(), SSE_READ));
1089   EXPECT_FALSE(socket1->IsBlocking());
1090 
1091   // Since the send buffer is full, next Send will result in EWOULDBLOCK.
1092   EXPECT_EQ(-1, socket1->Send(data, kBufferSize));
1093   EXPECT_FALSE(sink.Check(socket1.get(), SSE_WRITE));
1094   EXPECT_FALSE(sink.Check(socket2.get(), SSE_READ));
1095   EXPECT_TRUE(socket1->IsBlocking());
1096 
1097   // When sending is unblocked, the buffered data should be sent and
1098   // SignalWriteEvent should fire.
1099   ss_.SetSendingBlocked(false);
1100   ss_.ProcessMessagesUntilIdle();
1101   EXPECT_TRUE(sink.Check(socket1.get(), SSE_WRITE));
1102   EXPECT_TRUE(sink.Check(socket2.get(), SSE_READ));
1103 }
1104 
TEST_F(VirtualSocketServerTest,CreatesStandardDistribution)1105 TEST_F(VirtualSocketServerTest, CreatesStandardDistribution) {
1106   const uint32_t kTestMean[] = {10, 100, 333, 1000};
1107   const double kTestDev[] = { 0.25, 0.1, 0.01 };
1108   // TODO(deadbeef): The current code only works for 1000 data points or more.
1109   const uint32_t kTestSamples[] = {/*10, 100,*/ 1000};
1110   for (size_t midx = 0; midx < arraysize(kTestMean); ++midx) {
1111     for (size_t didx = 0; didx < arraysize(kTestDev); ++didx) {
1112       for (size_t sidx = 0; sidx < arraysize(kTestSamples); ++sidx) {
1113         ASSERT_LT(0u, kTestSamples[sidx]);
1114         const uint32_t kStdDev =
1115             static_cast<uint32_t>(kTestDev[didx] * kTestMean[midx]);
1116         VirtualSocketServer::Function* f =
1117             VirtualSocketServer::CreateDistribution(kTestMean[midx],
1118                                                     kStdDev,
1119                                                     kTestSamples[sidx]);
1120         ASSERT_TRUE(nullptr != f);
1121         ASSERT_EQ(kTestSamples[sidx], f->size());
1122         double sum = 0;
1123         for (uint32_t i = 0; i < f->size(); ++i) {
1124           sum += (*f)[i].second;
1125         }
1126         const double mean = sum / f->size();
1127         double sum_sq_dev = 0;
1128         for (uint32_t i = 0; i < f->size(); ++i) {
1129           double dev = (*f)[i].second - mean;
1130           sum_sq_dev += dev * dev;
1131         }
1132         const double stddev = sqrt(sum_sq_dev / f->size());
1133         EXPECT_NEAR(kTestMean[midx], mean, 0.1 * kTestMean[midx])
1134           << "M=" << kTestMean[midx]
1135           << " SD=" << kStdDev
1136           << " N=" << kTestSamples[sidx];
1137         EXPECT_NEAR(kStdDev, stddev, 0.1 * kStdDev)
1138           << "M=" << kTestMean[midx]
1139           << " SD=" << kStdDev
1140           << " N=" << kTestSamples[sidx];
1141         delete f;
1142       }
1143     }
1144   }
1145 }
1146