1 //===-- RNBSocketTest.cpp -------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "gtest/gtest.h"
10 
11 #include <arpa/inet.h>
12 #include <sys/sysctl.h>
13 #include <unistd.h>
14 
15 #include "RNBDefs.h"
16 #include "RNBSocket.h"
17 #include "lldb/Host/Socket.h"
18 #include "lldb/Host/common/TCPSocket.h"
19 #include "llvm/Testing/Support/Error.h"
20 
21 using namespace lldb_private;
22 
23 std::string hello = "Hello, world!";
24 std::string goodbye = "Goodbye!";
25 
26 static void ServerCallbackv4(const void *baton, in_port_t port) {
27   auto child_pid = fork();
28   if (child_pid == 0) {
29     char addr_buffer[256];
30     sprintf(addr_buffer, "%s:%d", (const char *)baton, port);
31     llvm::Expected<std::unique_ptr<Socket>> socket_or_err =
32         Socket::TcpConnect(addr_buffer, false);
33     ASSERT_THAT_EXPECTED(socket_or_err, llvm::Succeeded());
34     Socket *client_socket = socket_or_err->get();
35 
36     char buffer[32];
37     size_t read_size = 32;
38     Status err = client_socket->Read((void *)&buffer[0], read_size);
39     if (err.Fail())
40       abort();
41     std::string Recv(&buffer[0], read_size);
42     if (Recv != hello)
43       abort();
44     size_t write_size = goodbye.length();
45     err = client_socket->Write(goodbye.c_str(), write_size);
46     if (err.Fail())
47       abort();
48     if (write_size != goodbye.length())
49       abort();
50     delete client_socket;
51     exit(0);
52   }
53 }
54 
55 void TestSocketListen(const char *addr) {
56   // Skip IPv6 tests if there isn't a valid interafce
57   auto addresses = lldb_private::SocketAddress::GetAddressInfo(
58       addr, NULL, AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP);
59   if (addresses.size() == 0)
60     return;
61 
62   char addr_wrap[256];
63   if (addresses.front().GetFamily() == AF_INET6)
64     sprintf(addr_wrap, "[%s]", addr);
65   else
66     sprintf(addr_wrap, "%s", addr);
67 
68   RNBSocket server_socket;
69   auto result =
70       server_socket.Listen(addr, 0, ServerCallbackv4, (const void *)addr_wrap);
71   ASSERT_TRUE(result == rnb_success);
72   result = server_socket.Write(hello.c_str(), hello.length());
73   ASSERT_TRUE(result == rnb_success);
74   std::string bye;
75   result = server_socket.Read(bye);
76   ASSERT_TRUE(result == rnb_success);
77   ASSERT_EQ(bye, goodbye);
78 
79   int exit_status;
80   wait(&exit_status);
81   ASSERT_EQ(exit_status, 0);
82 }
83 
84 TEST(RNBSocket, LoopBackListenIPv4) { TestSocketListen("127.0.0.1"); }
85 
86 TEST(RNBSocket, LoopBackListenIPv6) { TestSocketListen("::1"); }
87 
88 TEST(RNBSocket, AnyListen) { TestSocketListen("*"); }
89 
90 void TestSocketConnect(const char *addr) {
91   // Skip IPv6 tests if there isn't a valid interafce
92   auto addresses = lldb_private::SocketAddress::GetAddressInfo(
93       addr, NULL, AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP);
94   if (addresses.size() == 0)
95     return;
96 
97   char addr_wrap[256];
98   if (addresses.front().GetFamily() == AF_INET6)
99     sprintf(addr_wrap, "[%s]:0", addr);
100   else
101     sprintf(addr_wrap, "%s:0", addr);
102 
103   Socket *server_socket;
104   Predicate<uint16_t> port_predicate;
105   port_predicate.SetValue(0, eBroadcastNever);
106   llvm::Expected<std::unique_ptr<Socket>> socket_or_err =
107       Socket::TcpListen(addr_wrap, false, &port_predicate);
108   ASSERT_THAT_EXPECTED(socket_or_err, llvm::Succeeded());
109   server_socket = socket_or_err->get();
110 
111   auto port = ((TCPSocket *)server_socket)->GetLocalPortNumber();
112   auto child_pid = fork();
113   if (child_pid != 0) {
114     RNBSocket client_socket;
115     auto result = client_socket.Connect(addr, port);
116     ASSERT_TRUE(result == rnb_success);
117     result = client_socket.Write(hello.c_str(), hello.length());
118     ASSERT_TRUE(result == rnb_success);
119     std::string bye;
120     result = client_socket.Read(bye);
121     ASSERT_TRUE(result == rnb_success);
122     ASSERT_EQ(bye, goodbye);
123   } else {
124     Socket *connected_socket;
125     Status err = server_socket->Accept(connected_socket);
126     if (err.Fail()) {
127       llvm::errs() << err.AsCString();
128       abort();
129     }
130     char buffer[32];
131     size_t read_size = 32;
132     err = connected_socket->Read((void *)&buffer[0], read_size);
133     if (err.Fail()) {
134       llvm::errs() << err.AsCString();
135       abort();
136     }
137     std::string Recv(&buffer[0], read_size);
138     if (Recv != hello) {
139       llvm::errs() << err.AsCString();
140       abort();
141     }
142     size_t write_size = goodbye.length();
143     err = connected_socket->Write(goodbye.c_str(), write_size);
144     if (err.Fail()) {
145       llvm::errs() << err.AsCString();
146       abort();
147     }
148     if (write_size != goodbye.length()) {
149       llvm::errs() << err.AsCString();
150       abort();
151     }
152     exit(0);
153   }
154   int exit_status;
155   wait(&exit_status);
156   ASSERT_EQ(exit_status, 0);
157 }
158 
159 TEST(RNBSocket, LoopBackConnectIPv4) { TestSocketConnect("127.0.0.1"); }
160 
161 TEST(RNBSocket, LoopBackConnectIPv6) { TestSocketConnect("::1"); }
162