1 files changed, 245 insertions, 0 deletions

diff --git a/include/lldb/Utility/ProcessInfo.h b/include/lldb/Utility/ProcessInfo.h
new file mode 100644
index 000000000000..a25c06cabdf6
--- /dev/null
+++ b/include/lldb/Utility/ProcessInfo.h
@@ -0,0 +1,245 @@
+//===-- ProcessInfo.h -------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UTILITY_PROCESSINFO_H
+#define LLDB_UTILITY_PROCESSINFO_H
+
+// LLDB headers
+#include "lldb/Utility/ArchSpec.h"
+#include "lldb/Utility/Args.h"
+#include "lldb/Utility/Environment.h"
+#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/NameMatches.h"
+
+#include <vector>
+
+namespace lldb_private {
+
+class UserIDResolver;
+
+// ProcessInfo
+//
+// A base class for information for a process. This can be used to fill
+// out information for a process prior to launching it, or it can be used for
+// an instance of a process and can be filled in with the existing values for
+// that process.
+class ProcessInfo {
+public:
+  ProcessInfo();
+
+  ProcessInfo(const char *name, const ArchSpec &arch, lldb::pid_t pid);
+
+  void Clear();
+
+  const char *GetName() const;
+
+  size_t GetNameLength() const;
+
+  FileSpec &GetExecutableFile() { return m_executable; }
+
+  void SetExecutableFile(const FileSpec &exe_file,
+                         bool add_exe_file_as_first_arg);
+
+  const FileSpec &GetExecutableFile() const { return m_executable; }
+
+  uint32_t GetUserID() const { return m_uid; }
+
+  uint32_t GetGroupID() const { return m_gid; }
+
+  bool UserIDIsValid() const { return m_uid != UINT32_MAX; }
+
+  bool GroupIDIsValid() const { return m_gid != UINT32_MAX; }
+
+  void SetUserID(uint32_t uid) { m_uid = uid; }
+
+  void SetGroupID(uint32_t gid) { m_gid = gid; }
+
+  ArchSpec &GetArchitecture() { return m_arch; }
+
+  const ArchSpec &GetArchitecture() const { return m_arch; }
+
+  void SetArchitecture(const ArchSpec &arch) { m_arch = arch; }
+
+  lldb::pid_t GetProcessID() const { return m_pid; }
+
+  void SetProcessID(lldb::pid_t pid) { m_pid = pid; }
+
+  bool ProcessIDIsValid() const { return m_pid != LLDB_INVALID_PROCESS_ID; }
+
+  void Dump(Stream &s, Platform *platform) const;
+
+  Args &GetArguments() { return m_arguments; }
+
+  const Args &GetArguments() const { return m_arguments; }
+
+  llvm::StringRef GetArg0() const;
+
+  void SetArg0(llvm::StringRef arg);
+
+  void SetArguments(const Args &args, bool first_arg_is_executable);
+
+  void SetArguments(char const **argv, bool first_arg_is_executable);
+
+  Environment &GetEnvironment() { return m_environment; }
+  const Environment &GetEnvironment() const { return m_environment; }
+
+protected:
+  FileSpec m_executable;
+  std::string m_arg0; // argv[0] if supported. If empty, then use m_executable.
+  // Not all process plug-ins support specifying an argv[0] that differs from
+  // the resolved platform executable (which is in m_executable)
+  Args m_arguments; // All program arguments except argv[0]
+  Environment m_environment;
+  uint32_t m_uid;
+  uint32_t m_gid;
+  ArchSpec m_arch;
+  lldb::pid_t m_pid;
+};
+
+// ProcessInstanceInfo
+//
+// Describes an existing process and any discoverable information that pertains
+// to that process.
+class ProcessInstanceInfo : public ProcessInfo {
+public:
+  ProcessInstanceInfo()
+      : ProcessInfo(), m_euid(UINT32_MAX), m_egid(UINT32_MAX),
+        m_parent_pid(LLDB_INVALID_PROCESS_ID) {}
+
+  ProcessInstanceInfo(const char *name, const ArchSpec &arch, lldb::pid_t pid)
+      : ProcessInfo(name, arch, pid), m_euid(UINT32_MAX), m_egid(UINT32_MAX),
+        m_parent_pid(LLDB_INVALID_PROCESS_ID) {}
+
+  void Clear() {
+    ProcessInfo::Clear();
+    m_euid = UINT32_MAX;
+    m_egid = UINT32_MAX;
+    m_parent_pid = LLDB_INVALID_PROCESS_ID;
+  }
+
+  uint32_t GetEffectiveUserID() const { return m_euid; }
+
+  uint32_t GetEffectiveGroupID() const { return m_egid; }
+
+  bool EffectiveUserIDIsValid() const { return m_euid != UINT32_MAX; }
+
+  bool EffectiveGroupIDIsValid() const { return m_egid != UINT32_MAX; }
+
+  void SetEffectiveUserID(uint32_t uid) { m_euid = uid; }
+
+  void SetEffectiveGroupID(uint32_t gid) { m_egid = gid; }
+
+  lldb::pid_t GetParentProcessID() const { return m_parent_pid; }
+
+  void SetParentProcessID(lldb::pid_t pid) { m_parent_pid = pid; }
+
+  bool ParentProcessIDIsValid() const {
+    return m_parent_pid != LLDB_INVALID_PROCESS_ID;
+  }
+
+  void Dump(Stream &s, UserIDResolver &resolver) const;
+
+  static void DumpTableHeader(Stream &s, bool show_args, bool verbose);
+
+  void DumpAsTableRow(Stream &s, UserIDResolver &resolver, bool show_args,
+                      bool verbose) const;
+
+protected:
+  uint32_t m_euid;
+  uint32_t m_egid;
+  lldb::pid_t m_parent_pid;
+};
+
+class ProcessInstanceInfoList {
+public:
+  ProcessInstanceInfoList() = default;
+
+  void Clear() { m_infos.clear(); }
+
+  size_t GetSize() { return m_infos.size(); }
+
+  void Append(const ProcessInstanceInfo &info) { m_infos.push_back(info); }
+
+  const char *GetProcessNameAtIndex(size_t idx) {
+    return ((idx < m_infos.size()) ? m_infos[idx].GetName() : nullptr);
+  }
+
+  size_t GetProcessNameLengthAtIndex(size_t idx) {
+    return ((idx < m_infos.size()) ? m_infos[idx].GetNameLength() : 0);
+  }
+
+  lldb::pid_t GetProcessIDAtIndex(size_t idx) {
+    return ((idx < m_infos.size()) ? m_infos[idx].GetProcessID() : 0);
+  }
+
+  bool GetInfoAtIndex(size_t idx, ProcessInstanceInfo &info) {
+    if (idx < m_infos.size()) {
+      info = m_infos[idx];
+      return true;
+    }
+    return false;
+  }
+
+  // You must ensure "idx" is valid before calling this function
+  const ProcessInstanceInfo &GetProcessInfoAtIndex(size_t idx) const {
+    assert(idx < m_infos.size());
+    return m_infos[idx];
+  }
+
+protected:
+  std::vector<ProcessInstanceInfo> m_infos;
+};
+
+// ProcessInstanceInfoMatch
+//
+// A class to help matching one ProcessInstanceInfo to another.
+
+class ProcessInstanceInfoMatch {
+public:
+  ProcessInstanceInfoMatch()
+      : m_match_info(), m_name_match_type(NameMatch::Ignore),
+        m_match_all_users(false) {}
+
+  ProcessInstanceInfoMatch(const char *process_name,
+                           NameMatch process_name_match_type)
+      : m_match_info(), m_name_match_type(process_name_match_type),
+        m_match_all_users(false) {
+    m_match_info.GetExecutableFile().SetFile(process_name,
+                                             FileSpec::Style::native);
+  }
+
+  ProcessInstanceInfo &GetProcessInfo() { return m_match_info; }
+
+  const ProcessInstanceInfo &GetProcessInfo() const { return m_match_info; }
+
+  bool GetMatchAllUsers() const { return m_match_all_users; }
+
+  void SetMatchAllUsers(bool b) { m_match_all_users = b; }
+
+  NameMatch GetNameMatchType() const { return m_name_match_type; }
+
+  void SetNameMatchType(NameMatch name_match_type) {
+    m_name_match_type = name_match_type;
+  }
+
+  bool NameMatches(const char *process_name) const;
+
+  bool Matches(const ProcessInstanceInfo &proc_info) const;
+
+  bool MatchAllProcesses() const;
+  void Clear();
+
+protected:
+  ProcessInstanceInfo m_match_info;
+  NameMatch m_name_match_type;
+  bool m_match_all_users;
+};
+
+} // namespace lldb_private
+
+#endif // #ifndef LLDB_UTILITY_PROCESSINFO_H