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