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::RECV); });
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()