1 //===-- SocketTest.cpp ------------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #if defined(_MSC_VER) && (_HAS_EXCEPTIONS == 0)
11 // Workaround for MSVC standard library bug, which fails to include <thread> when
12 // exceptions are disabled.
13 #include <eh.h>
14 #endif
15 
16 #include <cstdio>
17 #include <functional>
18 #include <thread>
19 
20 #include "gtest/gtest.h"
21 
22 #include "lldb/Host/Config.h"
23 #include "lldb/Host/Socket.h"
24 #include "lldb/Host/common/TCPSocket.h"
25 #include "lldb/Host/common/UDPSocket.h"
26 
27 #ifndef LLDB_DISABLE_POSIX
28 #include "lldb/Host/posix/DomainSocket.h"
29 #endif
30 
31 using namespace lldb_private;
32 
33 class SocketTest : public testing::Test
34 {
35   public:
36     void
37     SetUp() override
38     {
39 #if defined(_MSC_VER)
40         WSADATA data;
41         ::WSAStartup(MAKEWORD(2, 2), &data);
42 #endif
43     }
44 
45     void
46     TearDown() override
47     {
48 #if defined(_MSC_VER)
49         ::WSACleanup();
50 #endif
51     }
52 
53   protected:
54     static void
55     AcceptThread(Socket *listen_socket, const char *listen_remote_address, bool child_processes_inherit,
56                  Socket **accept_socket, Error *error)
57     {
58         *error = listen_socket->Accept(listen_remote_address, child_processes_inherit, *accept_socket);
59     }
60 
61     template<typename SocketType>
62     void
63     CreateConnectedSockets(const char *listen_remote_address, const std::function<std::string(const SocketType&)> &get_connect_addr, std::unique_ptr<SocketType> *a_up, std::unique_ptr<SocketType> *b_up)
64     {
65         bool child_processes_inherit = false;
66         Error error;
67         std::unique_ptr<SocketType> listen_socket_up(new SocketType(child_processes_inherit, error));
68         EXPECT_FALSE(error.Fail());
69         error = listen_socket_up->Listen(listen_remote_address, 5);
70         EXPECT_FALSE(error.Fail());
71         EXPECT_TRUE(listen_socket_up->IsValid());
72 
73         Error accept_error;
74         Socket *accept_socket;
75         std::thread accept_thread(AcceptThread, listen_socket_up.get(), listen_remote_address, child_processes_inherit,
76                                   &accept_socket, &accept_error);
77 
78         std::string connect_remote_address = get_connect_addr(*listen_socket_up);
79         std::unique_ptr<SocketType> connect_socket_up(new SocketType(child_processes_inherit, error));
80         EXPECT_FALSE(error.Fail());
81         error = connect_socket_up->Connect(connect_remote_address.c_str());
82         EXPECT_FALSE(error.Fail());
83         EXPECT_TRUE(connect_socket_up->IsValid());
84 
85         a_up->swap(connect_socket_up);
86         EXPECT_TRUE(error.Success());
87         EXPECT_NE(nullptr, a_up->get());
88         EXPECT_TRUE((*a_up)->IsValid());
89 
90         accept_thread.join();
91         b_up->reset(static_cast<SocketType*>(accept_socket));
92         EXPECT_TRUE(accept_error.Success());
93         EXPECT_NE(nullptr, b_up->get());
94         EXPECT_TRUE((*b_up)->IsValid());
95 
96         listen_socket_up.reset();
97     }
98 };
99 
100 TEST_F (SocketTest, DecodeHostAndPort)
101 {
102     std::string host_str;
103     std::string port_str;
104     int32_t port;
105     Error error;
106     EXPECT_TRUE (Socket::DecodeHostAndPort ("localhost:1138", host_str, port_str, port, &error));
107     EXPECT_STREQ ("localhost", host_str.c_str ());
108     EXPECT_STREQ ("1138", port_str.c_str ());
109     EXPECT_EQ (1138, port);
110     EXPECT_TRUE (error.Success ());
111 
112     EXPECT_FALSE (Socket::DecodeHostAndPort ("google.com:65536", host_str, port_str, port, &error));
113     EXPECT_TRUE (error.Fail ());
114     EXPECT_STREQ ("invalid host:port specification: 'google.com:65536'", error.AsCString ());
115 
116     EXPECT_FALSE (Socket::DecodeHostAndPort ("google.com:-1138", host_str, port_str, port, &error));
117     EXPECT_TRUE (error.Fail ());
118     EXPECT_STREQ ("invalid host:port specification: 'google.com:-1138'", error.AsCString ());
119 
120     EXPECT_TRUE (Socket::DecodeHostAndPort ("12345", host_str, port_str, port, &error));
121     EXPECT_STREQ ("", host_str.c_str ());
122     EXPECT_STREQ ("12345", port_str.c_str ());
123     EXPECT_EQ (12345, port);
124     EXPECT_TRUE (error.Success ());
125 
126     EXPECT_TRUE (Socket::DecodeHostAndPort ("*:0", host_str, port_str, port, &error));
127     EXPECT_STREQ ("*", host_str.c_str ());
128     EXPECT_STREQ ("0", port_str.c_str ());
129     EXPECT_EQ (0, port);
130     EXPECT_TRUE (error.Success ());
131 }
132 
133 #ifndef LLDB_DISABLE_POSIX
134 TEST_F (SocketTest, DomainListenConnectAccept)
135 {
136     char* file_name_str = tempnam(nullptr, nullptr);
137     EXPECT_NE (nullptr, file_name_str);
138     const std::string file_name(file_name_str);
139     free(file_name_str);
140 
141     std::unique_ptr<DomainSocket> socket_a_up;
142     std::unique_ptr<DomainSocket> socket_b_up;
143     CreateConnectedSockets<DomainSocket>(file_name.c_str(),
144                                       [=](const DomainSocket &)
145                                       {
146                                           return file_name;
147                                       },
148                                       &socket_a_up, &socket_b_up);
149 }
150 #endif
151 
152 TEST_F (SocketTest, TCPListen0ConnectAccept)
153 {
154     std::unique_ptr<TCPSocket> socket_a_up;
155     std::unique_ptr<TCPSocket> socket_b_up;
156     CreateConnectedSockets<TCPSocket>("127.0.0.1:0",
157                                       [=](const TCPSocket &s)
158                                       {
159                                           char connect_remote_address[64];
160                                           snprintf(connect_remote_address, sizeof(connect_remote_address), "localhost:%u", s.GetLocalPortNumber());
161                                           return std::string(connect_remote_address);
162                                       },
163                                       &socket_a_up, &socket_b_up);
164 }
165 
166 TEST_F (SocketTest, TCPGetAddress)
167 {
168     std::unique_ptr<TCPSocket> socket_a_up;
169     std::unique_ptr<TCPSocket> socket_b_up;
170     CreateConnectedSockets<TCPSocket>("127.0.0.1:0",
171                                       [=](const TCPSocket &s)
172                                       {
173                                           char connect_remote_address[64];
174                                           snprintf(connect_remote_address, sizeof(connect_remote_address), "localhost:%u", s.GetLocalPortNumber());
175                                           return std::string(connect_remote_address);
176                                       },
177                                       &socket_a_up,
178                                       &socket_b_up);
179 
180     EXPECT_EQ (socket_a_up->GetLocalPortNumber (), socket_b_up->GetRemotePortNumber ());
181     EXPECT_EQ (socket_b_up->GetLocalPortNumber (), socket_a_up->GetRemotePortNumber ());
182     EXPECT_NE (socket_a_up->GetLocalPortNumber (), socket_b_up->GetLocalPortNumber ());
183     EXPECT_STREQ ("127.0.0.1", socket_a_up->GetRemoteIPAddress ().c_str ());
184     EXPECT_STREQ ("127.0.0.1", socket_b_up->GetRemoteIPAddress ().c_str ());
185 }
186 
187 TEST_F (SocketTest, UDPConnect)
188 {
189     Socket* socket_a;
190     Socket* socket_b;
191 
192     bool child_processes_inherit = false;
193     auto error = UDPSocket::Connect("127.0.0.1:0", child_processes_inherit, socket_a, socket_b);
194 
195     std::unique_ptr<Socket> a_up(socket_a);
196     std::unique_ptr<Socket> b_up(socket_b);
197 
198     EXPECT_TRUE(error.Success ());
199     EXPECT_TRUE(a_up->IsValid());
200     EXPECT_TRUE(b_up->IsValid());
201 }
202