1 //===-- SBLaunchInfo.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 "lldb/API/SBLaunchInfo.h" 10 #include "SBReproducerPrivate.h" 11 12 #include "lldb/API/SBFileSpec.h" 13 #include "lldb/API/SBListener.h" 14 #include "lldb/Host/ProcessLaunchInfo.h" 15 16 using namespace lldb; 17 using namespace lldb_private; 18 19 class lldb_private::SBLaunchInfoImpl : public ProcessLaunchInfo { 20 public: 21 SBLaunchInfoImpl() 22 : ProcessLaunchInfo(), m_envp(GetEnvironment().getEnvp()) {} 23 24 const char *const *GetEnvp() const { return m_envp; } 25 void RegenerateEnvp() { m_envp = GetEnvironment().getEnvp(); } 26 27 SBLaunchInfoImpl &operator=(const ProcessLaunchInfo &rhs) { 28 ProcessLaunchInfo::operator=(rhs); 29 RegenerateEnvp(); 30 return *this; 31 } 32 33 private: 34 Environment::Envp m_envp; 35 }; 36 37 SBLaunchInfo::SBLaunchInfo(const char **argv) 38 : m_opaque_sp(new SBLaunchInfoImpl()) { 39 LLDB_RECORD_CONSTRUCTOR(SBLaunchInfo, (const char **), argv); 40 41 m_opaque_sp->GetFlags().Reset(eLaunchFlagDebug | eLaunchFlagDisableASLR); 42 if (argv && argv[0]) 43 m_opaque_sp->GetArguments().SetArguments(argv); 44 } 45 46 SBLaunchInfo::~SBLaunchInfo() {} 47 48 const lldb_private::ProcessLaunchInfo &SBLaunchInfo::ref() const { 49 return *m_opaque_sp; 50 } 51 52 void SBLaunchInfo::set_ref(const ProcessLaunchInfo &info) { 53 *m_opaque_sp = info; 54 } 55 56 lldb::pid_t SBLaunchInfo::GetProcessID() { 57 LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBLaunchInfo, GetProcessID); 58 59 return m_opaque_sp->GetProcessID(); 60 } 61 62 uint32_t SBLaunchInfo::GetUserID() { 63 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetUserID); 64 65 return m_opaque_sp->GetUserID(); 66 } 67 68 uint32_t SBLaunchInfo::GetGroupID() { 69 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetGroupID); 70 71 return m_opaque_sp->GetGroupID(); 72 } 73 74 bool SBLaunchInfo::UserIDIsValid() { 75 LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, UserIDIsValid); 76 77 return m_opaque_sp->UserIDIsValid(); 78 } 79 80 bool SBLaunchInfo::GroupIDIsValid() { 81 LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GroupIDIsValid); 82 83 return m_opaque_sp->GroupIDIsValid(); 84 } 85 86 void SBLaunchInfo::SetUserID(uint32_t uid) { 87 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t), uid); 88 89 m_opaque_sp->SetUserID(uid); 90 } 91 92 void SBLaunchInfo::SetGroupID(uint32_t gid) { 93 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t), gid); 94 95 m_opaque_sp->SetGroupID(gid); 96 } 97 98 SBFileSpec SBLaunchInfo::GetExecutableFile() { 99 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile); 100 101 return LLDB_RECORD_RESULT(SBFileSpec(m_opaque_sp->GetExecutableFile())); 102 } 103 104 void SBLaunchInfo::SetExecutableFile(SBFileSpec exe_file, 105 bool add_as_first_arg) { 106 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetExecutableFile, 107 (lldb::SBFileSpec, bool), exe_file, add_as_first_arg); 108 109 m_opaque_sp->SetExecutableFile(exe_file.ref(), add_as_first_arg); 110 } 111 112 SBListener SBLaunchInfo::GetListener() { 113 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBLaunchInfo, GetListener); 114 115 return LLDB_RECORD_RESULT(SBListener(m_opaque_sp->GetListener())); 116 } 117 118 void SBLaunchInfo::SetListener(SBListener &listener) { 119 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &), 120 listener); 121 122 m_opaque_sp->SetListener(listener.GetSP()); 123 } 124 125 uint32_t SBLaunchInfo::GetNumArguments() { 126 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumArguments); 127 128 return m_opaque_sp->GetArguments().GetArgumentCount(); 129 } 130 131 const char *SBLaunchInfo::GetArgumentAtIndex(uint32_t idx) { 132 LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex, (uint32_t), 133 idx); 134 135 return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx); 136 } 137 138 void SBLaunchInfo::SetArguments(const char **argv, bool append) { 139 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetArguments, (const char **, bool), 140 argv, append); 141 142 if (append) { 143 if (argv) 144 m_opaque_sp->GetArguments().AppendArguments(argv); 145 } else { 146 if (argv) 147 m_opaque_sp->GetArguments().SetArguments(argv); 148 else 149 m_opaque_sp->GetArguments().Clear(); 150 } 151 } 152 153 uint32_t SBLaunchInfo::GetNumEnvironmentEntries() { 154 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries); 155 156 return m_opaque_sp->GetEnvironment().size(); 157 } 158 159 const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) { 160 LLDB_RECORD_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex, 161 (uint32_t), idx); 162 163 if (idx > GetNumEnvironmentEntries()) 164 return nullptr; 165 return m_opaque_sp->GetEnvp()[idx]; 166 } 167 168 void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) { 169 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironmentEntries, 170 (const char **, bool), envp, append); 171 172 Environment env(envp); 173 if (append) 174 m_opaque_sp->GetEnvironment().insert(env.begin(), env.end()); 175 else 176 m_opaque_sp->GetEnvironment() = env; 177 m_opaque_sp->RegenerateEnvp(); 178 } 179 180 void SBLaunchInfo::Clear() { 181 LLDB_RECORD_METHOD_NO_ARGS(void, SBLaunchInfo, Clear); 182 183 m_opaque_sp->Clear(); 184 } 185 186 const char *SBLaunchInfo::GetWorkingDirectory() const { 187 LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo, 188 GetWorkingDirectory); 189 190 return m_opaque_sp->GetWorkingDirectory().GetCString(); 191 } 192 193 void SBLaunchInfo::SetWorkingDirectory(const char *working_dir) { 194 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetWorkingDirectory, (const char *), 195 working_dir); 196 197 m_opaque_sp->SetWorkingDirectory(FileSpec(working_dir)); 198 } 199 200 uint32_t SBLaunchInfo::GetLaunchFlags() { 201 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetLaunchFlags); 202 203 return m_opaque_sp->GetFlags().Get(); 204 } 205 206 void SBLaunchInfo::SetLaunchFlags(uint32_t flags) { 207 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t), flags); 208 209 m_opaque_sp->GetFlags().Reset(flags); 210 } 211 212 const char *SBLaunchInfo::GetProcessPluginName() { 213 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetProcessPluginName); 214 215 return m_opaque_sp->GetProcessPluginName(); 216 } 217 218 void SBLaunchInfo::SetProcessPluginName(const char *plugin_name) { 219 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetProcessPluginName, (const char *), 220 plugin_name); 221 222 return m_opaque_sp->SetProcessPluginName(plugin_name); 223 } 224 225 const char *SBLaunchInfo::GetShell() { 226 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBLaunchInfo, GetShell); 227 228 // Constify this string so that it is saved in the string pool. Otherwise it 229 // would be freed when this function goes out of scope. 230 ConstString shell(m_opaque_sp->GetShell().GetPath().c_str()); 231 return shell.AsCString(); 232 } 233 234 void SBLaunchInfo::SetShell(const char *path) { 235 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShell, (const char *), path); 236 237 m_opaque_sp->SetShell(FileSpec(path)); 238 } 239 240 bool SBLaunchInfo::GetShellExpandArguments() { 241 LLDB_RECORD_METHOD_NO_ARGS(bool, SBLaunchInfo, GetShellExpandArguments); 242 243 return m_opaque_sp->GetShellExpandArguments(); 244 } 245 246 void SBLaunchInfo::SetShellExpandArguments(bool expand) { 247 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool), 248 expand); 249 250 m_opaque_sp->SetShellExpandArguments(expand); 251 } 252 253 uint32_t SBLaunchInfo::GetResumeCount() { 254 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBLaunchInfo, GetResumeCount); 255 256 return m_opaque_sp->GetResumeCount(); 257 } 258 259 void SBLaunchInfo::SetResumeCount(uint32_t c) { 260 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t), c); 261 262 m_opaque_sp->SetResumeCount(c); 263 } 264 265 bool SBLaunchInfo::AddCloseFileAction(int fd) { 266 LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int), fd); 267 268 return m_opaque_sp->AppendCloseFileAction(fd); 269 } 270 271 bool SBLaunchInfo::AddDuplicateFileAction(int fd, int dup_fd) { 272 LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction, (int, int), fd, 273 dup_fd); 274 275 return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd); 276 } 277 278 bool SBLaunchInfo::AddOpenFileAction(int fd, const char *path, bool read, 279 bool write) { 280 LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddOpenFileAction, 281 (int, const char *, bool, bool), fd, path, read, write); 282 283 return m_opaque_sp->AppendOpenFileAction(fd, FileSpec(path), read, write); 284 } 285 286 bool SBLaunchInfo::AddSuppressFileAction(int fd, bool read, bool write) { 287 LLDB_RECORD_METHOD(bool, SBLaunchInfo, AddSuppressFileAction, 288 (int, bool, bool), fd, read, write); 289 290 return m_opaque_sp->AppendSuppressFileAction(fd, read, write); 291 } 292 293 void SBLaunchInfo::SetLaunchEventData(const char *data) { 294 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetLaunchEventData, (const char *), 295 data); 296 297 m_opaque_sp->SetLaunchEventData(data); 298 } 299 300 const char *SBLaunchInfo::GetLaunchEventData() const { 301 LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo, 302 GetLaunchEventData); 303 304 return m_opaque_sp->GetLaunchEventData(); 305 } 306 307 void SBLaunchInfo::SetDetachOnError(bool enable) { 308 LLDB_RECORD_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool), enable); 309 310 m_opaque_sp->SetDetachOnError(enable); 311 } 312 313 bool SBLaunchInfo::GetDetachOnError() const { 314 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLaunchInfo, GetDetachOnError); 315 316 return m_opaque_sp->GetDetachOnError(); 317 } 318 319 namespace lldb_private { 320 namespace repro { 321 322 template <> 323 void RegisterMethods<SBLaunchInfo>(Registry &R) { 324 LLDB_REGISTER_CONSTRUCTOR(SBLaunchInfo, (const char **)); 325 LLDB_REGISTER_METHOD(lldb::pid_t, SBLaunchInfo, GetProcessID, ()); 326 LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetUserID, ()); 327 LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetGroupID, ()); 328 LLDB_REGISTER_METHOD(bool, SBLaunchInfo, UserIDIsValid, ()); 329 LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GroupIDIsValid, ()); 330 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetUserID, (uint32_t)); 331 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetGroupID, (uint32_t)); 332 LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBLaunchInfo, GetExecutableFile, ()); 333 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetExecutableFile, 334 (lldb::SBFileSpec, bool)); 335 LLDB_REGISTER_METHOD(lldb::SBListener, SBLaunchInfo, GetListener, ()); 336 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetListener, (lldb::SBListener &)); 337 LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumArguments, ()); 338 LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetArgumentAtIndex, 339 (uint32_t)); 340 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetArguments, 341 (const char **, bool)); 342 LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetNumEnvironmentEntries, ()); 343 LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetEnvironmentEntryAtIndex, 344 (uint32_t)); 345 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetEnvironmentEntries, 346 (const char **, bool)); 347 LLDB_REGISTER_METHOD(void, SBLaunchInfo, Clear, ()); 348 LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetWorkingDirectory, 349 ()); 350 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetWorkingDirectory, 351 (const char *)); 352 LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetLaunchFlags, ()); 353 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchFlags, (uint32_t)); 354 LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetProcessPluginName, ()); 355 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetProcessPluginName, 356 (const char *)); 357 LLDB_REGISTER_METHOD(const char *, SBLaunchInfo, GetShell, ()); 358 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShell, (const char *)); 359 LLDB_REGISTER_METHOD(bool, SBLaunchInfo, GetShellExpandArguments, ()); 360 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetShellExpandArguments, (bool)); 361 LLDB_REGISTER_METHOD(uint32_t, SBLaunchInfo, GetResumeCount, ()); 362 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetResumeCount, (uint32_t)); 363 LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddCloseFileAction, (int)); 364 LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddDuplicateFileAction, 365 (int, int)); 366 LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddOpenFileAction, 367 (int, const char *, bool, bool)); 368 LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddSuppressFileAction, 369 (int, bool, bool)); 370 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchEventData, 371 (const char *)); 372 LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetLaunchEventData, 373 ()); 374 LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool)); 375 LLDB_REGISTER_METHOD_CONST(bool, SBLaunchInfo, GetDetachOnError, ()); 376 } 377 378 } 379 } 380