Add --port-file flag to lldb-platform to store port number which platform is listening

[ovyalov]

Summary

If platform listens on dynamically allocated port (when runs as "--listen *:0") --port-file will be used to store port number which client can use to connect to.

[tberghammer]

LGTM

tools/lldb-server/lldb-platform.cpp

197

(nit): Indentation

[ovyalov]

tools/lldb-server/lldb-platform.cpp

197

Fixed.

[ovyalov]

Files:

/lldb/trunk/tools/lldb-server/lldb-platform.cpp

Users:

ovyalov (Author)

http://reviews.llvm.org/rL241479

tools/lldb-server/lldb-platform.cpp

 #include <signal.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/wait.h>
 
 // C++ Includes
+#include <fstream>
 
 // Other libraries and framework includes
 #include "lldb/Core/Error.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
+#include "lldb/Host/FileSpec.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostGetOpt.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Host/Socket.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/FileUtilities.h"
 #include "LLDBServerUtilities.h"
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h"
 #include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::lldb_server;
 using namespace lldb_private::process_gdb_remote;
static struct option g_long_options[] =
     { "verbose",            no_argument,        &g_verbose,         1   },
     { "log-file",           required_argument,  NULL,               'l' },
     { "log-channels",       required_argument,  NULL,               'c' },
     { "listen",             required_argument,  NULL,               'L' },
     { "port-offset",        required_argument,  NULL,               'p' },
     { "gdbserver-port",     required_argument,  NULL,               'P' },
     { "min-gdbserver-port", required_argument,  NULL,               'm' },
     { "max-gdbserver-port", required_argument,  NULL,               'M' },
+    { "port-file",          required_argument,  NULL,               'f' },
     { "server",             no_argument,        &g_server,          1   },
     { NULL,                 0,                  NULL,               0   }
 };
 
 #if defined (__APPLE__)
 #define LOW_PORT    (IPPORT_RESERVED)
 #define HIGH_PORT   (IPPORT_HIFIRSTAUTO)
 #else
case SIGHUP:
         abort();
         break;
     }
 }
 
 static void
 display_usage (const char *progname, const char *subcommand)
 {
-    fprintf(stderr, "Usage:\n  %s %s [--log-file log-file-name] [--log-channels log-channel-list] --server --listen port\n", progname, subcommand);
+    fprintf(stderr, "Usage:\n  %s %s [--log-file log-file-name] [--log-channels log-channel-list] [--port-file port-file-path] --server --listen port\n", progname, subcommand);
     exit(0);
 }
 
+static Error
+save_port_to_file(const uint16_t port, const FileSpec &port_file_spec)
+{
+    const ConstString& port_file_dir = port_file_spec.GetDirectory();
+    auto error = FileSystem::MakeDirectory(
+        FileSpec(port_file_dir.AsCString(), false), eFilePermissionsDirectoryDefault);
+    if (error.Fail())
+       return Error("Failed to create directory %s: %s", port_file_dir.AsCString(), error.AsCString());
+
+    llvm::SmallString<PATH_MAX> temp_file_path;
+    auto err_code = llvm::sys::fs::createTemporaryFile(
+        port_file_spec.GetPath().c_str(), "", temp_file_path);
+    if (err_code)
+        return Error("Failed to create temp file: %s", err_code.message().c_str());
+
+    llvm::FileRemover tmp_file_remover(temp_file_path.c_str());
+
+    {
+        std::ofstream temp_file(temp_file_path.c_str(), std::ios::out);
+        if (!temp_file.is_open())
+            return Error("Failed to open temp file %s", temp_file_path.c_str());
+        temp_file << port;
+    }
+
+    err_code = llvm::sys::fs::rename(temp_file_path.c_str(), port_file_spec.GetPath().c_str());
+    if (err_code)
+        return Error("Failed to rename file %s to %s: %s",
+                     temp_file_path.c_str(), port_file_spec.GetPath().c_str(), err_code.message().c_str());
+
+    tmp_file_remover.releaseFile();
+    return Error();
+}
+
 //----------------------------------------------------------------------
 // main
 //----------------------------------------------------------------------
 int
 main_platform (int argc, char *argv[])
 {
     const char *progname = argv[0];
     const char *subcommand = argv[1];
     argc--;
     argv++;
     signal (SIGPIPE, SIG_IGN);
     signal (SIGHUP, signal_handler);
     int long_option_index = 0;
     Error error;
     std::string listen_host_port;
     int ch;
 
     std::string log_file;
     StringRef log_channels; // e.g. "lldb process threads:gdb-remote default:linux all"
-  
     GDBRemoteCommunicationServerPlatform::PortMap gdbserver_portmap;
     int min_gdbserver_port = 0;
     int max_gdbserver_port = 0;
     uint16_t port_offset = 0;
-    
+    FileSpec port_file;
     bool show_usage = false;
     int option_error = 0;
     int socket_error = -1;
     
     std::string short_options(OptionParser::GetShortOptionString(g_long_options));
                             
 #if __GLIBC__
     optind = 0;
while ((ch = getopt_long_only(argc, argv, short_options.c_str(), g_long_options, &long_option_index)) != -1)
                 log_file.assign(optarg);
             break;
 
         case 'c': // Log Channels
             if (optarg && optarg[0])
                 log_channels = StringRef(optarg);
             break;
 
+        case 'f': // Port file
+            if (optarg && optarg[0])
+              port_file.SetFile(optarg, false);
+            break;
+
         case 'p':
             {
                 char *end = NULL;
                 long tmp_port_offset = strtoul(optarg, &end, 0);
                 if (end && *end == '\0')
                 {
                     if (LOW_PORT <= tmp_port_offset && tmp_port_offset <= HIGH_PORT)
                     {
#endif
     error = Socket::TcpListen(listen_host_port.c_str(), children_inherit_listen_socket, socket, NULL, backlog);
     if (error.Fail())
     {
         printf("error: %s\n", error.AsCString());
         exit(socket_error);
     }
     listening_socket_up.reset(socket);
     printf ("Listening for a connection from %u...\n", listening_socket_up->GetLocalPortNumber());
+    if (port_file)
+    {
+        error = save_port_to_file(listening_socket_up->GetLocalPortNumber(), port_file);
+        if (error.Fail())
+        {
+            fprintf(stderr, "failed to write port to %s: %s", port_file.GetPath().c_str(), error.AsCString());
+            return 1;
+        }
+    }
 
     do {
         GDBRemoteCommunicationServerPlatform platform;
         
         if (port_offset > 0)
             platform.SetPortOffset(port_offset);
 
         if (!gdbserver_portmap.empty())