//===-- Host.h --------------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef liblldb_Host_h_
#define liblldb_Host_h_
#if defined(__cplusplus)

#include <stdarg.h>

#include <map>
#include <string>

#include "lldb/Core/StringList.h"
#include "lldb/Host/File.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/Host/HostThread.h"
#include "lldb/lldb-private-forward.h"
#include "lldb/lldb-private.h"

namespace lldb_private {

class FileAction;
class ProcessLaunchInfo;

//----------------------------------------------------------------------
/// @class Host Host.h "lldb/Host/Host.h"
/// @brief A class that provides host computer information.
///
/// Host is a class that answers information about the host operating
/// system.
//----------------------------------------------------------------------
class Host {
public:
  typedef std::function<bool(
      lldb::pid_t pid, bool exited,
      int signal,  // Zero for no signal
      int status)> // Exit value of process if signal is zero
      MonitorChildProcessCallback;

  //------------------------------------------------------------------
  /// Start monitoring a child process.
  ///
  /// Allows easy monitoring of child processes. \a callback will be
  /// called when the child process exits or if it gets a signal. The
  /// callback will only be called with signals if \a monitor_signals
  /// is \b true. \a callback will usually be called from another
  /// thread so the callback function must be thread safe.
  ///
  /// When the callback gets called, the return value indicates if
  /// monitoring should stop. If \b true is returned from \a callback
  /// the information will be removed. If \b false is returned then
  /// monitoring will continue. If the child process exits, the
  /// monitoring will automatically stop after the callback returned
  /// regardless of the callback return value.
  ///
  /// @param[in] callback
  ///     A function callback to call when a child receives a signal
  ///     (if \a monitor_signals is true) or a child exits.
  ///
  /// @param[in] pid
  ///     The process ID of a child process to monitor, -1 for all
  ///     processes.
  ///
  /// @param[in] monitor_signals
  ///     If \b true the callback will get called when the child
  ///     process gets a signal. If \b false, the callback will only
  ///     get called if the child process exits.
  ///
  /// @return
  ///     A thread handle that can be used to cancel the thread that
  ///     was spawned to monitor \a pid.
  ///
  /// @see static void Host::StopMonitoringChildProcess (uint32_t)
  //------------------------------------------------------------------
  static HostThread
  StartMonitoringChildProcess(const MonitorChildProcessCallback &callback,
                              lldb::pid_t pid, bool monitor_signals);

  enum SystemLogType { eSystemLogWarning, eSystemLogError };

  static void SystemLog(SystemLogType type, const char *format, ...)
      __attribute__((format(printf, 2, 3)));

  static void SystemLog(SystemLogType type, const char *format, va_list args);

  //------------------------------------------------------------------
  /// Get the process ID for the calling process.
  ///
  /// @return
  ///     The process ID for the current process.
  //------------------------------------------------------------------
  static lldb::pid_t GetCurrentProcessID();

  static void Kill(lldb::pid_t pid, int signo);

  //------------------------------------------------------------------
  /// Get the thread ID for the calling thread in the current process.
  ///
  /// @return
  ///     The thread ID for the calling thread in the current process.
  //------------------------------------------------------------------
  static lldb::tid_t GetCurrentThreadID();

  //------------------------------------------------------------------
  /// Get the thread token (the one returned by ThreadCreate when the thread was
  /// created) for the
  /// calling thread in the current process.
  ///
  /// @return
  ///     The thread token for the calling thread in the current process.
  //------------------------------------------------------------------
  static lldb::thread_t GetCurrentThread();

  static const char *GetSignalAsCString(int signo);

  typedef void (*ThreadLocalStorageCleanupCallback)(void *p);

  static lldb::thread_key_t
  ThreadLocalStorageCreate(ThreadLocalStorageCleanupCallback callback);

  static void *ThreadLocalStorageGet(lldb::thread_key_t key);

  static void ThreadLocalStorageSet(lldb::thread_key_t key, void *value);

  //------------------------------------------------------------------
  /// Given an address in the current process (the process that
  /// is running the LLDB code), return the name of the module that
  /// it comes from. This can be useful when you need to know the
  /// path to the shared library that your code is running in for
  /// loading resources that are relative to your binary.
  ///
  /// @param[in] host_addr
  ///     The pointer to some code in the current process.
  ///
  /// @return
  ///     \b A file spec with the module that contains \a host_addr,
  ///     which may be invalid if \a host_addr doesn't fall into
  ///     any valid module address range.
  //------------------------------------------------------------------
  static FileSpec GetModuleFileSpecForHostAddress(const void *host_addr);

  //------------------------------------------------------------------
  /// If you have an executable that is in a bundle and want to get
  /// back to the bundle directory from the path itself, this
  /// function will change a path to a file within a bundle to the
  /// bundle directory itself.
  ///
  /// @param[in] file
  ///     A file spec that might point to a file in a bundle.
  ///
  /// @param[out] bundle_directory
  ///     An object will be filled in with the bundle directory for
  ///     the bundle when \b true is returned. Otherwise \a file is
  ///     left untouched and \b false is returned.
  ///
  /// @return
  ///     \b true if \a file was resolved in \a bundle_directory,
  ///     \b false otherwise.
  //------------------------------------------------------------------
  static bool GetBundleDirectory(const FileSpec &file,
                                 FileSpec &bundle_directory);

  //------------------------------------------------------------------
  /// When executable files may live within a directory, where the
  /// directory represents an executable bundle (like the MacOSX
  /// app bundles), then locate the executable within the containing
  /// bundle.
  ///
  /// @param[in,out] file
  ///     A file spec that currently points to the bundle that will
  ///     be filled in with the executable path within the bundle
  ///     if \b true is returned. Otherwise \a file is left untouched.
  ///
  /// @return
  ///     \b true if \a file was resolved, \b false if this function
  ///     was not able to resolve the path.
  //------------------------------------------------------------------
  static bool ResolveExecutableInBundle(FileSpec &file);

  static uint32_t FindProcesses(const ProcessInstanceInfoMatch &match_info,
                                ProcessInstanceInfoList &proc_infos);

  typedef std::map<lldb::pid_t, bool> TidMap;
  typedef std::pair<lldb::pid_t, bool> TidPair;
  static bool FindProcessThreads(const lldb::pid_t pid, TidMap &tids_to_attach);

  static bool GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &proc_info);

#if (defined(__APPLE__) || defined(__linux__) || defined(__FreeBSD__) ||       \
     defined(__GLIBC__) || defined(__NetBSD__)) &&                             \
    !defined(__ANDROID__)

  static short GetPosixspawnFlags(const ProcessLaunchInfo &launch_info);

  static Error LaunchProcessPosixSpawn(const char *exe_path,
                                       const ProcessLaunchInfo &launch_info,
                                       lldb::pid_t &pid);

  static bool AddPosixSpawnFileAction(void *file_actions,
                                      const FileAction *info, Log *log,
                                      Error &error);

#endif

  static const lldb::UnixSignalsSP &GetUnixSignals();

  static Error LaunchProcess(ProcessLaunchInfo &launch_info);

  //------------------------------------------------------------------
  /// Perform expansion of the command-line for this launch info
  /// This can potentially involve wildcard expansion
  //  environment variable replacement, and whatever other
  //  argument magic the platform defines as part of its typical
  //  user experience
  //------------------------------------------------------------------
  static Error ShellExpandArguments(ProcessLaunchInfo &launch_info);

  // TODO: Convert this function to take a StringRef.
  static Error RunShellCommand(
      const char *command,         // Shouldn't be NULL
      const FileSpec &working_dir, // Pass empty FileSpec to use the current
                                   // working directory
      int *status_ptr, // Pass NULL if you don't want the process exit status
      int *signo_ptr,  // Pass NULL if you don't want the signal that caused the
                       // process to exit
      std::string
          *command_output, // Pass NULL if you don't want the command output
      uint32_t timeout_sec,
      bool run_in_default_shell = true);

  static Error RunShellCommand(
      const Args &args,
      const FileSpec &working_dir, // Pass empty FileSpec to use the current
                                   // working directory
      int *status_ptr, // Pass NULL if you don't want the process exit status
      int *signo_ptr,  // Pass NULL if you don't want the signal that caused the
                       // process to exit
      std::string
          *command_output, // Pass NULL if you don't want the command output
      uint32_t timeout_sec,
      bool run_in_default_shell = true);

  static lldb::DataBufferSP GetAuxvData(lldb_private::Process *process);

  static lldb::DataBufferSP GetAuxvData(lldb::pid_t pid);

  static bool OpenFileInExternalEditor(const FileSpec &file_spec,
                                       uint32_t line_no);

  static size_t GetEnvironment(StringList &env);
};

} // namespace lldb_private

#endif // #if defined(__cplusplus)
#endif // liblldb_Host_h_
