xref: /aosp_15_r20/external/webrtc/rtc_base/socket_unittest.cc (revision d9f758449e529ab9291ac668be2861e7a55c2422)
1 /*
2  *  Copyright 2007 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 "rtc_base/socket.h"
12 
13 #include <errno.h>
14 #include <stdint.h>
15 #include <string.h>
16 
17 #include <cstddef>
18 #include <cstdint>
19 #include <memory>
20 
21 #include "absl/memory/memory.h"
22 #include "absl/strings/string_view.h"
23 #include "rtc_base/arraysize.h"
24 #include "rtc_base/async_packet_socket.h"
25 #include "rtc_base/async_udp_socket.h"
26 #include "rtc_base/buffer.h"
27 #include "rtc_base/gunit.h"
28 #include "rtc_base/logging.h"
29 #include "rtc_base/net_helpers.h"
30 #include "rtc_base/socket_address.h"
31 #include "rtc_base/socket_server.h"
32 #include "rtc_base/socket_unittest.h"
33 #include "rtc_base/test_client.h"
34 #include "rtc_base/test_utils.h"
35 #include "rtc_base/third_party/sigslot/sigslot.h"
36 #include "rtc_base/thread.h"
37 #include "rtc_base/time_utils.h"
38 
39 namespace rtc {
40 
41 using webrtc::testing::SSE_CLOSE;
42 using webrtc::testing::SSE_ERROR;
43 using webrtc::testing::SSE_OPEN;
44 using webrtc::testing::SSE_READ;
45 using webrtc::testing::SSE_WRITE;
46 using webrtc::testing::StreamSink;
47 
48 #define MAYBE_SKIP_IPV6                        \
49   if (!HasIPv6Enabled()) {                     \
50     RTC_LOG(LS_INFO) << "No IPv6... skipping"; \
51     return;                                    \
52   }
53 
54 // Data size to be used in TcpInternal tests.
55 static const size_t kTcpInternalDataSize = 1024 * 1024;  // bytes
56 
TestConnectIPv4()57 void SocketTest::TestConnectIPv4() {
58   ConnectInternal(kIPv4Loopback);
59 }
60 
TestConnectIPv6()61 void SocketTest::TestConnectIPv6() {
62   MAYBE_SKIP_IPV6;
63   ConnectInternal(kIPv6Loopback);
64 }
65 
TestConnectWithDnsLookupIPv4()66 void SocketTest::TestConnectWithDnsLookupIPv4() {
67   ConnectWithDnsLookupInternal(kIPv4Loopback, "localhost");
68 }
69 
TestConnectWithDnsLookupIPv6()70 void SocketTest::TestConnectWithDnsLookupIPv6() {
71   // TODO: Enable this when DNS resolution supports IPv6.
72   RTC_LOG(LS_INFO) << "Skipping IPv6 DNS test";
73   // ConnectWithDnsLookupInternal(kIPv6Loopback, "localhost6");
74 }
75 
TestConnectFailIPv4()76 void SocketTest::TestConnectFailIPv4() {
77   ConnectFailInternal(kIPv4Loopback);
78 }
79 
TestConnectFailIPv6()80 void SocketTest::TestConnectFailIPv6() {
81   MAYBE_SKIP_IPV6;
82   ConnectFailInternal(kIPv6Loopback);
83 }
84 
TestConnectWithDnsLookupFailIPv4()85 void SocketTest::TestConnectWithDnsLookupFailIPv4() {
86   ConnectWithDnsLookupFailInternal(kIPv4Loopback);
87 }
88 
TestConnectWithDnsLookupFailIPv6()89 void SocketTest::TestConnectWithDnsLookupFailIPv6() {
90   MAYBE_SKIP_IPV6;
91   ConnectWithDnsLookupFailInternal(kIPv6Loopback);
92 }
93 
TestConnectWithClosedSocketIPv4()94 void SocketTest::TestConnectWithClosedSocketIPv4() {
95   ConnectWithClosedSocketInternal(kIPv4Loopback);
96 }
97 
TestConnectWithClosedSocketIPv6()98 void SocketTest::TestConnectWithClosedSocketIPv6() {
99   MAYBE_SKIP_IPV6;
100   ConnectWithClosedSocketInternal(kIPv6Loopback);
101 }
102 
TestConnectWhileNotClosedIPv4()103 void SocketTest::TestConnectWhileNotClosedIPv4() {
104   ConnectWhileNotClosedInternal(kIPv4Loopback);
105 }
106 
TestConnectWhileNotClosedIPv6()107 void SocketTest::TestConnectWhileNotClosedIPv6() {
108   MAYBE_SKIP_IPV6;
109   ConnectWhileNotClosedInternal(kIPv6Loopback);
110 }
111 
TestServerCloseDuringConnectIPv4()112 void SocketTest::TestServerCloseDuringConnectIPv4() {
113   ServerCloseDuringConnectInternal(kIPv4Loopback);
114 }
115 
TestServerCloseDuringConnectIPv6()116 void SocketTest::TestServerCloseDuringConnectIPv6() {
117   MAYBE_SKIP_IPV6;
118   ServerCloseDuringConnectInternal(kIPv6Loopback);
119 }
120 
TestClientCloseDuringConnectIPv4()121 void SocketTest::TestClientCloseDuringConnectIPv4() {
122   ClientCloseDuringConnectInternal(kIPv4Loopback);
123 }
124 
TestClientCloseDuringConnectIPv6()125 void SocketTest::TestClientCloseDuringConnectIPv6() {
126   MAYBE_SKIP_IPV6;
127   ClientCloseDuringConnectInternal(kIPv6Loopback);
128 }
129 
TestServerCloseIPv4()130 void SocketTest::TestServerCloseIPv4() {
131   ServerCloseInternal(kIPv4Loopback);
132 }
133 
TestServerCloseIPv6()134 void SocketTest::TestServerCloseIPv6() {
135   MAYBE_SKIP_IPV6;
136   ServerCloseInternal(kIPv6Loopback);
137 }
138 
TestCloseInClosedCallbackIPv4()139 void SocketTest::TestCloseInClosedCallbackIPv4() {
140   CloseInClosedCallbackInternal(kIPv4Loopback);
141 }
142 
TestCloseInClosedCallbackIPv6()143 void SocketTest::TestCloseInClosedCallbackIPv6() {
144   MAYBE_SKIP_IPV6;
145   CloseInClosedCallbackInternal(kIPv6Loopback);
146 }
147 
TestDeleteInReadCallbackIPv4()148 void SocketTest::TestDeleteInReadCallbackIPv4() {
149   DeleteInReadCallbackInternal(kIPv4Loopback);
150 }
151 
TestDeleteInReadCallbackIPv6()152 void SocketTest::TestDeleteInReadCallbackIPv6() {
153   MAYBE_SKIP_IPV6;
154   DeleteInReadCallbackInternal(kIPv6Loopback);
155 }
156 
TestSocketServerWaitIPv4()157 void SocketTest::TestSocketServerWaitIPv4() {
158   SocketServerWaitInternal(kIPv4Loopback);
159 }
160 
TestSocketServerWaitIPv6()161 void SocketTest::TestSocketServerWaitIPv6() {
162   MAYBE_SKIP_IPV6;
163   SocketServerWaitInternal(kIPv6Loopback);
164 }
165 
TestTcpIPv4()166 void SocketTest::TestTcpIPv4() {
167   TcpInternal(kIPv4Loopback, kTcpInternalDataSize, -1);
168 }
169 
TestTcpIPv6()170 void SocketTest::TestTcpIPv6() {
171   MAYBE_SKIP_IPV6;
172   TcpInternal(kIPv6Loopback, kTcpInternalDataSize, -1);
173 }
174 
TestSingleFlowControlCallbackIPv4()175 void SocketTest::TestSingleFlowControlCallbackIPv4() {
176   SingleFlowControlCallbackInternal(kIPv4Loopback);
177 }
178 
TestSingleFlowControlCallbackIPv6()179 void SocketTest::TestSingleFlowControlCallbackIPv6() {
180   MAYBE_SKIP_IPV6;
181   SingleFlowControlCallbackInternal(kIPv6Loopback);
182 }
183 
TestUdpIPv4()184 void SocketTest::TestUdpIPv4() {
185   UdpInternal(kIPv4Loopback);
186 }
187 
TestUdpIPv6()188 void SocketTest::TestUdpIPv6() {
189   MAYBE_SKIP_IPV6;
190   UdpInternal(kIPv6Loopback);
191 }
192 
TestUdpReadyToSendIPv4()193 void SocketTest::TestUdpReadyToSendIPv4() {
194 #if !defined(WEBRTC_MAC)
195   // TODO(ronghuawu): Enable this test on mac/ios.
196   UdpReadyToSend(kIPv4Loopback);
197 #endif
198 }
199 
TestUdpReadyToSendIPv6()200 void SocketTest::TestUdpReadyToSendIPv6() {
201 #if defined(WEBRTC_WIN)
202   // TODO(ronghuawu): Enable this test (currently flakey) on mac and linux.
203   MAYBE_SKIP_IPV6;
204   UdpReadyToSend(kIPv6Loopback);
205 #endif
206 }
207 
TestGetSetOptionsIPv4()208 void SocketTest::TestGetSetOptionsIPv4() {
209   GetSetOptionsInternal(kIPv4Loopback);
210 }
211 
TestGetSetOptionsIPv6()212 void SocketTest::TestGetSetOptionsIPv6() {
213   MAYBE_SKIP_IPV6;
214   GetSetOptionsInternal(kIPv6Loopback);
215 }
216 
TestSocketRecvTimestampIPv4()217 void SocketTest::TestSocketRecvTimestampIPv4() {
218   SocketRecvTimestamp(kIPv4Loopback);
219 }
220 
TestSocketRecvTimestampIPv6()221 void SocketTest::TestSocketRecvTimestampIPv6() {
222   MAYBE_SKIP_IPV6;
223   SocketRecvTimestamp(kIPv6Loopback);
224 }
225 
TestUdpSocketRecvTimestampUseRtcEpochIPv4()226 void SocketTest::TestUdpSocketRecvTimestampUseRtcEpochIPv4() {
227   UdpSocketRecvTimestampUseRtcEpoch(kIPv4Loopback);
228 }
229 
TestUdpSocketRecvTimestampUseRtcEpochIPv6()230 void SocketTest::TestUdpSocketRecvTimestampUseRtcEpochIPv6() {
231   MAYBE_SKIP_IPV6;
232   UdpSocketRecvTimestampUseRtcEpoch(kIPv6Loopback);
233 }
234 
235 // For unbound sockets, GetLocalAddress / GetRemoteAddress return AF_UNSPEC
236 // values on Windows, but an empty address of the same family on Linux/MacOS X.
IsUnspecOrEmptyIP(const IPAddress & address)237 bool IsUnspecOrEmptyIP(const IPAddress& address) {
238 #if !defined(WEBRTC_WIN)
239   return IPIsAny(address);
240 #else
241   return address.family() == AF_UNSPEC;
242 #endif
243 }
244 
ConnectInternal(const IPAddress & loopback)245 void SocketTest::ConnectInternal(const IPAddress& loopback) {
246   StreamSink sink;
247   SocketAddress accept_addr;
248 
249   // Create client.
250   std::unique_ptr<Socket> client(
251       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
252   sink.Monitor(client.get());
253   EXPECT_EQ(Socket::CS_CLOSED, client->GetState());
254   EXPECT_TRUE(IsUnspecOrEmptyIP(client->GetLocalAddress().ipaddr()));
255 
256   // Create server and listen.
257   std::unique_ptr<Socket> server(
258       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
259   sink.Monitor(server.get());
260   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
261   EXPECT_EQ(0, server->Listen(5));
262   EXPECT_EQ(Socket::CS_CONNECTING, server->GetState());
263 
264   // Ensure no pending server connections, since we haven't done anything yet.
265   EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
266   EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
267   EXPECT_TRUE(accept_addr.IsNil());
268 
269   // Attempt connect to listening socket.
270   EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
271   EXPECT_FALSE(client->GetLocalAddress().IsNil());
272   EXPECT_NE(server->GetLocalAddress(), client->GetLocalAddress());
273 
274   // Client is connecting, outcome not yet determined.
275   EXPECT_EQ(Socket::CS_CONNECTING, client->GetState());
276   EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
277   EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
278 
279   // Server has pending connection, accept it.
280   EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
281   std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
282   ASSERT_TRUE(accepted);
283   EXPECT_FALSE(accept_addr.IsNil());
284   EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
285 
286   // Connected from server perspective, check the addresses are correct.
287   EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState());
288   EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress());
289   EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
290 
291   // Connected from client perspective, check the addresses are correct.
292   EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout);
293   EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
294   EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
295   EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
296   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
297 }
298 
ConnectWithDnsLookupInternal(const IPAddress & loopback,absl::string_view host)299 void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback,
300                                               absl::string_view host) {
301   StreamSink sink;
302   SocketAddress accept_addr;
303 
304   // Create client.
305   std::unique_ptr<Socket> client(
306       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
307   sink.Monitor(client.get());
308 
309   // Create server and listen.
310   std::unique_ptr<Socket> server(
311       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
312   sink.Monitor(server.get());
313   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
314   EXPECT_EQ(0, server->Listen(5));
315 
316   // Attempt connect to listening socket.
317   SocketAddress dns_addr(server->GetLocalAddress());
318   dns_addr.SetIP(host);
319   EXPECT_EQ(0, client->Connect(dns_addr));
320   // TODO: Bind when doing DNS lookup.
321   // EXPECT_NE(kEmptyAddr, client->GetLocalAddress());  // Implicit Bind
322 
323   // Client is connecting, outcome not yet determined.
324   EXPECT_EQ(Socket::CS_CONNECTING, client->GetState());
325   EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
326   EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
327 
328   // Server has pending connection, accept it.
329   EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
330   std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
331   ASSERT_TRUE(accepted);
332   EXPECT_FALSE(accept_addr.IsNil());
333   EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
334 
335   // Connected from server perspective, check the addresses are correct.
336   EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState());
337   EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress());
338   EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
339 
340   // Connected from client perspective, check the addresses are correct.
341   EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout);
342   EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
343   EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
344   EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
345   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
346 }
347 
ConnectFailInternal(const IPAddress & loopback)348 void SocketTest::ConnectFailInternal(const IPAddress& loopback) {
349   StreamSink sink;
350   SocketAddress accept_addr;
351 
352   // Create client.
353   std::unique_ptr<Socket> client(
354       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
355   sink.Monitor(client.get());
356 
357   // Create server, but don't listen yet.
358   std::unique_ptr<Socket> server(
359       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
360   sink.Monitor(server.get());
361   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
362 
363   // Attempt connect to a non-existent socket.
364   // We don't connect to the server socket created above, since on
365   // MacOS it takes about 75 seconds to get back an error!
366   SocketAddress bogus_addr(loopback, 65535);
367   EXPECT_EQ(0, client->Connect(bogus_addr));
368 
369   // Wait for connection to fail (ECONNREFUSED).
370   EXPECT_EQ_WAIT(Socket::CS_CLOSED, client->GetState(), kTimeout);
371   EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
372   EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
373   EXPECT_TRUE(client->GetRemoteAddress().IsNil());
374 
375   // Should be no pending server connections.
376   EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
377   EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
378   EXPECT_EQ(IPAddress(), accept_addr.ipaddr());
379 }
380 
ConnectWithDnsLookupFailInternal(const IPAddress & loopback)381 void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
382   StreamSink sink;
383   SocketAddress accept_addr;
384 
385   // Create client.
386   std::unique_ptr<Socket> client(
387       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
388   sink.Monitor(client.get());
389 
390   // Create server, but don't listen yet.
391   std::unique_ptr<Socket> server(
392       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
393   sink.Monitor(server.get());
394   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
395 
396   // Attempt connect to a non-existent host.
397   // We don't connect to the server socket created above, since on
398   // MacOS it takes about 75 seconds to get back an error!
399   SocketAddress bogus_dns_addr("not-a-real-hostname", 65535);
400   EXPECT_EQ(0, client->Connect(bogus_dns_addr));
401 
402   // Wait for connection to fail (EHOSTNOTFOUND).
403   bool dns_lookup_finished = false;
404   WAIT_(client->GetState() == Socket::CS_CLOSED, kTimeout, dns_lookup_finished);
405   if (!dns_lookup_finished) {
406     RTC_LOG(LS_WARNING) << "Skipping test; DNS resolution took longer than 5 "
407                            "seconds.";
408     return;
409   }
410 
411   EXPECT_EQ_WAIT(Socket::CS_CLOSED, client->GetState(), kTimeout);
412   EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
413   EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
414   EXPECT_TRUE(client->GetRemoteAddress().IsNil());
415   // Should be no pending server connections.
416   EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
417   EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
418   EXPECT_TRUE(accept_addr.IsNil());
419 }
420 
ConnectWithClosedSocketInternal(const IPAddress & loopback)421 void SocketTest::ConnectWithClosedSocketInternal(const IPAddress& loopback) {
422   // Create server and listen.
423   std::unique_ptr<Socket> server(
424       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
425   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
426   EXPECT_EQ(0, server->Listen(5));
427 
428   // Create a client and put in to CS_CLOSED state.
429   std::unique_ptr<Socket> client(
430       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
431   EXPECT_EQ(0, client->Close());
432   EXPECT_EQ(Socket::CS_CLOSED, client->GetState());
433 
434   // Connect() should reinitialize the socket, and put it in to CS_CONNECTING.
435   EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress())));
436   EXPECT_EQ(Socket::CS_CONNECTING, client->GetState());
437 }
438 
ConnectWhileNotClosedInternal(const IPAddress & loopback)439 void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) {
440   // Create server and listen.
441   StreamSink sink;
442   std::unique_ptr<Socket> server(
443       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
444   sink.Monitor(server.get());
445   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
446   EXPECT_EQ(0, server->Listen(5));
447   // Create client, connect.
448   std::unique_ptr<Socket> client(
449       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
450   EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress())));
451   EXPECT_EQ(Socket::CS_CONNECTING, client->GetState());
452   // Try to connect again. Should fail, but not interfere with original attempt.
453   EXPECT_EQ(SOCKET_ERROR,
454             client->Connect(SocketAddress(server->GetLocalAddress())));
455 
456   // Accept the original connection.
457   SocketAddress accept_addr;
458   EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
459   std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
460   ASSERT_TRUE(accepted);
461   EXPECT_FALSE(accept_addr.IsNil());
462 
463   // Check the states and addresses.
464   EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState());
465   EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress());
466   EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
467   EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout);
468   EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
469   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
470 
471   // Try to connect again, to an unresolved hostname.
472   // Shouldn't break anything.
473   EXPECT_EQ(SOCKET_ERROR, client->Connect(SocketAddress(
474                               "localhost", server->GetLocalAddress().port())));
475   EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState());
476   EXPECT_EQ(Socket::CS_CONNECTED, client->GetState());
477   EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
478   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
479 }
480 
ServerCloseDuringConnectInternal(const IPAddress & loopback)481 void SocketTest::ServerCloseDuringConnectInternal(const IPAddress& loopback) {
482   StreamSink sink;
483 
484   // Create client.
485   std::unique_ptr<Socket> client(
486       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
487   sink.Monitor(client.get());
488 
489   // Create server and listen.
490   std::unique_ptr<Socket> server(
491       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
492   sink.Monitor(server.get());
493   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
494   EXPECT_EQ(0, server->Listen(5));
495 
496   // Attempt connect to listening socket.
497   EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
498 
499   // Close down the server while the socket is in the accept queue.
500   EXPECT_TRUE_WAIT(sink.Check(server.get(), SSE_READ), kTimeout);
501   server->Close();
502 
503   // This should fail the connection for the client. Clean up.
504   EXPECT_EQ_WAIT(Socket::CS_CLOSED, client->GetState(), kTimeout);
505   EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
506   client->Close();
507 }
508 
ClientCloseDuringConnectInternal(const IPAddress & loopback)509 void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) {
510   StreamSink sink;
511   SocketAddress accept_addr;
512 
513   // Create client.
514   std::unique_ptr<Socket> client(
515       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
516   sink.Monitor(client.get());
517 
518   // Create server and listen.
519   std::unique_ptr<Socket> server(
520       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
521   sink.Monitor(server.get());
522   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
523   EXPECT_EQ(0, server->Listen(5));
524 
525   // Attempt connect to listening socket.
526   EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
527 
528   // Close down the client while the socket is in the accept queue.
529   EXPECT_TRUE_WAIT(sink.Check(server.get(), SSE_READ), kTimeout);
530   client->Close();
531 
532   // The connection should still be able to be accepted.
533   std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
534   ASSERT_TRUE(accepted);
535   sink.Monitor(accepted.get());
536   EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState());
537 
538   // The accepted socket should then close (possibly with err, timing-related)
539   EXPECT_EQ_WAIT(Socket::CS_CLOSED, accepted->GetState(), kTimeout);
540   EXPECT_TRUE(sink.Check(accepted.get(), SSE_CLOSE) ||
541               sink.Check(accepted.get(), SSE_ERROR));
542 
543   // The client should not get a close event.
544   EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
545 }
546 
ServerCloseInternal(const IPAddress & loopback)547 void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
548   StreamSink sink;
549   SocketAddress accept_addr;
550 
551   // Create client.
552   std::unique_ptr<Socket> client(
553       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
554   sink.Monitor(client.get());
555 
556   // Create server and listen.
557   std::unique_ptr<Socket> server(
558       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
559   sink.Monitor(server.get());
560   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
561   EXPECT_EQ(0, server->Listen(5));
562 
563   // Attempt connection.
564   EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
565 
566   // Accept connection.
567   EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
568   std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
569   ASSERT_TRUE(accepted);
570   sink.Monitor(accepted.get());
571 
572   // Both sides are now connected.
573   EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout);
574   EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
575   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
576   EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
577 
578   // Send data to the client, and then close the connection.
579   EXPECT_EQ(1, accepted->Send("a", 1));
580   accepted->Close();
581   EXPECT_EQ(Socket::CS_CLOSED, accepted->GetState());
582 
583   // Expect that the client is notified, and has not yet closed.
584   EXPECT_TRUE_WAIT(sink.Check(client.get(), SSE_READ), kTimeout);
585   EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
586   EXPECT_EQ(Socket::CS_CONNECTED, client->GetState());
587 
588   // Ensure the data can be read.
589   char buffer[10];
590   EXPECT_EQ(1, client->Recv(buffer, sizeof(buffer), nullptr));
591   EXPECT_EQ('a', buffer[0]);
592 
593   // Now we should close, but the remote address will remain.
594   EXPECT_EQ_WAIT(Socket::CS_CLOSED, client->GetState(), kTimeout);
595   EXPECT_TRUE(sink.Check(client.get(), SSE_CLOSE));
596   EXPECT_FALSE(client->GetRemoteAddress().IsAnyIP());
597 
598   // The closer should not get a close signal.
599   EXPECT_FALSE(sink.Check(accepted.get(), SSE_CLOSE));
600   EXPECT_TRUE(accepted->GetRemoteAddress().IsNil());
601 
602   // And the closee should only get a single signal.
603   Thread::Current()->ProcessMessages(0);
604   EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
605 
606   // Close down the client and ensure all is good.
607   client->Close();
608   EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
609   EXPECT_TRUE(client->GetRemoteAddress().IsNil());
610 }
611 
612 class SocketCloser : public sigslot::has_slots<> {
613  public:
OnClose(Socket * socket,int error)614   void OnClose(Socket* socket, int error) {
615     socket->Close();  // Deleting here would blow up the vector of handlers
616                       // for the socket's signal.
617   }
618 };
619 
CloseInClosedCallbackInternal(const IPAddress & loopback)620 void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
621   StreamSink sink;
622   SocketCloser closer;
623   SocketAddress accept_addr;
624 
625   // Create client.
626   std::unique_ptr<Socket> client(
627       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
628   sink.Monitor(client.get());
629   client->SignalCloseEvent.connect(&closer, &SocketCloser::OnClose);
630 
631   // Create server and listen.
632   std::unique_ptr<Socket> server(
633       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
634   sink.Monitor(server.get());
635   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
636   EXPECT_EQ(0, server->Listen(5));
637 
638   // Attempt connection.
639   EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
640 
641   // Accept connection.
642   EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
643   std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
644   ASSERT_TRUE(accepted);
645   sink.Monitor(accepted.get());
646 
647   // Both sides are now connected.
648   EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout);
649   EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
650   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
651   EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
652 
653   // Send data to the client, and then close the connection.
654   accepted->Close();
655   EXPECT_EQ(Socket::CS_CLOSED, accepted->GetState());
656 
657   // Expect that the client is notified, and has not yet closed.
658   EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
659   EXPECT_EQ(Socket::CS_CONNECTED, client->GetState());
660 
661   // Now we should be closed and invalidated
662   EXPECT_EQ_WAIT(Socket::CS_CLOSED, client->GetState(), kTimeout);
663   EXPECT_TRUE(sink.Check(client.get(), SSE_CLOSE));
664   EXPECT_TRUE(Socket::CS_CLOSED == client->GetState());
665 }
666 
667 // Helper class specifically for the test below.
668 class SocketDeleter : public sigslot::has_slots<> {
669  public:
SocketDeleter(std::unique_ptr<Socket> socket)670   explicit SocketDeleter(std::unique_ptr<Socket> socket)
671       : socket_(std::move(socket)) {}
672 
Delete(Socket * other)673   void Delete(Socket* other) { socket_.reset(); }
674 
deleted() const675   bool deleted() const { return socket_ == nullptr; }
676 
677  private:
678   std::unique_ptr<Socket> socket_;
679 };
680 
681 // Tested deleting a socket within another socket's read callback. A previous
682 // iteration of the select loop failed in this situation, if both sockets
683 // became readable at the same time.
DeleteInReadCallbackInternal(const IPAddress & loopback)684 void SocketTest::DeleteInReadCallbackInternal(const IPAddress& loopback) {
685   std::unique_ptr<Socket> socket1(
686       socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
687   std::unique_ptr<Socket> socket2(
688       socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
689   EXPECT_EQ(0, socket1->Bind(SocketAddress(loopback, 0)));
690   EXPECT_EQ(0, socket2->Bind(SocketAddress(loopback, 0)));
691   EXPECT_EQ(3, socket1->SendTo("foo", 3, socket1->GetLocalAddress()));
692   EXPECT_EQ(3, socket2->SendTo("bar", 3, socket1->GetLocalAddress()));
693   // Sleep a while to ensure sends are both completed at the same time.
694   Thread::SleepMs(1000);
695 
696   // Configure the helper class to delete socket 2 when socket 1 has a read
697   // event.
698   SocketDeleter deleter(std::move(socket2));
699   socket1->SignalReadEvent.connect(&deleter, &SocketDeleter::Delete);
700   EXPECT_TRUE_WAIT(deleter.deleted(), kTimeout);
701 }
702 
SocketServerWaitInternal(const IPAddress & loopback)703 void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
704   StreamSink sink;
705   SocketAddress accept_addr;
706 
707   // Create & connect server and client sockets.
708   std::unique_ptr<Socket> client(
709       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
710   std::unique_ptr<Socket> server(
711       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
712   sink.Monitor(client.get());
713   sink.Monitor(server.get());
714   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
715   EXPECT_EQ(0, server->Listen(5));
716 
717   EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
718   EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
719 
720   std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
721   ASSERT_TRUE(accepted);
722   sink.Monitor(accepted.get());
723   EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState());
724   EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress());
725   EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
726 
727   EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout);
728   EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
729   EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
730   EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
731   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
732 
733   // Do an i/o operation, triggering an eventual callback.
734   EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ));
735   char buf[1024] = {0};
736 
737   EXPECT_EQ(1024, client->Send(buf, 1024));
738   EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ));
739 
740   // Shouldn't signal when blocked in a thread Send, where process_io is false.
741   std::unique_ptr<Thread> thread(Thread::CreateWithSocketServer());
742   thread->Start();
743   thread->BlockingCall([] { Thread::SleepMs(500); });
744   EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ));
745 
746   // But should signal when process_io is true.
747   EXPECT_TRUE_WAIT((sink.Check(accepted.get(), SSE_READ)), kTimeout);
748   EXPECT_LT(0, accepted->Recv(buf, 1024, nullptr));
749 }
750 
TcpInternal(const IPAddress & loopback,size_t data_size,ptrdiff_t max_send_size)751 void SocketTest::TcpInternal(const IPAddress& loopback,
752                              size_t data_size,
753                              ptrdiff_t max_send_size) {
754   StreamSink sink;
755   SocketAddress accept_addr;
756 
757   // Create receiving client.
758   std::unique_ptr<Socket> receiver(
759       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
760   sink.Monitor(receiver.get());
761 
762   // Create server and listen.
763   std::unique_ptr<Socket> server(
764       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
765   sink.Monitor(server.get());
766   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
767   EXPECT_EQ(0, server->Listen(5));
768 
769   // Attempt connection.
770   EXPECT_EQ(0, receiver->Connect(server->GetLocalAddress()));
771 
772   // Accept connection which will be used for sending.
773   EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
774   std::unique_ptr<Socket> sender(server->Accept(&accept_addr));
775   ASSERT_TRUE(sender);
776   sink.Monitor(sender.get());
777 
778   // Both sides are now connected.
779   EXPECT_EQ_WAIT(Socket::CS_CONNECTED, receiver->GetState(), kTimeout);
780   EXPECT_TRUE(sink.Check(receiver.get(), SSE_OPEN));
781   EXPECT_EQ(receiver->GetRemoteAddress(), sender->GetLocalAddress());
782   EXPECT_EQ(sender->GetRemoteAddress(), receiver->GetLocalAddress());
783 
784   // Create test data.
785   rtc::Buffer send_buffer(0, data_size);
786   rtc::Buffer recv_buffer(0, data_size);
787   for (size_t i = 0; i < data_size; ++i) {
788     char ch = static_cast<char>(i % 256);
789     send_buffer.AppendData(&ch, sizeof(ch));
790   }
791   rtc::Buffer recved_data(0, data_size);
792 
793   // Send and receive a bunch of data.
794   size_t sent_size = 0;
795   bool writable = true;
796   bool send_called = false;
797   bool readable = false;
798   bool recv_called = false;
799   while (recv_buffer.size() < send_buffer.size()) {
800     // Send as much as we can while we're cleared to send.
801     while (writable && sent_size < send_buffer.size()) {
802       int unsent_size = static_cast<int>(send_buffer.size() - sent_size);
803       int sent = sender->Send(send_buffer.data() + sent_size, unsent_size);
804       if (!send_called) {
805         // The first Send() after connecting or getting writability should
806         // succeed and send some data.
807         EXPECT_GT(sent, 0);
808         send_called = true;
809       }
810       if (sent >= 0) {
811         EXPECT_LE(sent, unsent_size);
812         sent_size += sent;
813         if (max_send_size >= 0) {
814           EXPECT_LE(static_cast<ptrdiff_t>(sent), max_send_size);
815           if (sent < unsent_size) {
816             // If max_send_size is limiting the amount to send per call such
817             // that the sent amount is less than the unsent amount, we simulate
818             // that the socket is no longer writable.
819             writable = false;
820           }
821         }
822       } else {
823         ASSERT_TRUE(sender->IsBlocking());
824         writable = false;
825       }
826     }
827 
828     // Read all the sent data.
829     while (recv_buffer.size() < sent_size) {
830       if (!readable) {
831         // Wait until data is available.
832         EXPECT_TRUE_WAIT(sink.Check(receiver.get(), SSE_READ), kTimeout);
833         readable = true;
834         recv_called = false;
835       }
836 
837       // Receive as much as we can get in a single recv call.
838       int recved_size = receiver->Recv(recved_data.data(), data_size, nullptr);
839 
840       if (!recv_called) {
841         // The first Recv() after getting readability should succeed and receive
842         // some data.
843         // TODO: The following line is disabled due to flakey pulse
844         //     builds.  Re-enable if/when possible.
845         // EXPECT_GT(recved_size, 0);
846         recv_called = true;
847       }
848       if (recved_size >= 0) {
849         EXPECT_LE(static_cast<size_t>(recved_size),
850                   sent_size - recv_buffer.size());
851         recv_buffer.AppendData(recved_data.data(), recved_size);
852       } else {
853         ASSERT_TRUE(receiver->IsBlocking());
854         readable = false;
855       }
856     }
857 
858     // Once all that we've sent has been received, expect to be able to send
859     // again.
860     if (!writable) {
861       ASSERT_TRUE_WAIT(sink.Check(sender.get(), SSE_WRITE), kTimeout);
862       writable = true;
863       send_called = false;
864     }
865   }
866 
867   // The received data matches the sent data.
868   EXPECT_EQ(data_size, sent_size);
869   EXPECT_EQ(data_size, recv_buffer.size());
870   EXPECT_EQ(recv_buffer, send_buffer);
871 
872   // Close down.
873   sender->Close();
874   EXPECT_EQ_WAIT(Socket::CS_CLOSED, receiver->GetState(), kTimeout);
875   EXPECT_TRUE(sink.Check(receiver.get(), SSE_CLOSE));
876   receiver->Close();
877 }
878 
SingleFlowControlCallbackInternal(const IPAddress & loopback)879 void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
880   StreamSink sink;
881   SocketAddress accept_addr;
882 
883   // Create client.
884   std::unique_ptr<Socket> client(
885       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
886   sink.Monitor(client.get());
887 
888   // Create server and listen.
889   std::unique_ptr<Socket> server(
890       socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
891   sink.Monitor(server.get());
892   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
893   EXPECT_EQ(0, server->Listen(5));
894 
895   // Attempt connection.
896   EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
897 
898   // Accept connection.
899   EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
900   std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
901   ASSERT_TRUE(accepted);
902   sink.Monitor(accepted.get());
903 
904   // Both sides are now connected.
905   EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout);
906   EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
907   EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
908   EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
909 
910   // Expect a writable callback from the connect.
911   EXPECT_TRUE_WAIT(sink.Check(accepted.get(), SSE_WRITE), kTimeout);
912 
913   // Fill the socket buffer.
914   char buf[1024 * 16] = {0};
915   int sends = 0;
916   while (++sends && accepted->Send(&buf, arraysize(buf)) != -1) {
917   }
918   EXPECT_TRUE(accepted->IsBlocking());
919 
920   // Wait until data is available.
921   EXPECT_TRUE_WAIT(sink.Check(client.get(), SSE_READ), kTimeout);
922 
923   // Pull data.
924   for (int i = 0; i < sends; ++i) {
925     client->Recv(buf, arraysize(buf), nullptr);
926   }
927 
928   // Expect at least one additional writable callback.
929   EXPECT_TRUE_WAIT(sink.Check(accepted.get(), SSE_WRITE), kTimeout);
930 
931   // Adding data in response to the writeable callback shouldn't cause infinite
932   // callbacks.
933   int extras = 0;
934   for (int i = 0; i < 100; ++i) {
935     accepted->Send(&buf, arraysize(buf));
936     rtc::Thread::Current()->ProcessMessages(1);
937     if (sink.Check(accepted.get(), SSE_WRITE)) {
938       extras++;
939     }
940   }
941   EXPECT_LT(extras, 2);
942 
943   // Close down.
944   accepted->Close();
945   client->Close();
946 }
947 
UdpInternal(const IPAddress & loopback)948 void SocketTest::UdpInternal(const IPAddress& loopback) {
949   SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
950   // Test basic bind and connect behavior.
951   Socket* socket = socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM);
952   EXPECT_EQ(Socket::CS_CLOSED, socket->GetState());
953   EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
954   SocketAddress addr1 = socket->GetLocalAddress();
955   EXPECT_EQ(0, socket->Connect(addr1));
956   EXPECT_EQ(Socket::CS_CONNECTED, socket->GetState());
957   socket->Close();
958   EXPECT_EQ(Socket::CS_CLOSED, socket->GetState());
959   delete socket;
960 
961   // Test send/receive behavior.
962   auto client1 = std::make_unique<TestClient>(
963       absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, addr1)));
964   auto client2 = std::make_unique<TestClient>(
965       absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
966 
967   SocketAddress addr2;
968   EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
969   EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &addr2));
970 
971   SocketAddress addr3;
972   EXPECT_EQ(6, client1->SendTo("bizbaz", 6, addr2));
973   EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &addr3));
974   EXPECT_EQ(addr3, addr1);
975   // TODO: figure out what the intent is here
976   for (int i = 0; i < 10; ++i) {
977     client2 = std::make_unique<TestClient>(
978         absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
979 
980     SocketAddress addr4;
981     EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
982     EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &addr4));
983     EXPECT_EQ(addr4.ipaddr(), addr2.ipaddr());
984 
985     SocketAddress addr5;
986     EXPECT_EQ(6, client1->SendTo("bizbaz", 6, addr4));
987     EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &addr5));
988     EXPECT_EQ(addr5, addr1);
989 
990     addr2 = addr4;
991   }
992 }
993 
UdpReadyToSend(const IPAddress & loopback)994 void SocketTest::UdpReadyToSend(const IPAddress& loopback) {
995   SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
996   // RFC 5737 - The blocks 192.0.2.0/24 (TEST-NET-1) ... are provided for use in
997   // documentation.
998   // RFC 3849 - 2001:DB8::/32 as a documentation-only prefix.
999   std::string dest =
1000       (loopback.family() == AF_INET6) ? "2001:db8::1" : "192.0.2.0";
1001   SocketAddress test_addr(dest, 2345);
1002 
1003   // Test send
1004   auto client = std::make_unique<TestClient>(
1005       absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
1006   int test_packet_size = 1200;
1007   std::unique_ptr<char[]> test_packet(new char[test_packet_size]);
1008   // Init the test packet just to avoid memcheck warning.
1009   memset(test_packet.get(), 0, test_packet_size);
1010   // Set the send buffer size to the same size as the test packet to have a
1011   // better chance to get EWOULDBLOCK.
1012   int send_buffer_size = test_packet_size;
1013 #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
1014   send_buffer_size /= 2;
1015 #endif
1016   client->SetOption(rtc::Socket::OPT_SNDBUF, send_buffer_size);
1017 
1018   int error = 0;
1019   uint32_t start_ms = Time();
1020   int sent_packet_num = 0;
1021   int expected_error = EWOULDBLOCK;
1022   while (start_ms + kTimeout > Time()) {
1023     int ret = client->SendTo(test_packet.get(), test_packet_size, test_addr);
1024     ++sent_packet_num;
1025     if (ret != test_packet_size) {
1026       error = client->GetError();
1027       if (error == expected_error) {
1028         RTC_LOG(LS_INFO) << "Got expected error code after sending "
1029                          << sent_packet_num << " packets.";
1030         break;
1031       }
1032     }
1033   }
1034   EXPECT_EQ(expected_error, error);
1035   EXPECT_FALSE(client->ready_to_send());
1036   EXPECT_TRUE_WAIT(client->ready_to_send(), kTimeout);
1037   RTC_LOG(LS_INFO) << "Got SignalReadyToSend";
1038 }
1039 
GetSetOptionsInternal(const IPAddress & loopback)1040 void SocketTest::GetSetOptionsInternal(const IPAddress& loopback) {
1041   std::unique_ptr<Socket> socket(
1042       socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
1043   socket->Bind(SocketAddress(loopback, 0));
1044 
1045   // Check SNDBUF/RCVBUF.
1046   const int desired_size = 12345;
1047 #if defined(WEBRTC_LINUX)
1048   // Yes, really.  It's in the kernel source.
1049   const int expected_size = desired_size * 2;
1050 #else   // !WEBRTC_LINUX
1051   const int expected_size = desired_size;
1052 #endif  // !WEBRTC_LINUX
1053   int recv_size = 0;
1054   int send_size = 0;
1055   // get the initial sizes
1056   ASSERT_NE(-1, socket->GetOption(Socket::OPT_RCVBUF, &recv_size));
1057   ASSERT_NE(-1, socket->GetOption(Socket::OPT_SNDBUF, &send_size));
1058   // set our desired sizes
1059   ASSERT_NE(-1, socket->SetOption(Socket::OPT_RCVBUF, desired_size));
1060   ASSERT_NE(-1, socket->SetOption(Socket::OPT_SNDBUF, desired_size));
1061   // get the sizes again
1062   ASSERT_NE(-1, socket->GetOption(Socket::OPT_RCVBUF, &recv_size));
1063   ASSERT_NE(-1, socket->GetOption(Socket::OPT_SNDBUF, &send_size));
1064   // make sure they are right
1065   ASSERT_EQ(expected_size, recv_size);
1066   ASSERT_EQ(expected_size, send_size);
1067 
1068   // Check that we can't set NODELAY on a UDP socket.
1069   int current_nd, desired_nd = 1;
1070   ASSERT_EQ(-1, socket->GetOption(Socket::OPT_NODELAY, &current_nd));
1071   ASSERT_EQ(-1, socket->SetOption(Socket::OPT_NODELAY, desired_nd));
1072 
1073 #if defined(WEBRTC_POSIX)
1074   // Check DSCP.
1075   int current_dscp, desired_dscp = 1;
1076   ASSERT_NE(-1, socket->GetOption(Socket::OPT_DSCP, &current_dscp));
1077   ASSERT_NE(-1, socket->SetOption(Socket::OPT_DSCP, desired_dscp));
1078   ASSERT_NE(-1, socket->GetOption(Socket::OPT_DSCP, &current_dscp));
1079   ASSERT_EQ(desired_dscp, current_dscp);
1080 #endif
1081 }
1082 
SocketRecvTimestamp(const IPAddress & loopback)1083 void SocketTest::SocketRecvTimestamp(const IPAddress& loopback) {
1084   StreamSink sink;
1085   std::unique_ptr<Socket> socket(
1086       socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
1087   EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
1088   SocketAddress address = socket->GetLocalAddress();
1089   sink.Monitor(socket.get());
1090 
1091   int64_t send_time_1 = TimeMicros();
1092   socket->SendTo("foo", 3, address);
1093 
1094   int64_t recv_timestamp_1;
1095   // Wait until data is available.
1096   EXPECT_TRUE_WAIT(sink.Check(socket.get(), SSE_READ), kTimeout);
1097   char buffer[3];
1098   ASSERT_GT(socket->RecvFrom(buffer, 3, nullptr, &recv_timestamp_1), 0);
1099 
1100   const int64_t kTimeBetweenPacketsMs = 100;
1101   Thread::SleepMs(kTimeBetweenPacketsMs);
1102 
1103   int64_t send_time_2 = TimeMicros();
1104   socket->SendTo("bar", 3, address);
1105   // Wait until data is available.
1106   EXPECT_TRUE_WAIT(sink.Check(socket.get(), SSE_READ), kTimeout);
1107   int64_t recv_timestamp_2;
1108   ASSERT_GT(socket->RecvFrom(buffer, 3, nullptr, &recv_timestamp_2), 0);
1109 
1110   int64_t system_time_diff = send_time_2 - send_time_1;
1111   int64_t recv_timestamp_diff = recv_timestamp_2 - recv_timestamp_1;
1112   // Compare against the system time at the point of sending, because
1113   // SleepMs may not sleep for exactly the requested time.
1114   EXPECT_NEAR(system_time_diff, recv_timestamp_diff, 10000);
1115 }
1116 
UdpSocketRecvTimestampUseRtcEpoch(const IPAddress & loopback)1117 void SocketTest::UdpSocketRecvTimestampUseRtcEpoch(const IPAddress& loopback) {
1118   SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
1119   std::unique_ptr<Socket> socket(
1120       socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
1121   ASSERT_EQ(socket->Bind(SocketAddress(loopback, 0)), 0);
1122   SocketAddress address = socket->GetLocalAddress();
1123   socket = nullptr;
1124 
1125   auto client1 = std::make_unique<TestClient>(
1126       absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, address)));
1127   auto client2 = std::make_unique<TestClient>(
1128       absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
1129 
1130   SocketAddress addr2;
1131   client2->SendTo("foo", 3, address);
1132   std::unique_ptr<TestClient::Packet> packet_1 = client1->NextPacket(10000);
1133   ASSERT_TRUE(packet_1 != nullptr);
1134   EXPECT_NEAR(packet_1->packet_time_us, rtc::TimeMicros(), 1000'000);
1135 
1136   Thread::SleepMs(100);
1137   client2->SendTo("bar", 3, address);
1138   std::unique_ptr<TestClient::Packet> packet_2 = client1->NextPacket(10000);
1139   ASSERT_TRUE(packet_2 != nullptr);
1140   EXPECT_GT(packet_2->packet_time_us, packet_1->packet_time_us);
1141   EXPECT_NEAR(packet_2->packet_time_us, rtc::TimeMicros(), 1000'000);
1142 }
1143 }  // namespace rtc
1144