Inside Bitcoin

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
17using namespace std::chrono_literals;
18
19BOOST_FIXTURE_TEST_SUITE(sock_tests, BasicTestingSetup)
20
21static 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
31static 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
38BOOST_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
48BOOST_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
60BOOST_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
85struct 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
137BOOST_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
147BOOST_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
158BOOST_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
184BOOST_AUTO_TEST_SUITE_END()
185