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