sock_tests.cpp raw
1 // Copyright (c) 2021-present 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/common.h>
8 #include <test/util/setup_common.h>
9 #include <util/sock.h>
10 #include <util/threadinterrupt.h>
11
12 #include <boost/test/unit_test.hpp>
13
14 #include <cassert>
15 #include <thread>
16
17 using namespace std::chrono_literals;
18
19 BOOST_FIXTURE_TEST_SUITE(sock_tests, BasicTestingSetup)
20
21 static bool SocketIsClosed(const SOCKET& s)
22 {
23 // Notice that if another thread is running and creates its own socket after `s` has been
24 // closed, it may be assigned the same file descriptor number. In this case, our test will
25 // wrongly pretend that the socket is not closed.
26 int type;
27 socklen_t len = sizeof(type);
28 return getsockopt(s, SOL_SOCKET, SO_TYPE, reinterpret_cast<char*>(&type), &len) == SOCKET_ERROR;
29 }
30
31 static SOCKET CreateSocket()
32 {
33 const SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
34 BOOST_REQUIRE(s != static_cast<SOCKET>(SOCKET_ERROR));
35 return s;
36 }
37
38 BOOST_AUTO_TEST_CASE(constructor_and_destructor)
39 {
40 const SOCKET s = CreateSocket();
41 Sock* sock = new Sock(s);
42 BOOST_CHECK(*sock == s);
43 BOOST_CHECK(!SocketIsClosed(s));
44 delete sock;
45 BOOST_CHECK(SocketIsClosed(s));
46 }
47
48 BOOST_AUTO_TEST_CASE(move_constructor)
49 {
50 const SOCKET s = CreateSocket();
51 Sock* sock1 = new Sock(s);
52 Sock* sock2 = new Sock(std::move(*sock1));
53 delete sock1;
54 BOOST_CHECK(!SocketIsClosed(s));
55 BOOST_CHECK(*sock2 == s);
56 delete sock2;
57 BOOST_CHECK(SocketIsClosed(s));
58 }
59
60 BOOST_AUTO_TEST_CASE(move_assignment)
61 {
62 const SOCKET s1 = CreateSocket();
63 const SOCKET s2 = CreateSocket();
64 Sock* sock1 = new Sock(s1);
65 Sock* sock2 = new Sock(s2);
66
67 BOOST_CHECK(!SocketIsClosed(s1));
68 BOOST_CHECK(!SocketIsClosed(s2));
69
70 *sock2 = std::move(*sock1);
71 BOOST_CHECK(!SocketIsClosed(s1));
72 BOOST_CHECK(SocketIsClosed(s2));
73 BOOST_CHECK(*sock2 == s1);
74
75 delete sock1;
76 BOOST_CHECK(!SocketIsClosed(s1));
77 BOOST_CHECK(SocketIsClosed(s2));
78 BOOST_CHECK(*sock2 == s1);
79
80 delete sock2;
81 BOOST_CHECK(SocketIsClosed(s1));
82 BOOST_CHECK(SocketIsClosed(s2));
83 }
84
85 struct TcpSocketPair {
86 Sock sender;
87 Sock receiver;
88
89 TcpSocketPair()
90 : sender{Sock{CreateSocket()}},
91 receiver{Sock{CreateSocket()}}
92 {
93 connect_pair();
94 }
95
96 TcpSocketPair(const TcpSocketPair&) = delete;
97 TcpSocketPair& operator= (const TcpSocketPair&) = delete;
98 TcpSocketPair(TcpSocketPair&&) = default;
99 TcpSocketPair& operator= (TcpSocketPair&&) = default;
100
101 void connect_pair()
102 {
103 sockaddr_in addr{};
104 addr.sin_family = AF_INET;
105 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
106 addr.sin_port = 0;
107
108 BOOST_REQUIRE_EQUAL(receiver.Bind(reinterpret_cast<sockaddr*>(&addr), sizeof(addr)), 0);
109 BOOST_REQUIRE_EQUAL(receiver.Listen(1), 0);
110
111 // Get the address of the listener.
112 sockaddr_in bound{};
113 socklen_t blen = sizeof(bound);
114 BOOST_REQUIRE_EQUAL(receiver.GetSockName(reinterpret_cast<sockaddr*>(&bound), &blen), 0);
115 BOOST_REQUIRE_EQUAL(blen, sizeof(bound));
116
117 BOOST_REQUIRE_EQUAL(sender.Connect(reinterpret_cast<sockaddr*>(&bound), sizeof(bound)), 0);
118
119 std::unique_ptr<Sock> accepted = receiver.Accept(nullptr, nullptr);
120 BOOST_REQUIRE(accepted != nullptr);
121
122 receiver = std::move(*accepted);
123 }
124
125 void send_and_receive()
126 {
127 const char* msg = "abcd";
128 constexpr ssize_t msg_len = 4;
129 char recv_buf[10];
130
131 BOOST_CHECK_EQUAL(sender.Send(msg, msg_len, 0), msg_len);
132 BOOST_CHECK_EQUAL(receiver.Recv(recv_buf, sizeof(recv_buf), 0), msg_len);
133 BOOST_CHECK_EQUAL(strncmp(msg, recv_buf, msg_len), 0);
134 }
135 };
136
137 BOOST_AUTO_TEST_CASE(send_and_receive)
138 {
139 TcpSocketPair socks{};
140 socks.send_and_receive();
141
142 // Sockets are still connected after being moved.
143 TcpSocketPair socks_moved = std::move(socks);
144 socks_moved.send_and_receive();
145 }
146
147 BOOST_AUTO_TEST_CASE(wait)
148 {
149 TcpSocketPair socks = TcpSocketPair{};
150
151 std::thread waiter([&socks]() { (void)socks.receiver.Wait(24h, Sock::RecvEvent); });
152
153 BOOST_REQUIRE_EQUAL(socks.sender.Send("a", 1, 0), 1);
154
155 waiter.join();
156 }
157
158 BOOST_AUTO_TEST_CASE(recv_until_terminator_limit)
159 {
160 constexpr auto timeout = 1min; // High enough so that it is never hit.
161 CThreadInterrupt interrupt;
162
163 TcpSocketPair socks = TcpSocketPair{};
164
165 std::thread receiver([&socks, &timeout, &interrupt]() {
166 constexpr size_t max_data{10};
167 bool threw_as_expected{false};
168 // BOOST_CHECK_EXCEPTION() writes to some variables shared with the main thread which
169 // creates a data race. So mimic it manually.
170 try {
171 (void)socks.receiver.RecvUntilTerminator('\n', timeout, interrupt, max_data);
172 } catch (const std::runtime_error& e) {
173 threw_as_expected = HasReason("too many bytes without a terminator")(e);
174 }
175 assert(threw_as_expected);
176 });
177
178 BOOST_REQUIRE_NO_THROW(socks.sender.SendComplete("1234567", timeout, interrupt));
179 BOOST_REQUIRE_NO_THROW(socks.sender.SendComplete("89a\n", timeout, interrupt));
180
181 receiver.join();
182 }
183
184 BOOST_AUTO_TEST_SUITE_END()
185