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