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