1//===-- lldb-platform.cpp ---------------------------------------*- C++ -*-===//
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 <cerrno>
10#if defined(__APPLE__)
11#include <netinet/in.h>
12#endif
13#include <csignal>
14#include <cstdint>
15#include <cstdio>
16#include <cstdlib>
17#include <cstring>
18#if !defined(_WIN32)
19#include <sys/wait.h>
20#endif
21#include <fstream>
22#include <optional>
23
24#include "llvm/Support/FileSystem.h"
25#include "llvm/Support/FileUtilities.h"
26#include "llvm/Support/WithColor.h"
27#include "llvm/Support/raw_ostream.h"
28
29#include "Acceptor.h"
30#include "LLDBServerUtilities.h"
31#include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h"
32#include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
33#include "lldb/Host/ConnectionFileDescriptor.h"
34#include "lldb/Host/HostGetOpt.h"
35#include "lldb/Host/OptionParser.h"
36#include "lldb/Host/common/TCPSocket.h"
37#include "lldb/Utility/FileSpec.h"
38#include "lldb/Utility/Status.h"
39
40using namespace lldb;
41using namespace lldb_private;
42using namespace lldb_private::lldb_server;
43using namespace lldb_private::process_gdb_remote;
44using namespace llvm;
45
46// option descriptors for getopt_long_only()
47
48static int g_debug = 0;
49static int g_verbose = 0;
50static int g_server = 0;
51
52static struct option g_long_options[] = {
53    {"debug", no_argument, &g_debug, 1},
54    {"verbose", no_argument, &g_verbose, 1},
55    {"log-file", required_argument, nullptr, 'l'},
56    {"log-channels", required_argument, nullptr, 'c'},
57    {"listen", required_argument, nullptr, 'L'},
58    {"port-offset", required_argument, nullptr, 'p'},
59    {"gdbserver-port", required_argument, nullptr, 'P'},
60    {"min-gdbserver-port", required_argument, nullptr, 'm'},
61    {"max-gdbserver-port", required_argument, nullptr, 'M'},
62    {"socket-file", required_argument, nullptr, 'f'},
63    {"server", no_argument, &g_server, 1},
64    {nullptr, 0, nullptr, 0}};
65
66#if defined(__APPLE__)
67#define LOW_PORT (IPPORT_RESERVED)
68#define HIGH_PORT (IPPORT_HIFIRSTAUTO)
69#else
70#define LOW_PORT (1024u)
71#define HIGH_PORT (49151u)
72#endif
73
74#if !defined(_WIN32)
75// Watch for signals
76static void signal_handler(int signo) {
77  switch (signo) {
78  case SIGHUP:
79    // Use SIGINT first, if that does not work, use SIGHUP as a last resort.
80    // And we should not call exit() here because it results in the global
81    // destructors to be invoked and wreaking havoc on the threads still
82    // running.
83    llvm::errs() << "SIGHUP received, exiting lldb-server...\n";
84    abort();
85    break;
86  }
87}
88#endif
89
90static void display_usage(const char *progname, const char *subcommand) {
91  fprintf(stderr, "Usage:\n  %s %s [--log-file log-file-name] [--log-channels "
92                  "log-channel-list] [--port-file port-file-path] --server "
93                  "--listen port\n",
94          progname, subcommand);
95  exit(0);
96}
97
98static Status save_socket_id_to_file(const std::string &socket_id,
99                                     const FileSpec &file_spec) {
100  FileSpec temp_file_spec(file_spec.GetDirectory().GetStringRef());
101  Status error(llvm::sys::fs::create_directory(temp_file_spec.GetPath()));
102  if (error.Fail())
103    return Status("Failed to create directory %s: %s",
104                  temp_file_spec.GetPath().c_str(), error.AsCString());
105
106  llvm::SmallString<64> temp_file_path;
107  temp_file_spec.AppendPathComponent("port-file.%%%%%%");
108  temp_file_path = temp_file_spec.GetPath();
109
110  Status status;
111  if (auto Err =
112          handleErrors(llvm::writeFileAtomically(
113                           temp_file_path, file_spec.GetPath(), socket_id),
114                       [&status, &file_spec](const AtomicFileWriteError &E) {
115                         std::string ErrorMsgBuffer;
116                         llvm::raw_string_ostream S(ErrorMsgBuffer);
117                         E.log(S);
118
119                         switch (E.Error) {
120                         case atomic_write_error::failed_to_create_uniq_file:
121                           status = Status("Failed to create temp file: %s",
122                                           ErrorMsgBuffer.c_str());
123                           break;
124                         case atomic_write_error::output_stream_error:
125                           status = Status("Failed to write to port file.");
126                           break;
127                         case atomic_write_error::failed_to_rename_temp_file:
128                           status = Status("Failed to rename file %s to %s: %s",
129                                           ErrorMsgBuffer.c_str(),
130                                           file_spec.GetPath().c_str(),
131                                           ErrorMsgBuffer.c_str());
132                           break;
133                         }
134                       })) {
135    return Status("Failed to atomically write file %s",
136                  file_spec.GetPath().c_str());
137  }
138  return status;
139}
140
141// main
142int main_platform(int argc, char *argv[]) {
143  const char *progname = argv[0];
144  const char *subcommand = argv[1];
145  argc--;
146  argv++;
147#if !defined(_WIN32)
148  signal(SIGPIPE, SIG_IGN);
149  signal(SIGHUP, signal_handler);
150#endif
151  int long_option_index = 0;
152  Status error;
153  std::string listen_host_port;
154  int ch;
155
156  std::string log_file;
157  StringRef
158      log_channels; // e.g. "lldb process threads:gdb-remote default:linux all"
159
160  GDBRemoteCommunicationServerPlatform::PortMap gdbserver_portmap;
161  int min_gdbserver_port = 0;
162  int max_gdbserver_port = 0;
163  uint16_t port_offset = 0;
164
165  FileSpec socket_file;
166  bool show_usage = false;
167  int option_error = 0;
168  int socket_error = -1;
169
170  std::string short_options(OptionParser::GetShortOptionString(g_long_options));
171
172#if __GLIBC__
173  optind = 0;
174#else
175  optreset = 1;
176  optind = 1;
177#endif
178
179  while ((ch = getopt_long_only(argc, argv, short_options.c_str(),
180                                g_long_options, &long_option_index)) != -1) {
181    switch (ch) {
182    case 0: // Any optional that auto set themselves will return 0
183      break;
184
185    case 'L':
186      listen_host_port.append(optarg);
187      break;
188
189    case 'l': // Set Log File
190      if (optarg && optarg[0])
191        log_file.assign(optarg);
192      break;
193
194    case 'c': // Log Channels
195      if (optarg && optarg[0])
196        log_channels = StringRef(optarg);
197      break;
198
199    case 'f': // Socket file
200      if (optarg && optarg[0])
201        socket_file.SetFile(optarg, FileSpec::Style::native);
202      break;
203
204    case 'p': {
205      if (!llvm::to_integer(optarg, port_offset)) {
206        WithColor::error() << "invalid port offset string " << optarg << "\n";
207        option_error = 4;
208        break;
209      }
210      if (port_offset < LOW_PORT || port_offset > HIGH_PORT) {
211        WithColor::error() << llvm::formatv(
212            "port offset {0} is not in the "
213            "valid user port range of {1} - {2}\n",
214            port_offset, LOW_PORT, HIGH_PORT);
215        option_error = 5;
216      }
217    } break;
218
219    case 'P':
220    case 'm':
221    case 'M': {
222      uint16_t portnum;
223      if (!llvm::to_integer(optarg, portnum)) {
224        WithColor::error() << "invalid port number string " << optarg << "\n";
225        option_error = 2;
226        break;
227      }
228      if (portnum < LOW_PORT || portnum > HIGH_PORT) {
229        WithColor::error() << llvm::formatv(
230            "port number {0} is not in the "
231            "valid user port range of {1} - {2}\n",
232            portnum, LOW_PORT, HIGH_PORT);
233        option_error = 1;
234        break;
235      }
236      if (ch == 'P')
237        gdbserver_portmap.AllowPort(portnum);
238      else if (ch == 'm')
239        min_gdbserver_port = portnum;
240      else
241        max_gdbserver_port = portnum;
242    } break;
243
244    case 'h': /* fall-through is intentional */
245    case '?':
246      show_usage = true;
247      break;
248    }
249  }
250
251  if (!LLDBServerUtilities::SetupLogging(log_file, log_channels, 0))
252    return -1;
253
254  // Make a port map for a port range that was specified.
255  if (min_gdbserver_port && min_gdbserver_port < max_gdbserver_port) {
256    gdbserver_portmap = GDBRemoteCommunicationServerPlatform::PortMap(
257        min_gdbserver_port, max_gdbserver_port);
258  } else if (min_gdbserver_port || max_gdbserver_port) {
259    WithColor::error() << llvm::formatv(
260        "--min-gdbserver-port ({0}) is not lower than "
261        "--max-gdbserver-port ({1})\n",
262        min_gdbserver_port, max_gdbserver_port);
263    option_error = 3;
264  }
265
266  // Print usage and exit if no listening port is specified.
267  if (listen_host_port.empty())
268    show_usage = true;
269
270  if (show_usage || option_error) {
271    display_usage(progname, subcommand);
272    exit(option_error);
273  }
274
275  // Skip any options we consumed with getopt_long_only.
276  argc -= optind;
277  argv += optind;
278  lldb_private::Args inferior_arguments;
279  inferior_arguments.SetArguments(argc, const_cast<const char **>(argv));
280
281  const bool children_inherit_listen_socket = false;
282  // the test suite makes many connections in parallel, let's not miss any.
283  // The highest this should get reasonably is a function of the number
284  // of target CPUs. For now, let's just use 100.
285  const int backlog = 100;
286
287  std::unique_ptr<Acceptor> acceptor_up(Acceptor::Create(
288      listen_host_port, children_inherit_listen_socket, error));
289  if (error.Fail()) {
290    fprintf(stderr, "failed to create acceptor: %s", error.AsCString());
291    exit(socket_error);
292  }
293
294  error = acceptor_up->Listen(backlog);
295  if (error.Fail()) {
296    printf("failed to listen: %s\n", error.AsCString());
297    exit(socket_error);
298  }
299  if (socket_file) {
300    error =
301        save_socket_id_to_file(acceptor_up->GetLocalSocketId(), socket_file);
302    if (error.Fail()) {
303      fprintf(stderr, "failed to write socket id to %s: %s\n",
304              socket_file.GetPath().c_str(), error.AsCString());
305      return 1;
306    }
307  }
308
309  do {
310    GDBRemoteCommunicationServerPlatform platform(
311        acceptor_up->GetSocketProtocol(), acceptor_up->GetSocketScheme());
312
313    if (port_offset > 0)
314      platform.SetPortOffset(port_offset);
315
316    if (!gdbserver_portmap.empty()) {
317      platform.SetPortMap(std::move(gdbserver_portmap));
318    }
319
320    const bool children_inherit_accept_socket = true;
321    Connection *conn = nullptr;
322    error = acceptor_up->Accept(children_inherit_accept_socket, conn);
323    if (error.Fail()) {
324      WithColor::error() << error.AsCString() << '\n';
325      exit(socket_error);
326    }
327    printf("Connection established.\n");
328    if (g_server) {
329      // Collect child zombie processes.
330#if !defined(_WIN32)
331      while (waitpid(-1, nullptr, WNOHANG) > 0)
332        ;
333#endif
334      if (fork()) {
335        // Parent doesn't need a connection to the lldb client
336        delete conn;
337
338        // Parent will continue to listen for new connections.
339        continue;
340      } else {
341        // Child process will handle the connection and exit.
342        g_server = 0;
343        // Listening socket is owned by parent process.
344        acceptor_up.release();
345      }
346    } else {
347      // If not running as a server, this process will not accept
348      // connections while a connection is active.
349      acceptor_up.reset();
350    }
351    platform.SetConnection(std::unique_ptr<Connection>(conn));
352
353    if (platform.IsConnected()) {
354      if (inferior_arguments.GetArgumentCount() > 0) {
355        lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
356        std::optional<uint16_t> port = 0;
357        std::string socket_name;
358        Status error = platform.LaunchGDBServer(inferior_arguments,
359                                                "", // hostname
360                                                pid, port, socket_name);
361        if (error.Success())
362          platform.SetPendingGdbServer(pid, *port, socket_name);
363        else
364          fprintf(stderr, "failed to start gdbserver: %s\n", error.AsCString());
365      }
366
367      bool interrupt = false;
368      bool done = false;
369      while (!interrupt && !done) {
370        if (platform.GetPacketAndSendResponse(std::nullopt, error, interrupt,
371                                              done) !=
372            GDBRemoteCommunication::PacketResult::Success)
373          break;
374      }
375
376      if (error.Fail())
377        WithColor::error() << error.AsCString() << '\n';
378    }
379  } while (g_server);
380
381  fprintf(stderr, "lldb-server exiting...\n");
382
383  return 0;
384}
385