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