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, ¤t_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, ¤t_dscp));
1077 ASSERT_NE(-1, socket->SetOption(Socket::OPT_DSCP, desired_dscp));
1078 ASSERT_NE(-1, socket->GetOption(Socket::OPT_DSCP, ¤t_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