Branch data Line data Source code
1 : : // Copyright (c) 2021-2022 The Bitcoin Core developers
2 : : // Distributed under the MIT software license, see the accompanying
3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 : :
5 : : #include <common/system.h>
6 : : #include <compat/compat.h>
7 : : #include <test/util/setup_common.h>
8 : : #include <util/sock.h>
9 : : #include <util/threadinterrupt.h>
10 : :
11 : : #include <boost/test/unit_test.hpp>
12 : :
13 : : #include <cassert>
14 : : #include <thread>
15 : :
16 : : using namespace std::chrono_literals;
17 : :
18 : 0 : BOOST_FIXTURE_TEST_SUITE(sock_tests, BasicTestingSetup)
19 : :
20 : 0 : static bool SocketIsClosed(const SOCKET& s)
21 : : {
22 : : // Notice that if another thread is running and creates its own socket after `s` has been
23 : : // closed, it may be assigned the same file descriptor number. In this case, our test will
24 : : // wrongly pretend that the socket is not closed.
25 : : int type;
26 : 0 : socklen_t len = sizeof(type);
27 : 0 : return getsockopt(s, SOL_SOCKET, SO_TYPE, (sockopt_arg_type)&type, &len) == SOCKET_ERROR;
28 : : }
29 : :
30 : 0 : static SOCKET CreateSocket()
31 : : {
32 : 0 : const SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
33 : 0 : BOOST_REQUIRE(s != static_cast<SOCKET>(SOCKET_ERROR));
34 : 0 : return s;
35 : 0 : }
36 : :
37 : 0 : BOOST_AUTO_TEST_CASE(constructor_and_destructor)
38 : : {
39 : 0 : const SOCKET s = CreateSocket();
40 : 0 : Sock* sock = new Sock(s);
41 : 0 : BOOST_CHECK(*sock == s);
42 : 0 : BOOST_CHECK(!SocketIsClosed(s));
43 : 0 : delete sock;
44 : 0 : BOOST_CHECK(SocketIsClosed(s));
45 : 0 : }
46 : :
47 : 0 : BOOST_AUTO_TEST_CASE(move_constructor)
48 : : {
49 : 0 : const SOCKET s = CreateSocket();
50 : 0 : Sock* sock1 = new Sock(s);
51 : 0 : Sock* sock2 = new Sock(std::move(*sock1));
52 : 0 : delete sock1;
53 : 0 : BOOST_CHECK(!SocketIsClosed(s));
54 : 0 : BOOST_CHECK(*sock2 == s);
55 : 0 : delete sock2;
56 : 0 : BOOST_CHECK(SocketIsClosed(s));
57 : 0 : }
58 : :
59 : 0 : BOOST_AUTO_TEST_CASE(move_assignment)
60 : : {
61 : 0 : const SOCKET s1 = CreateSocket();
62 : 0 : const SOCKET s2 = CreateSocket();
63 : 0 : Sock* sock1 = new Sock(s1);
64 : 0 : Sock* sock2 = new Sock(s2);
65 : :
66 : 0 : BOOST_CHECK(!SocketIsClosed(s1));
67 : 0 : BOOST_CHECK(!SocketIsClosed(s2));
68 : :
69 : 0 : *sock2 = std::move(*sock1);
70 : 0 : BOOST_CHECK(!SocketIsClosed(s1));
71 : 0 : BOOST_CHECK(SocketIsClosed(s2));
72 : 0 : BOOST_CHECK(*sock2 == s1);
73 : :
74 : 0 : delete sock1;
75 : 0 : BOOST_CHECK(!SocketIsClosed(s1));
76 : 0 : BOOST_CHECK(SocketIsClosed(s2));
77 : 0 : BOOST_CHECK(*sock2 == s1);
78 : :
79 : 0 : delete sock2;
80 : 0 : BOOST_CHECK(SocketIsClosed(s1));
81 : 0 : BOOST_CHECK(SocketIsClosed(s2));
82 : 0 : }
83 : :
84 : : #ifndef WIN32 // Windows does not have socketpair(2).
85 : :
86 : 0 : static void CreateSocketPair(int s[2])
87 : : {
88 : 0 : BOOST_REQUIRE_EQUAL(socketpair(AF_UNIX, SOCK_STREAM, 0, s), 0);
89 : 0 : }
90 : :
91 : 0 : static void SendAndRecvMessage(const Sock& sender, const Sock& receiver)
92 : : {
93 : 0 : const char* msg = "abcd";
94 : 0 : constexpr ssize_t msg_len = 4;
95 : : char recv_buf[10];
96 : :
97 : 0 : BOOST_CHECK_EQUAL(sender.Send(msg, msg_len, 0), msg_len);
98 : 0 : BOOST_CHECK_EQUAL(receiver.Recv(recv_buf, sizeof(recv_buf), 0), msg_len);
99 : 0 : BOOST_CHECK_EQUAL(strncmp(msg, recv_buf, msg_len), 0);
100 : 0 : }
101 : :
102 : 0 : BOOST_AUTO_TEST_CASE(send_and_receive)
103 : : {
104 : : int s[2];
105 : 0 : CreateSocketPair(s);
106 : :
107 : 0 : Sock* sock0 = new Sock(s[0]);
108 : 0 : Sock* sock1 = new Sock(s[1]);
109 : :
110 : 0 : SendAndRecvMessage(*sock0, *sock1);
111 : :
112 : 0 : Sock* sock0moved = new Sock(std::move(*sock0));
113 : 0 : Sock* sock1moved = new Sock(INVALID_SOCKET);
114 : 0 : *sock1moved = std::move(*sock1);
115 : :
116 : 0 : delete sock0;
117 : 0 : delete sock1;
118 : :
119 : 0 : SendAndRecvMessage(*sock1moved, *sock0moved);
120 : :
121 : 0 : delete sock0moved;
122 : 0 : delete sock1moved;
123 : :
124 : 0 : BOOST_CHECK(SocketIsClosed(s[0]));
125 : 0 : BOOST_CHECK(SocketIsClosed(s[1]));
126 : 0 : }
127 : :
128 : 0 : BOOST_AUTO_TEST_CASE(wait)
129 : : {
130 : : int s[2];
131 : 0 : CreateSocketPair(s);
132 : :
133 : 0 : Sock sock0(s[0]);
134 : 0 : Sock sock1(s[1]);
135 : :
136 : 0 : std::thread waiter([&sock0]() { (void)sock0.Wait(24h, Sock::RECV); });
137 : :
138 : 0 : BOOST_REQUIRE_EQUAL(sock1.Send("a", 1, 0), 1);
139 : :
140 : 0 : waiter.join();
141 : 0 : }
142 : :
143 : 0 : BOOST_AUTO_TEST_CASE(recv_until_terminator_limit)
144 : : {
145 : 0 : constexpr auto timeout = 1min; // High enough so that it is never hit.
146 : 0 : CThreadInterrupt interrupt;
147 : : int s[2];
148 : 0 : CreateSocketPair(s);
149 : :
150 : 0 : Sock sock_send(s[0]);
151 : 0 : Sock sock_recv(s[1]);
152 : :
153 : 0 : std::thread receiver([&sock_recv, &timeout, &interrupt]() {
154 : 0 : constexpr size_t max_data{10};
155 : 0 : bool threw_as_expected{false};
156 : : // BOOST_CHECK_EXCEPTION() writes to some variables shared with the main thread which
157 : : // creates a data race. So mimic it manually.
158 : : try {
159 : 0 : (void)sock_recv.RecvUntilTerminator('\n', timeout, interrupt, max_data);
160 : 0 : } catch (const std::runtime_error& e) {
161 : 0 : threw_as_expected = HasReason("too many bytes without a terminator")(e);
162 : 0 : }
163 : 0 : assert(threw_as_expected);
164 : 0 : });
165 : :
166 : 0 : BOOST_REQUIRE_NO_THROW(sock_send.SendComplete("1234567", timeout, interrupt));
167 : 0 : BOOST_REQUIRE_NO_THROW(sock_send.SendComplete("89a\n", timeout, interrupt));
168 : :
169 : 0 : receiver.join();
170 : 0 : }
171 : :
172 : : #endif /* WIN32 */
173 : :
174 : 0 : BOOST_AUTO_TEST_SUITE_END()
|
