Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include <errno.h>
4 : : #include <string.h>
5 : : #include <sys/stat.h>
6 : : #include <sys/wait.h>
7 : : #include <unistd.h>
8 : :
9 : : #include "alloc-util.h"
10 : : #include "copy.h"
11 : : #include "def.h"
12 : : #include "env-util.h"
13 : : #include "exec-util.h"
14 : : #include "fd-util.h"
15 : : #include "fileio.h"
16 : : #include "fs-util.h"
17 : : #include "log.h"
18 : : #include "macro.h"
19 : : #include "path-util.h"
20 : : #include "rm-rf.h"
21 : : #include "string-util.h"
22 : : #include "strv.h"
23 : : #include "tests.h"
24 : :
25 : : static int here = 0, here2 = 0, here3 = 0;
26 : : void *ignore_stdout_args[] = {&here, &here2, &here3};
27 : :
28 : : /* noop handlers, just check that arguments are passed correctly */
29 : 20 : static int ignore_stdout_func(int fd, void *arg) {
30 [ - + ]: 20 : assert(fd >= 0);
31 [ - + ]: 20 : assert(arg == &here);
32 : 20 : safe_close(fd);
33 : :
34 : 20 : return 0;
35 : : }
36 : 0 : static int ignore_stdout_func2(int fd, void *arg) {
37 [ # # ]: 0 : assert(fd >= 0);
38 [ # # ]: 0 : assert(arg == &here2);
39 : 0 : safe_close(fd);
40 : :
41 : 0 : return 0;
42 : : }
43 : 8 : static int ignore_stdout_func3(int fd, void *arg) {
44 [ - + ]: 8 : assert(fd >= 0);
45 [ - + ]: 8 : assert(arg == &here3);
46 : 8 : safe_close(fd);
47 : :
48 : 8 : return 0;
49 : : }
50 : :
51 : : static const gather_stdout_callback_t ignore_stdout[] = {
52 : : ignore_stdout_func,
53 : : ignore_stdout_func2,
54 : : ignore_stdout_func3,
55 : : };
56 : :
57 : 8 : static void test_execute_directory(bool gather_stdout) {
58 : 8 : char template_lo[] = "/tmp/test-exec-util.lo.XXXXXXX";
59 : 8 : char template_hi[] = "/tmp/test-exec-util.hi.XXXXXXX";
60 : 8 : const char * dirs[] = {template_hi, template_lo, NULL};
61 : : const char *name, *name2, *name3,
62 : : *overridden, *override,
63 : : *masked, *mask,
64 : : *masked2, *mask2, /* the mask is non-executable */
65 : : *masked2e, *mask2e; /* the mask is executable */
66 : :
67 [ + - + + ]: 8 : log_info("/* %s (%s) */", __func__, gather_stdout ? "gathering stdout" : "asynchronous");
68 : :
69 [ - + ]: 8 : assert_se(mkdtemp(template_lo));
70 [ - + ]: 8 : assert_se(mkdtemp(template_hi));
71 : :
72 [ + + + - : 40 : name = strjoina(template_lo, "/script");
- + - + +
+ + - ]
73 [ + + + - : 40 : name2 = strjoina(template_hi, "/script2");
- + - + +
+ + - ]
74 [ + + + - : 40 : name3 = strjoina(template_lo, "/useless");
- + - + +
+ + - ]
75 [ + + + - : 40 : overridden = strjoina(template_lo, "/overridden");
- + - + +
+ + - ]
76 [ + + + - : 40 : override = strjoina(template_hi, "/overridden");
- + - + +
+ + - ]
77 [ + + + - : 40 : masked = strjoina(template_lo, "/masked");
- + - + +
+ + - ]
78 [ + + + - : 40 : mask = strjoina(template_hi, "/masked");
- + - + +
+ + - ]
79 [ + + + - : 40 : masked2 = strjoina(template_lo, "/masked2");
- + - + +
+ + - ]
80 [ + + + - : 40 : mask2 = strjoina(template_hi, "/masked2");
- + - + +
+ + - ]
81 [ + + + - : 40 : masked2e = strjoina(template_lo, "/masked2e");
- + - + +
+ + - ]
82 [ + + + - : 40 : mask2e = strjoina(template_hi, "/masked2e");
- + - + +
+ + - ]
83 : :
84 [ - + ]: 8 : assert_se(write_string_file(name,
85 : : "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works",
86 : : WRITE_STRING_FILE_CREATE) == 0);
87 [ - + ]: 8 : assert_se(write_string_file(name2,
88 : : "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works2",
89 : : WRITE_STRING_FILE_CREATE) == 0);
90 [ - + ]: 8 : assert_se(write_string_file(overridden,
91 : : "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed",
92 : : WRITE_STRING_FILE_CREATE) == 0);
93 [ - + ]: 8 : assert_se(write_string_file(override,
94 : : "#!/bin/sh\necho 'Executing '$0",
95 : : WRITE_STRING_FILE_CREATE) == 0);
96 [ - + ]: 8 : assert_se(write_string_file(masked,
97 : : "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed",
98 : : WRITE_STRING_FILE_CREATE) == 0);
99 [ - + ]: 8 : assert_se(write_string_file(masked2,
100 : : "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed",
101 : : WRITE_STRING_FILE_CREATE) == 0);
102 [ - + ]: 8 : assert_se(write_string_file(masked2e,
103 : : "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed",
104 : : WRITE_STRING_FILE_CREATE) == 0);
105 [ - + ]: 8 : assert_se(symlink("/dev/null", mask) == 0);
106 [ - + ]: 8 : assert_se(touch(mask2) == 0);
107 [ - + ]: 8 : assert_se(touch(mask2e) == 0);
108 [ - + ]: 8 : assert_se(touch(name3) >= 0);
109 : :
110 [ - + ]: 8 : assert_se(chmod(name, 0755) == 0);
111 [ - + ]: 8 : assert_se(chmod(name2, 0755) == 0);
112 [ - + ]: 8 : assert_se(chmod(overridden, 0755) == 0);
113 [ - + ]: 8 : assert_se(chmod(override, 0755) == 0);
114 [ - + ]: 8 : assert_se(chmod(masked, 0755) == 0);
115 [ - + ]: 8 : assert_se(chmod(masked2, 0755) == 0);
116 [ - + ]: 8 : assert_se(chmod(masked2e, 0755) == 0);
117 [ - + ]: 8 : assert_se(chmod(mask2e, 0755) == 0);
118 : :
119 [ + + ]: 8 : if (gather_stdout)
120 : 4 : execute_directories(dirs, DEFAULT_TIMEOUT_USEC, ignore_stdout, ignore_stdout_args, NULL, NULL, EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
121 : : else
122 : 4 : execute_directories(dirs, DEFAULT_TIMEOUT_USEC, NULL, NULL, NULL, NULL, EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
123 : :
124 [ - + ]: 8 : assert_se(chdir(template_lo) == 0);
125 [ - + ]: 8 : assert_se(access("it_works", F_OK) >= 0);
126 [ - + ]: 8 : assert_se(access("failed", F_OK) < 0);
127 : :
128 [ - + ]: 8 : assert_se(chdir(template_hi) == 0);
129 [ - + ]: 8 : assert_se(access("it_works2", F_OK) >= 0);
130 [ - + ]: 8 : assert_se(access("failed", F_OK) < 0);
131 : :
132 : 8 : (void) rm_rf(template_lo, REMOVE_ROOT|REMOVE_PHYSICAL);
133 : 8 : (void) rm_rf(template_hi, REMOVE_ROOT|REMOVE_PHYSICAL);
134 : 8 : }
135 : :
136 : 4 : static void test_execution_order(void) {
137 : 4 : char template_lo[] = "/tmp/test-exec-util-lo.XXXXXXX";
138 : 4 : char template_hi[] = "/tmp/test-exec-util-hi.XXXXXXX";
139 : 4 : const char *dirs[] = {template_hi, template_lo, NULL};
140 : : const char *name, *name2, *name3, *overridden, *override, *masked, *mask;
141 : : const char *output, *t;
142 : 4 : _cleanup_free_ char *contents = NULL;
143 : :
144 [ - + ]: 4 : assert_se(mkdtemp(template_lo));
145 [ - + ]: 4 : assert_se(mkdtemp(template_hi));
146 : :
147 [ + + + - : 20 : output = strjoina(template_hi, "/output");
- + - + +
+ + - ]
148 : :
149 [ + - ]: 4 : log_info("/* %s >>%s */", __func__, output);
150 : :
151 : : /* write files in "random" order */
152 [ + + + - : 20 : name2 = strjoina(template_lo, "/90-bar");
- + - + +
+ + - ]
153 [ + + + - : 20 : name = strjoina(template_hi, "/80-foo");
- + - + +
+ + - ]
154 [ + + + - : 20 : name3 = strjoina(template_lo, "/last");
- + - + +
+ + - ]
155 [ + + + - : 20 : overridden = strjoina(template_lo, "/30-override");
- + - + +
+ + - ]
156 [ + + + - : 20 : override = strjoina(template_hi, "/30-override");
- + - + +
+ + - ]
157 [ + + + - : 20 : masked = strjoina(template_lo, "/10-masked");
- + - + +
+ + - ]
158 [ + + + - : 20 : mask = strjoina(template_hi, "/10-masked");
- + - + +
+ + - ]
159 : :
160 [ + + + - : 20 : t = strjoina("#!/bin/sh\necho $(basename $0) >>", output);
- + - + +
+ + - ]
161 [ - + ]: 4 : assert_se(write_string_file(name, t, WRITE_STRING_FILE_CREATE) == 0);
162 : :
163 [ + + + - : 20 : t = strjoina("#!/bin/sh\necho $(basename $0) >>", output);
- + - + +
+ + - ]
164 [ - + ]: 4 : assert_se(write_string_file(name2, t, WRITE_STRING_FILE_CREATE) == 0);
165 : :
166 [ + + + - : 20 : t = strjoina("#!/bin/sh\necho $(basename $0) >>", output);
- + - + +
+ + - ]
167 [ - + ]: 4 : assert_se(write_string_file(name3, t, WRITE_STRING_FILE_CREATE) == 0);
168 : :
169 [ + + + - : 20 : t = strjoina("#!/bin/sh\necho OVERRIDDEN >>", output);
- + - + +
+ + - ]
170 [ - + ]: 4 : assert_se(write_string_file(overridden, t, WRITE_STRING_FILE_CREATE) == 0);
171 : :
172 [ + + + - : 20 : t = strjoina("#!/bin/sh\necho $(basename $0) >>", output);
- + - + +
+ + - ]
173 [ - + ]: 4 : assert_se(write_string_file(override, t, WRITE_STRING_FILE_CREATE) == 0);
174 : :
175 [ + + + - : 20 : t = strjoina("#!/bin/sh\necho MASKED >>", output);
- + - + +
+ + - ]
176 [ - + ]: 4 : assert_se(write_string_file(masked, t, WRITE_STRING_FILE_CREATE) == 0);
177 : :
178 [ - + ]: 4 : assert_se(symlink("/dev/null", mask) == 0);
179 : :
180 [ - + ]: 4 : assert_se(chmod(name, 0755) == 0);
181 [ - + ]: 4 : assert_se(chmod(name2, 0755) == 0);
182 [ - + ]: 4 : assert_se(chmod(name3, 0755) == 0);
183 [ - + ]: 4 : assert_se(chmod(overridden, 0755) == 0);
184 [ - + ]: 4 : assert_se(chmod(override, 0755) == 0);
185 [ - + ]: 4 : assert_se(chmod(masked, 0755) == 0);
186 : :
187 : 4 : execute_directories(dirs, DEFAULT_TIMEOUT_USEC, ignore_stdout, ignore_stdout_args, NULL, NULL, EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
188 : :
189 [ - + ]: 4 : assert_se(read_full_file(output, &contents, NULL) >= 0);
190 [ - + ]: 4 : assert_se(streq(contents, "30-override\n80-foo\n90-bar\nlast\n"));
191 : :
192 : 4 : (void) rm_rf(template_lo, REMOVE_ROOT|REMOVE_PHYSICAL);
193 : 4 : (void) rm_rf(template_hi, REMOVE_ROOT|REMOVE_PHYSICAL);
194 : 4 : }
195 : :
196 : 8 : static int gather_stdout_one(int fd, void *arg) {
197 : 8 : char ***s = arg, *t;
198 : 8 : char buf[128] = {};
199 : :
200 [ - + ]: 8 : assert_se(s);
201 [ - + ]: 8 : assert_se(read(fd, buf, sizeof buf) >= 0);
202 : 8 : safe_close(fd);
203 : :
204 [ - + ]: 8 : assert_se(t = strndup(buf, sizeof buf));
205 [ - + ]: 8 : assert_se(strv_push(s, t) >= 0);
206 : :
207 : 8 : return 0;
208 : : }
209 : 0 : static int gather_stdout_two(int fd, void *arg) {
210 : 0 : char ***s = arg, **t;
211 : :
212 [ # # # # ]: 0 : STRV_FOREACH(t, *s)
213 [ # # ]: 0 : assert_se(write(fd, *t, strlen(*t)) == (ssize_t) strlen(*t));
214 : 0 : safe_close(fd);
215 : :
216 : 0 : return 0;
217 : : }
218 : 4 : static int gather_stdout_three(int fd, void *arg) {
219 : 4 : char **s = arg;
220 : 4 : char buf[128] = {};
221 : :
222 [ - + ]: 4 : assert_se(read(fd, buf, sizeof buf - 1) > 0);
223 : 4 : safe_close(fd);
224 [ - + ]: 4 : assert_se(*s = strndup(buf, sizeof buf));
225 : :
226 : 4 : return 0;
227 : : }
228 : :
229 : : const gather_stdout_callback_t gather_stdout[] = {
230 : : gather_stdout_one,
231 : : gather_stdout_two,
232 : : gather_stdout_three,
233 : : };
234 : :
235 : 4 : static void test_stdout_gathering(void) {
236 : 4 : char template[] = "/tmp/test-exec-util.XXXXXXX";
237 : 4 : const char *dirs[] = {template, NULL};
238 : : const char *name, *name2, *name3;
239 : : int r;
240 : :
241 : 4 : char **tmp = NULL; /* this is only used in the forked process, no cleanup here */
242 : 4 : _cleanup_free_ char *output = NULL;
243 : :
244 : 4 : void* args[] = {&tmp, &tmp, &output};
245 : :
246 [ - + ]: 4 : assert_se(mkdtemp(template));
247 : :
248 [ + - ]: 4 : log_info("/* %s */", __func__);
249 : :
250 : : /* write files */
251 [ + + + - : 20 : name = strjoina(template, "/10-foo");
- + - + +
+ + - ]
252 [ + + + - : 20 : name2 = strjoina(template, "/20-bar");
- + - + +
+ + - ]
253 [ + + + - : 20 : name3 = strjoina(template, "/30-last");
- + - + +
+ + - ]
254 : :
255 [ - + ]: 4 : assert_se(write_string_file(name,
256 : : "#!/bin/sh\necho a\necho b\necho c\n",
257 : : WRITE_STRING_FILE_CREATE) == 0);
258 [ - + ]: 4 : assert_se(write_string_file(name2,
259 : : "#!/bin/sh\necho d\n",
260 : : WRITE_STRING_FILE_CREATE) == 0);
261 [ - + ]: 4 : assert_se(write_string_file(name3,
262 : : "#!/bin/sh\nsleep 1",
263 : : WRITE_STRING_FILE_CREATE) == 0);
264 : :
265 [ - + ]: 4 : assert_se(chmod(name, 0755) == 0);
266 [ - + ]: 4 : assert_se(chmod(name2, 0755) == 0);
267 [ - + ]: 4 : assert_se(chmod(name3, 0755) == 0);
268 : :
269 : 4 : r = execute_directories(dirs, DEFAULT_TIMEOUT_USEC, gather_stdout, args, NULL, NULL, EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
270 [ - + ]: 4 : assert_se(r >= 0);
271 : :
272 [ + - ]: 4 : log_info("got: %s", output);
273 : :
274 [ - + ]: 4 : assert_se(streq(output, "a\nb\nc\nd\n"));
275 : 4 : }
276 : :
277 : 4 : static void test_environment_gathering(void) {
278 : 4 : char template[] = "/tmp/test-exec-util.XXXXXXX", **p;
279 : 4 : const char *dirs[] = {template, NULL};
280 : : const char *name, *name2, *name3, *old;
281 : : int r;
282 : :
283 : 4 : char **tmp = NULL; /* this is only used in the forked process, no cleanup here */
284 : 4 : _cleanup_strv_free_ char **env = NULL;
285 : :
286 : 4 : void* const args[] = { &tmp, &tmp, &env };
287 : :
288 [ - + ]: 4 : assert_se(mkdtemp(template));
289 : :
290 [ + - ]: 4 : log_info("/* %s */", __func__);
291 : :
292 : : /* write files */
293 [ + + + - : 20 : name = strjoina(template, "/10-foo");
- + - + +
+ + - ]
294 [ + + + - : 20 : name2 = strjoina(template, "/20-bar");
- + - + +
+ + - ]
295 [ + + + - : 20 : name3 = strjoina(template, "/30-last");
- + - + +
+ + - ]
296 : :
297 [ - + ]: 4 : assert_se(write_string_file(name,
298 : : "#!/bin/sh\n"
299 : : "echo A=23\n",
300 : : WRITE_STRING_FILE_CREATE) == 0);
301 [ - + ]: 4 : assert_se(write_string_file(name2,
302 : : "#!/bin/sh\n"
303 : : "echo A=22:$A\n\n\n", /* substitution from previous generator */
304 : : WRITE_STRING_FILE_CREATE) == 0);
305 [ - + ]: 4 : assert_se(write_string_file(name3,
306 : : "#!/bin/sh\n"
307 : : "echo A=$A:24\n"
308 : : "echo B=12\n"
309 : : "echo C=000\n"
310 : : "echo C=001\n" /* variable overwriting */
311 : : /* various invalid entries */
312 : : "echo unset A\n"
313 : : "echo unset A=\n"
314 : : "echo unset A=B\n"
315 : : "echo unset \n"
316 : : "echo A B=C\n"
317 : : "echo A\n"
318 : : /* test variable assignment without newline */
319 : : "echo PATH=$PATH:/no/such/file", /* no newline */
320 : : WRITE_STRING_FILE_CREATE) == 0);
321 : :
322 [ - + ]: 4 : assert_se(chmod(name, 0755) == 0);
323 [ - + ]: 4 : assert_se(chmod(name2, 0755) == 0);
324 [ - + ]: 4 : assert_se(chmod(name3, 0755) == 0);
325 : :
326 : : /* When booting in containers or without initramfs there might not be
327 : : * any PATH in the environment and if there is no PATH /bin/sh built-in
328 : : * PATH may leak and override systemd's DEFAULT_PATH which is not
329 : : * good. Force our own PATH in environment, to prevent expansion of sh
330 : : * built-in $PATH */
331 : 4 : old = getenv("PATH");
332 : 4 : r = setenv("PATH", "no-sh-built-in-path", 1);
333 [ - + ]: 4 : assert_se(r >= 0);
334 : :
335 : 4 : r = execute_directories(dirs, DEFAULT_TIMEOUT_USEC, gather_environment, args, NULL, NULL, EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
336 [ - + ]: 4 : assert_se(r >= 0);
337 : :
338 [ + - + + ]: 20 : STRV_FOREACH(p, env)
339 [ + - ]: 16 : log_info("got env: \"%s\"", *p);
340 : :
341 [ - + ]: 4 : assert_se(streq(strv_env_get(env, "A"), "22:23:24"));
342 [ - + ]: 4 : assert_se(streq(strv_env_get(env, "B"), "12"));
343 [ - + ]: 4 : assert_se(streq(strv_env_get(env, "C"), "001"));
344 [ - + ]: 4 : assert_se(streq(strv_env_get(env, "PATH"), "no-sh-built-in-path:/no/such/file"));
345 : :
346 : : /* now retest with "default" path passed in, as created by
347 : : * manager_default_environment */
348 : 4 : env = strv_free(env);
349 : 4 : env = strv_new("PATH=" DEFAULT_PATH);
350 [ - + ]: 4 : assert_se(env);
351 : :
352 : 4 : r = execute_directories(dirs, DEFAULT_TIMEOUT_USEC, gather_environment, args, NULL, env, EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
353 [ - + ]: 4 : assert_se(r >= 0);
354 : :
355 [ + - + + ]: 20 : STRV_FOREACH(p, env)
356 [ + - ]: 16 : log_info("got env: \"%s\"", *p);
357 : :
358 [ - + ]: 4 : assert_se(streq(strv_env_get(env, "A"), "22:23:24"));
359 [ - + ]: 4 : assert_se(streq(strv_env_get(env, "B"), "12"));
360 [ - + ]: 4 : assert_se(streq(strv_env_get(env, "C"), "001"));
361 [ - + ]: 4 : assert_se(streq(strv_env_get(env, "PATH"), DEFAULT_PATH ":/no/such/file"));
362 : :
363 : : /* reset environ PATH */
364 [ + - ]: 4 : if (old)
365 : 4 : (void) setenv("PATH", old, 1);
366 : : else
367 : 0 : (void) unsetenv("PATH");
368 : 4 : }
369 : :
370 : 4 : static void test_error_catching(void) {
371 : 4 : char template[] = "/tmp/test-exec-util.XXXXXXX";
372 : 4 : const char *dirs[] = {template, NULL};
373 : : const char *name, *name2, *name3;
374 : : int r;
375 : :
376 [ - + ]: 4 : assert_se(mkdtemp(template));
377 : :
378 [ + - ]: 4 : log_info("/* %s */", __func__);
379 : :
380 : : /* write files */
381 [ + + + - : 20 : name = strjoina(template, "/10-foo");
- + - + +
+ + - ]
382 [ + + + - : 20 : name2 = strjoina(template, "/20-bar");
- + - + +
+ + - ]
383 [ + + + - : 20 : name3 = strjoina(template, "/30-last");
- + - + +
+ + - ]
384 : :
385 [ - + ]: 4 : assert_se(write_string_file(name,
386 : : "#!/bin/sh\necho a\necho b\necho c\n",
387 : : WRITE_STRING_FILE_CREATE) == 0);
388 [ - + ]: 4 : assert_se(write_string_file(name2,
389 : : "#!/bin/sh\nexit 42\n",
390 : : WRITE_STRING_FILE_CREATE) == 0);
391 [ - + ]: 4 : assert_se(write_string_file(name3,
392 : : "#!/bin/sh\nexit 12",
393 : : WRITE_STRING_FILE_CREATE) == 0);
394 : :
395 [ - + ]: 4 : assert_se(chmod(name, 0755) == 0);
396 [ - + ]: 4 : assert_se(chmod(name2, 0755) == 0);
397 [ - + ]: 4 : assert_se(chmod(name3, 0755) == 0);
398 : :
399 : 4 : r = execute_directories(dirs, DEFAULT_TIMEOUT_USEC, NULL, NULL, NULL, NULL, EXEC_DIR_NONE);
400 : :
401 : : /* we should exit with the error code of the first script that failed */
402 [ - + ]: 4 : assert_se(r == 42);
403 : 4 : }
404 : :
405 : 4 : static void test_exec_command_flags_from_strv(void) {
406 : 4 : ExecCommandFlags flags = 0;
407 : 4 : char **valid_strv = STRV_MAKE("no-env-expand", "no-setuid", "ignore-failure");
408 : 4 : char **invalid_strv = STRV_MAKE("no-env-expand", "no-setuid", "nonexistent-option", "ignore-failure");
409 : : int r;
410 : :
411 : 4 : r = exec_command_flags_from_strv(valid_strv, &flags);
412 : :
413 [ - + ]: 4 : assert_se(r == 0);
414 [ - + ]: 4 : assert_se(FLAGS_SET(flags, EXEC_COMMAND_NO_ENV_EXPAND));
415 [ - + ]: 4 : assert_se(FLAGS_SET(flags, EXEC_COMMAND_NO_SETUID));
416 [ - + ]: 4 : assert_se(FLAGS_SET(flags, EXEC_COMMAND_IGNORE_FAILURE));
417 [ - + ]: 4 : assert_se(!FLAGS_SET(flags, EXEC_COMMAND_AMBIENT_MAGIC));
418 [ - + ]: 4 : assert_se(!FLAGS_SET(flags, EXEC_COMMAND_FULLY_PRIVILEGED));
419 : :
420 : 4 : r = exec_command_flags_from_strv(invalid_strv, &flags);
421 : :
422 [ - + ]: 4 : assert_se(r == -EINVAL);
423 : 4 : }
424 : :
425 : 4 : static void test_exec_command_flags_to_strv(void) {
426 : 4 : _cleanup_strv_free_ char **opts = NULL, **empty_opts = NULL, **invalid_opts = NULL;
427 : 4 : ExecCommandFlags flags = 0;
428 : : int r;
429 : :
430 : 4 : flags |= (EXEC_COMMAND_AMBIENT_MAGIC|EXEC_COMMAND_NO_ENV_EXPAND|EXEC_COMMAND_IGNORE_FAILURE);
431 : :
432 : 4 : r = exec_command_flags_to_strv(flags, &opts);
433 : :
434 [ - + ]: 4 : assert_se(r == 0);
435 [ - + ]: 4 : assert_se(strv_equal(opts, STRV_MAKE("ignore-failure", "ambient", "no-env-expand")));
436 : :
437 : 4 : r = exec_command_flags_to_strv(0, &empty_opts);
438 : :
439 [ - + ]: 4 : assert_se(r == 0);
440 [ - + ]: 4 : assert_se(strv_equal(empty_opts, STRV_MAKE_EMPTY));
441 : :
442 : 4 : flags = _EXEC_COMMAND_FLAGS_INVALID;
443 : :
444 : 4 : r = exec_command_flags_to_strv(flags, &invalid_opts);
445 : :
446 [ - + ]: 4 : assert_se(r == -EINVAL);
447 : 4 : }
448 : :
449 : 4 : int main(int argc, char *argv[]) {
450 : 4 : test_setup_logging(LOG_DEBUG);
451 : :
452 : 4 : test_execute_directory(true);
453 : 4 : test_execute_directory(false);
454 : 4 : test_execution_order();
455 : 4 : test_stdout_gathering();
456 : 4 : test_environment_gathering();
457 : 4 : test_error_catching();
458 : 4 : test_exec_command_flags_from_strv();
459 : 4 : test_exec_command_flags_to_strv();
460 : :
461 : 4 : return 0;
462 : : }
|
