]>
Commit | Line | Data |
---|---|---|
53e1b683 | 1 | /* SPDX-License-Identifier: LGPL-2.1+ */ |
a7334b09 | 2 | |
034c6ed7 LP |
3 | #include <errno.h> |
4 | #include <fcntl.h> | |
8dd4c05b LP |
5 | #include <glob.h> |
6 | #include <grp.h> | |
7 | #include <poll.h> | |
309bff19 | 8 | #include <signal.h> |
8dd4c05b | 9 | #include <string.h> |
19c0b0b9 | 10 | #include <sys/capability.h> |
d251207d | 11 | #include <sys/eventfd.h> |
f3e43635 | 12 | #include <sys/mman.h> |
8dd4c05b | 13 | #include <sys/personality.h> |
94f04347 | 14 | #include <sys/prctl.h> |
d2ffa389 | 15 | #include <sys/shm.h> |
8dd4c05b | 16 | #include <sys/socket.h> |
451a074f | 17 | #include <sys/stat.h> |
d2ffa389 | 18 | #include <sys/types.h> |
8dd4c05b LP |
19 | #include <sys/un.h> |
20 | #include <unistd.h> | |
023a4f67 | 21 | #include <utmpx.h> |
5cb5a6ff | 22 | |
349cc4a5 | 23 | #if HAVE_PAM |
5b6319dc LP |
24 | #include <security/pam_appl.h> |
25 | #endif | |
26 | ||
349cc4a5 | 27 | #if HAVE_SELINUX |
7b52a628 MS |
28 | #include <selinux/selinux.h> |
29 | #endif | |
30 | ||
349cc4a5 | 31 | #if HAVE_SECCOMP |
17df7223 LP |
32 | #include <seccomp.h> |
33 | #endif | |
34 | ||
349cc4a5 | 35 | #if HAVE_APPARMOR |
eef65bf3 MS |
36 | #include <sys/apparmor.h> |
37 | #endif | |
38 | ||
24882e06 | 39 | #include "sd-messages.h" |
8dd4c05b LP |
40 | |
41 | #include "af-list.h" | |
b5efdb8a | 42 | #include "alloc-util.h" |
349cc4a5 | 43 | #if HAVE_APPARMOR |
3ffd4af2 LP |
44 | #include "apparmor-util.h" |
45 | #endif | |
8dd4c05b LP |
46 | #include "async.h" |
47 | #include "barrier.h" | |
8dd4c05b | 48 | #include "cap-list.h" |
430f0182 | 49 | #include "capability-util.h" |
a1164ae3 | 50 | #include "chown-recursive.h" |
da681e1b | 51 | #include "cpu-set-util.h" |
f6a6225e | 52 | #include "def.h" |
686d13b9 | 53 | #include "env-file.h" |
4d1a6904 | 54 | #include "env-util.h" |
17df7223 | 55 | #include "errno-list.h" |
3ffd4af2 | 56 | #include "execute.h" |
8dd4c05b | 57 | #include "exit-status.h" |
3ffd4af2 | 58 | #include "fd-util.h" |
f97b34a6 | 59 | #include "format-util.h" |
f4f15635 | 60 | #include "fs-util.h" |
7d50b32a | 61 | #include "glob-util.h" |
c004493c | 62 | #include "io-util.h" |
8dd4c05b | 63 | #include "ioprio.h" |
a1164ae3 | 64 | #include "label.h" |
8dd4c05b LP |
65 | #include "log.h" |
66 | #include "macro.h" | |
e8a565cb | 67 | #include "manager.h" |
8dd4c05b LP |
68 | #include "missing.h" |
69 | #include "mkdir.h" | |
70 | #include "namespace.h" | |
6bedfcbb | 71 | #include "parse-util.h" |
8dd4c05b | 72 | #include "path-util.h" |
0b452006 | 73 | #include "process-util.h" |
78f22b97 | 74 | #include "rlimit-util.h" |
8dd4c05b | 75 | #include "rm-rf.h" |
349cc4a5 | 76 | #if HAVE_SECCOMP |
3ffd4af2 LP |
77 | #include "seccomp-util.h" |
78 | #endif | |
07d46372 | 79 | #include "securebits-util.h" |
8dd4c05b | 80 | #include "selinux-util.h" |
24882e06 | 81 | #include "signal-util.h" |
8dd4c05b | 82 | #include "smack-util.h" |
57b7a260 | 83 | #include "socket-util.h" |
fd63e712 | 84 | #include "special.h" |
949befd3 | 85 | #include "stat-util.h" |
8b43440b | 86 | #include "string-table.h" |
07630cea | 87 | #include "string-util.h" |
8dd4c05b | 88 | #include "strv.h" |
7ccbd1ae | 89 | #include "syslog-util.h" |
8dd4c05b | 90 | #include "terminal-util.h" |
566b7d23 | 91 | #include "umask-util.h" |
8dd4c05b | 92 | #include "unit.h" |
b1d4f8e1 | 93 | #include "user-util.h" |
8dd4c05b LP |
94 | #include "util.h" |
95 | #include "utmp-wtmp.h" | |
5cb5a6ff | 96 | |
e056b01d | 97 | #define IDLE_TIMEOUT_USEC (5*USEC_PER_SEC) |
31a7eb86 | 98 | #define IDLE_TIMEOUT2_USEC (1*USEC_PER_SEC) |
e6a26745 | 99 | |
02a51aba LP |
100 | /* This assumes there is a 'tty' group */ |
101 | #define TTY_MODE 0620 | |
102 | ||
531dca78 LP |
103 | #define SNDBUF_SIZE (8*1024*1024) |
104 | ||
da6053d0 | 105 | static int shift_fds(int fds[], size_t n_fds) { |
034c6ed7 LP |
106 | int start, restart_from; |
107 | ||
108 | if (n_fds <= 0) | |
109 | return 0; | |
110 | ||
a0d40ac5 LP |
111 | /* Modifies the fds array! (sorts it) */ |
112 | ||
034c6ed7 LP |
113 | assert(fds); |
114 | ||
115 | start = 0; | |
116 | for (;;) { | |
117 | int i; | |
118 | ||
119 | restart_from = -1; | |
120 | ||
121 | for (i = start; i < (int) n_fds; i++) { | |
122 | int nfd; | |
123 | ||
124 | /* Already at right index? */ | |
125 | if (fds[i] == i+3) | |
126 | continue; | |
127 | ||
3cc2aff1 LP |
128 | nfd = fcntl(fds[i], F_DUPFD, i + 3); |
129 | if (nfd < 0) | |
034c6ed7 LP |
130 | return -errno; |
131 | ||
03e334a1 | 132 | safe_close(fds[i]); |
034c6ed7 LP |
133 | fds[i] = nfd; |
134 | ||
135 | /* Hmm, the fd we wanted isn't free? Then | |
ee33e53a | 136 | * let's remember that and try again from here */ |
034c6ed7 LP |
137 | if (nfd != i+3 && restart_from < 0) |
138 | restart_from = i; | |
139 | } | |
140 | ||
141 | if (restart_from < 0) | |
142 | break; | |
143 | ||
144 | start = restart_from; | |
145 | } | |
146 | ||
147 | return 0; | |
148 | } | |
149 | ||
25b583d7 | 150 | static int flags_fds(const int fds[], size_t n_socket_fds, size_t n_storage_fds, bool nonblock) { |
da6053d0 | 151 | size_t i, n_fds; |
e2c76839 | 152 | int r; |
47a71eed | 153 | |
25b583d7 | 154 | n_fds = n_socket_fds + n_storage_fds; |
47a71eed LP |
155 | if (n_fds <= 0) |
156 | return 0; | |
157 | ||
158 | assert(fds); | |
159 | ||
9b141911 FB |
160 | /* Drops/Sets O_NONBLOCK and FD_CLOEXEC from the file flags. |
161 | * O_NONBLOCK only applies to socket activation though. */ | |
47a71eed LP |
162 | |
163 | for (i = 0; i < n_fds; i++) { | |
47a71eed | 164 | |
9b141911 FB |
165 | if (i < n_socket_fds) { |
166 | r = fd_nonblock(fds[i], nonblock); | |
167 | if (r < 0) | |
168 | return r; | |
169 | } | |
47a71eed | 170 | |
451a074f LP |
171 | /* We unconditionally drop FD_CLOEXEC from the fds, |
172 | * since after all we want to pass these fds to our | |
173 | * children */ | |
47a71eed | 174 | |
3cc2aff1 LP |
175 | r = fd_cloexec(fds[i], false); |
176 | if (r < 0) | |
e2c76839 | 177 | return r; |
47a71eed LP |
178 | } |
179 | ||
180 | return 0; | |
181 | } | |
182 | ||
1e22b5cd | 183 | static const char *exec_context_tty_path(const ExecContext *context) { |
80876c20 LP |
184 | assert(context); |
185 | ||
1e22b5cd LP |
186 | if (context->stdio_as_fds) |
187 | return NULL; | |
188 | ||
80876c20 LP |
189 | if (context->tty_path) |
190 | return context->tty_path; | |
191 | ||
192 | return "/dev/console"; | |
193 | } | |
194 | ||
1e22b5cd LP |
195 | static void exec_context_tty_reset(const ExecContext *context, const ExecParameters *p) { |
196 | const char *path; | |
197 | ||
6ea832a2 LP |
198 | assert(context); |
199 | ||
1e22b5cd | 200 | path = exec_context_tty_path(context); |
6ea832a2 | 201 | |
1e22b5cd LP |
202 | if (context->tty_vhangup) { |
203 | if (p && p->stdin_fd >= 0) | |
204 | (void) terminal_vhangup_fd(p->stdin_fd); | |
205 | else if (path) | |
206 | (void) terminal_vhangup(path); | |
207 | } | |
6ea832a2 | 208 | |
1e22b5cd LP |
209 | if (context->tty_reset) { |
210 | if (p && p->stdin_fd >= 0) | |
211 | (void) reset_terminal_fd(p->stdin_fd, true); | |
212 | else if (path) | |
213 | (void) reset_terminal(path); | |
214 | } | |
215 | ||
216 | if (context->tty_vt_disallocate && path) | |
217 | (void) vt_disallocate(path); | |
6ea832a2 LP |
218 | } |
219 | ||
6af760f3 LP |
220 | static bool is_terminal_input(ExecInput i) { |
221 | return IN_SET(i, | |
222 | EXEC_INPUT_TTY, | |
223 | EXEC_INPUT_TTY_FORCE, | |
224 | EXEC_INPUT_TTY_FAIL); | |
225 | } | |
226 | ||
3a1286b6 | 227 | static bool is_terminal_output(ExecOutput o) { |
6af760f3 LP |
228 | return IN_SET(o, |
229 | EXEC_OUTPUT_TTY, | |
230 | EXEC_OUTPUT_SYSLOG_AND_CONSOLE, | |
231 | EXEC_OUTPUT_KMSG_AND_CONSOLE, | |
232 | EXEC_OUTPUT_JOURNAL_AND_CONSOLE); | |
233 | } | |
234 | ||
aac8c0c3 LP |
235 | static bool is_syslog_output(ExecOutput o) { |
236 | return IN_SET(o, | |
237 | EXEC_OUTPUT_SYSLOG, | |
238 | EXEC_OUTPUT_SYSLOG_AND_CONSOLE); | |
239 | } | |
240 | ||
241 | static bool is_kmsg_output(ExecOutput o) { | |
242 | return IN_SET(o, | |
243 | EXEC_OUTPUT_KMSG, | |
244 | EXEC_OUTPUT_KMSG_AND_CONSOLE); | |
245 | } | |
246 | ||
6af760f3 LP |
247 | static bool exec_context_needs_term(const ExecContext *c) { |
248 | assert(c); | |
249 | ||
250 | /* Return true if the execution context suggests we should set $TERM to something useful. */ | |
251 | ||
252 | if (is_terminal_input(c->std_input)) | |
253 | return true; | |
254 | ||
255 | if (is_terminal_output(c->std_output)) | |
256 | return true; | |
257 | ||
258 | if (is_terminal_output(c->std_error)) | |
259 | return true; | |
260 | ||
261 | return !!c->tty_path; | |
3a1286b6 MS |
262 | } |
263 | ||
80876c20 | 264 | static int open_null_as(int flags, int nfd) { |
046a82c1 | 265 | int fd; |
071830ff | 266 | |
80876c20 | 267 | assert(nfd >= 0); |
071830ff | 268 | |
613b411c LP |
269 | fd = open("/dev/null", flags|O_NOCTTY); |
270 | if (fd < 0) | |
071830ff LP |
271 | return -errno; |
272 | ||
046a82c1 | 273 | return move_fd(fd, nfd, false); |
071830ff LP |
274 | } |
275 | ||
524daa8c | 276 | static int connect_journal_socket(int fd, uid_t uid, gid_t gid) { |
92a17af9 | 277 | static const union sockaddr_union sa = { |
b92bea5d ZJS |
278 | .un.sun_family = AF_UNIX, |
279 | .un.sun_path = "/run/systemd/journal/stdout", | |
280 | }; | |
524daa8c ZJS |
281 | uid_t olduid = UID_INVALID; |
282 | gid_t oldgid = GID_INVALID; | |
283 | int r; | |
284 | ||
cad93f29 | 285 | if (gid_is_valid(gid)) { |
524daa8c ZJS |
286 | oldgid = getgid(); |
287 | ||
92a17af9 | 288 | if (setegid(gid) < 0) |
524daa8c ZJS |
289 | return -errno; |
290 | } | |
291 | ||
cad93f29 | 292 | if (uid_is_valid(uid)) { |
524daa8c ZJS |
293 | olduid = getuid(); |
294 | ||
92a17af9 | 295 | if (seteuid(uid) < 0) { |
524daa8c ZJS |
296 | r = -errno; |
297 | goto restore_gid; | |
298 | } | |
299 | } | |
300 | ||
92a17af9 | 301 | r = connect(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un)) < 0 ? -errno : 0; |
524daa8c ZJS |
302 | |
303 | /* If we fail to restore the uid or gid, things will likely | |
304 | fail later on. This should only happen if an LSM interferes. */ | |
305 | ||
cad93f29 | 306 | if (uid_is_valid(uid)) |
524daa8c ZJS |
307 | (void) seteuid(olduid); |
308 | ||
309 | restore_gid: | |
cad93f29 | 310 | if (gid_is_valid(gid)) |
524daa8c ZJS |
311 | (void) setegid(oldgid); |
312 | ||
313 | return r; | |
314 | } | |
315 | ||
fd1f9c89 | 316 | static int connect_logger_as( |
34cf6c43 | 317 | const Unit *unit, |
fd1f9c89 | 318 | const ExecContext *context, |
af635cf3 | 319 | const ExecParameters *params, |
fd1f9c89 LP |
320 | ExecOutput output, |
321 | const char *ident, | |
fd1f9c89 LP |
322 | int nfd, |
323 | uid_t uid, | |
324 | gid_t gid) { | |
325 | ||
2ac1ff68 EV |
326 | _cleanup_close_ int fd = -1; |
327 | int r; | |
071830ff LP |
328 | |
329 | assert(context); | |
af635cf3 | 330 | assert(params); |
80876c20 LP |
331 | assert(output < _EXEC_OUTPUT_MAX); |
332 | assert(ident); | |
333 | assert(nfd >= 0); | |
071830ff | 334 | |
54fe0cdb LP |
335 | fd = socket(AF_UNIX, SOCK_STREAM, 0); |
336 | if (fd < 0) | |
80876c20 | 337 | return -errno; |
071830ff | 338 | |
524daa8c ZJS |
339 | r = connect_journal_socket(fd, uid, gid); |
340 | if (r < 0) | |
341 | return r; | |
071830ff | 342 | |
2ac1ff68 | 343 | if (shutdown(fd, SHUT_RD) < 0) |
80876c20 | 344 | return -errno; |
071830ff | 345 | |
fd1f9c89 | 346 | (void) fd_inc_sndbuf(fd, SNDBUF_SIZE); |
531dca78 | 347 | |
2ac1ff68 | 348 | if (dprintf(fd, |
62bca2c6 | 349 | "%s\n" |
80876c20 LP |
350 | "%s\n" |
351 | "%i\n" | |
54fe0cdb LP |
352 | "%i\n" |
353 | "%i\n" | |
354 | "%i\n" | |
4f4a1dbf | 355 | "%i\n", |
c867611e | 356 | context->syslog_identifier ?: ident, |
af635cf3 | 357 | params->flags & EXEC_PASS_LOG_UNIT ? unit->id : "", |
54fe0cdb LP |
358 | context->syslog_priority, |
359 | !!context->syslog_level_prefix, | |
aac8c0c3 LP |
360 | is_syslog_output(output), |
361 | is_kmsg_output(output), | |
2ac1ff68 EV |
362 | is_terminal_output(output)) < 0) |
363 | return -errno; | |
80876c20 | 364 | |
2ac1ff68 | 365 | return move_fd(TAKE_FD(fd), nfd, false); |
80876c20 | 366 | } |
2ac1ff68 | 367 | |
3a274a21 | 368 | static int open_terminal_as(const char *path, int flags, int nfd) { |
046a82c1 | 369 | int fd; |
071830ff | 370 | |
80876c20 LP |
371 | assert(path); |
372 | assert(nfd >= 0); | |
fd1f9c89 | 373 | |
3a274a21 | 374 | fd = open_terminal(path, flags | O_NOCTTY); |
3cc2aff1 | 375 | if (fd < 0) |
80876c20 | 376 | return fd; |
071830ff | 377 | |
046a82c1 | 378 | return move_fd(fd, nfd, false); |
80876c20 | 379 | } |
071830ff | 380 | |
2038c3f5 | 381 | static int acquire_path(const char *path, int flags, mode_t mode) { |
15a3e96f LP |
382 | union sockaddr_union sa = {}; |
383 | _cleanup_close_ int fd = -1; | |
384 | int r, salen; | |
071830ff | 385 | |
80876c20 | 386 | assert(path); |
071830ff | 387 | |
2038c3f5 LP |
388 | if (IN_SET(flags & O_ACCMODE, O_WRONLY, O_RDWR)) |
389 | flags |= O_CREAT; | |
390 | ||
391 | fd = open(path, flags|O_NOCTTY, mode); | |
392 | if (fd >= 0) | |
15a3e96f | 393 | return TAKE_FD(fd); |
071830ff | 394 | |
2038c3f5 LP |
395 | if (errno != ENXIO) /* ENXIO is returned when we try to open() an AF_UNIX file system socket on Linux */ |
396 | return -errno; | |
15a3e96f | 397 | if (strlen(path) >= sizeof(sa.un.sun_path)) /* Too long, can't be a UNIX socket */ |
2038c3f5 LP |
398 | return -ENXIO; |
399 | ||
400 | /* So, it appears the specified path could be an AF_UNIX socket. Let's see if we can connect to it. */ | |
401 | ||
402 | fd = socket(AF_UNIX, SOCK_STREAM, 0); | |
403 | if (fd < 0) | |
404 | return -errno; | |
405 | ||
15a3e96f LP |
406 | salen = sockaddr_un_set_path(&sa.un, path); |
407 | if (salen < 0) | |
408 | return salen; | |
409 | ||
410 | if (connect(fd, &sa.sa, salen) < 0) | |
2038c3f5 LP |
411 | return errno == EINVAL ? -ENXIO : -errno; /* Propagate initial error if we get EINVAL, i.e. we have |
412 | * indication that his wasn't an AF_UNIX socket after all */ | |
071830ff | 413 | |
2038c3f5 LP |
414 | if ((flags & O_ACCMODE) == O_RDONLY) |
415 | r = shutdown(fd, SHUT_WR); | |
416 | else if ((flags & O_ACCMODE) == O_WRONLY) | |
417 | r = shutdown(fd, SHUT_RD); | |
418 | else | |
15a3e96f LP |
419 | return TAKE_FD(fd); |
420 | if (r < 0) | |
2038c3f5 | 421 | return -errno; |
2038c3f5 | 422 | |
15a3e96f | 423 | return TAKE_FD(fd); |
80876c20 | 424 | } |
071830ff | 425 | |
08f3be7a LP |
426 | static int fixup_input( |
427 | const ExecContext *context, | |
428 | int socket_fd, | |
429 | bool apply_tty_stdin) { | |
430 | ||
431 | ExecInput std_input; | |
432 | ||
433 | assert(context); | |
434 | ||
435 | std_input = context->std_input; | |
1e3ad081 LP |
436 | |
437 | if (is_terminal_input(std_input) && !apply_tty_stdin) | |
438 | return EXEC_INPUT_NULL; | |
071830ff | 439 | |
03fd9c49 | 440 | if (std_input == EXEC_INPUT_SOCKET && socket_fd < 0) |
4f2d528d LP |
441 | return EXEC_INPUT_NULL; |
442 | ||
08f3be7a LP |
443 | if (std_input == EXEC_INPUT_DATA && context->stdin_data_size == 0) |
444 | return EXEC_INPUT_NULL; | |
445 | ||
03fd9c49 | 446 | return std_input; |
4f2d528d LP |
447 | } |
448 | ||
03fd9c49 | 449 | static int fixup_output(ExecOutput std_output, int socket_fd) { |
4f2d528d | 450 | |
03fd9c49 | 451 | if (std_output == EXEC_OUTPUT_SOCKET && socket_fd < 0) |
4f2d528d LP |
452 | return EXEC_OUTPUT_INHERIT; |
453 | ||
03fd9c49 | 454 | return std_output; |
4f2d528d LP |
455 | } |
456 | ||
a34ceba6 LP |
457 | static int setup_input( |
458 | const ExecContext *context, | |
459 | const ExecParameters *params, | |
52c239d7 LB |
460 | int socket_fd, |
461 | int named_iofds[3]) { | |
a34ceba6 | 462 | |
4f2d528d LP |
463 | ExecInput i; |
464 | ||
465 | assert(context); | |
a34ceba6 LP |
466 | assert(params); |
467 | ||
468 | if (params->stdin_fd >= 0) { | |
469 | if (dup2(params->stdin_fd, STDIN_FILENO) < 0) | |
470 | return -errno; | |
471 | ||
472 | /* Try to make this the controlling tty, if it is a tty, and reset it */ | |
1fb0682e LP |
473 | if (isatty(STDIN_FILENO)) { |
474 | (void) ioctl(STDIN_FILENO, TIOCSCTTY, context->std_input == EXEC_INPUT_TTY_FORCE); | |
475 | (void) reset_terminal_fd(STDIN_FILENO, true); | |
476 | } | |
a34ceba6 LP |
477 | |
478 | return STDIN_FILENO; | |
479 | } | |
4f2d528d | 480 | |
08f3be7a | 481 | i = fixup_input(context, socket_fd, params->flags & EXEC_APPLY_TTY_STDIN); |
4f2d528d LP |
482 | |
483 | switch (i) { | |
071830ff | 484 | |
80876c20 LP |
485 | case EXEC_INPUT_NULL: |
486 | return open_null_as(O_RDONLY, STDIN_FILENO); | |
487 | ||
488 | case EXEC_INPUT_TTY: | |
489 | case EXEC_INPUT_TTY_FORCE: | |
490 | case EXEC_INPUT_TTY_FAIL: { | |
046a82c1 | 491 | int fd; |
071830ff | 492 | |
1e22b5cd | 493 | fd = acquire_terminal(exec_context_tty_path(context), |
8854d795 LP |
494 | i == EXEC_INPUT_TTY_FAIL ? ACQUIRE_TERMINAL_TRY : |
495 | i == EXEC_INPUT_TTY_FORCE ? ACQUIRE_TERMINAL_FORCE : | |
496 | ACQUIRE_TERMINAL_WAIT, | |
3a43da28 | 497 | USEC_INFINITY); |
970edce6 | 498 | if (fd < 0) |
80876c20 LP |
499 | return fd; |
500 | ||
046a82c1 | 501 | return move_fd(fd, STDIN_FILENO, false); |
80876c20 LP |
502 | } |
503 | ||
4f2d528d | 504 | case EXEC_INPUT_SOCKET: |
e75a9ed1 LP |
505 | assert(socket_fd >= 0); |
506 | ||
4f2d528d LP |
507 | return dup2(socket_fd, STDIN_FILENO) < 0 ? -errno : STDIN_FILENO; |
508 | ||
52c239d7 | 509 | case EXEC_INPUT_NAMED_FD: |
e75a9ed1 LP |
510 | assert(named_iofds[STDIN_FILENO] >= 0); |
511 | ||
52c239d7 LB |
512 | (void) fd_nonblock(named_iofds[STDIN_FILENO], false); |
513 | return dup2(named_iofds[STDIN_FILENO], STDIN_FILENO) < 0 ? -errno : STDIN_FILENO; | |
514 | ||
08f3be7a LP |
515 | case EXEC_INPUT_DATA: { |
516 | int fd; | |
517 | ||
518 | fd = acquire_data_fd(context->stdin_data, context->stdin_data_size, 0); | |
519 | if (fd < 0) | |
520 | return fd; | |
521 | ||
522 | return move_fd(fd, STDIN_FILENO, false); | |
523 | } | |
524 | ||
2038c3f5 LP |
525 | case EXEC_INPUT_FILE: { |
526 | bool rw; | |
527 | int fd; | |
528 | ||
529 | assert(context->stdio_file[STDIN_FILENO]); | |
530 | ||
531 | rw = (context->std_output == EXEC_OUTPUT_FILE && streq_ptr(context->stdio_file[STDIN_FILENO], context->stdio_file[STDOUT_FILENO])) || | |
532 | (context->std_error == EXEC_OUTPUT_FILE && streq_ptr(context->stdio_file[STDIN_FILENO], context->stdio_file[STDERR_FILENO])); | |
533 | ||
534 | fd = acquire_path(context->stdio_file[STDIN_FILENO], rw ? O_RDWR : O_RDONLY, 0666 & ~context->umask); | |
535 | if (fd < 0) | |
536 | return fd; | |
537 | ||
538 | return move_fd(fd, STDIN_FILENO, false); | |
539 | } | |
540 | ||
80876c20 LP |
541 | default: |
542 | assert_not_reached("Unknown input type"); | |
543 | } | |
544 | } | |
545 | ||
41fc585a LP |
546 | static bool can_inherit_stderr_from_stdout( |
547 | const ExecContext *context, | |
548 | ExecOutput o, | |
549 | ExecOutput e) { | |
550 | ||
551 | assert(context); | |
552 | ||
553 | /* Returns true, if given the specified STDERR and STDOUT output we can directly dup() the stdout fd to the | |
554 | * stderr fd */ | |
555 | ||
556 | if (e == EXEC_OUTPUT_INHERIT) | |
557 | return true; | |
558 | if (e != o) | |
559 | return false; | |
560 | ||
561 | if (e == EXEC_OUTPUT_NAMED_FD) | |
562 | return streq_ptr(context->stdio_fdname[STDOUT_FILENO], context->stdio_fdname[STDERR_FILENO]); | |
563 | ||
564 | if (IN_SET(e, EXEC_OUTPUT_FILE, EXEC_OUTPUT_FILE_APPEND)) | |
565 | return streq_ptr(context->stdio_file[STDOUT_FILENO], context->stdio_file[STDERR_FILENO]); | |
566 | ||
567 | return true; | |
568 | } | |
569 | ||
a34ceba6 | 570 | static int setup_output( |
34cf6c43 | 571 | const Unit *unit, |
a34ceba6 LP |
572 | const ExecContext *context, |
573 | const ExecParameters *params, | |
574 | int fileno, | |
575 | int socket_fd, | |
52c239d7 | 576 | int named_iofds[3], |
a34ceba6 | 577 | const char *ident, |
7bce046b LP |
578 | uid_t uid, |
579 | gid_t gid, | |
580 | dev_t *journal_stream_dev, | |
581 | ino_t *journal_stream_ino) { | |
a34ceba6 | 582 | |
4f2d528d LP |
583 | ExecOutput o; |
584 | ExecInput i; | |
47c1d80d | 585 | int r; |
4f2d528d | 586 | |
f2341e0a | 587 | assert(unit); |
80876c20 | 588 | assert(context); |
a34ceba6 | 589 | assert(params); |
80876c20 | 590 | assert(ident); |
7bce046b LP |
591 | assert(journal_stream_dev); |
592 | assert(journal_stream_ino); | |
80876c20 | 593 | |
a34ceba6 LP |
594 | if (fileno == STDOUT_FILENO && params->stdout_fd >= 0) { |
595 | ||
596 | if (dup2(params->stdout_fd, STDOUT_FILENO) < 0) | |
597 | return -errno; | |
598 | ||
599 | return STDOUT_FILENO; | |
600 | } | |
601 | ||
602 | if (fileno == STDERR_FILENO && params->stderr_fd >= 0) { | |
603 | if (dup2(params->stderr_fd, STDERR_FILENO) < 0) | |
604 | return -errno; | |
605 | ||
606 | return STDERR_FILENO; | |
607 | } | |
608 | ||
08f3be7a | 609 | i = fixup_input(context, socket_fd, params->flags & EXEC_APPLY_TTY_STDIN); |
03fd9c49 | 610 | o = fixup_output(context->std_output, socket_fd); |
4f2d528d | 611 | |
eb17e935 MS |
612 | if (fileno == STDERR_FILENO) { |
613 | ExecOutput e; | |
614 | e = fixup_output(context->std_error, socket_fd); | |
80876c20 | 615 | |
eb17e935 MS |
616 | /* This expects the input and output are already set up */ |
617 | ||
618 | /* Don't change the stderr file descriptor if we inherit all | |
619 | * the way and are not on a tty */ | |
620 | if (e == EXEC_OUTPUT_INHERIT && | |
621 | o == EXEC_OUTPUT_INHERIT && | |
622 | i == EXEC_INPUT_NULL && | |
623 | !is_terminal_input(context->std_input) && | |
624 | getppid () != 1) | |
625 | return fileno; | |
626 | ||
627 | /* Duplicate from stdout if possible */ | |
41fc585a | 628 | if (can_inherit_stderr_from_stdout(context, o, e)) |
eb17e935 | 629 | return dup2(STDOUT_FILENO, fileno) < 0 ? -errno : fileno; |
071830ff | 630 | |
eb17e935 | 631 | o = e; |
80876c20 | 632 | |
eb17e935 | 633 | } else if (o == EXEC_OUTPUT_INHERIT) { |
21d21ea4 LP |
634 | /* If input got downgraded, inherit the original value */ |
635 | if (i == EXEC_INPUT_NULL && is_terminal_input(context->std_input)) | |
1e22b5cd | 636 | return open_terminal_as(exec_context_tty_path(context), O_WRONLY, fileno); |
21d21ea4 | 637 | |
08f3be7a LP |
638 | /* If the input is connected to anything that's not a /dev/null or a data fd, inherit that... */ |
639 | if (!IN_SET(i, EXEC_INPUT_NULL, EXEC_INPUT_DATA)) | |
eb17e935 | 640 | return dup2(STDIN_FILENO, fileno) < 0 ? -errno : fileno; |
071830ff | 641 | |
acb591e4 LP |
642 | /* If we are not started from PID 1 we just inherit STDOUT from our parent process. */ |
643 | if (getppid() != 1) | |
eb17e935 | 644 | return fileno; |
94f04347 | 645 | |
eb17e935 MS |
646 | /* We need to open /dev/null here anew, to get the right access mode. */ |
647 | return open_null_as(O_WRONLY, fileno); | |
071830ff | 648 | } |
94f04347 | 649 | |
eb17e935 | 650 | switch (o) { |
80876c20 LP |
651 | |
652 | case EXEC_OUTPUT_NULL: | |
eb17e935 | 653 | return open_null_as(O_WRONLY, fileno); |
80876c20 LP |
654 | |
655 | case EXEC_OUTPUT_TTY: | |
4f2d528d | 656 | if (is_terminal_input(i)) |
eb17e935 | 657 | return dup2(STDIN_FILENO, fileno) < 0 ? -errno : fileno; |
80876c20 LP |
658 | |
659 | /* We don't reset the terminal if this is just about output */ | |
1e22b5cd | 660 | return open_terminal_as(exec_context_tty_path(context), O_WRONLY, fileno); |
80876c20 LP |
661 | |
662 | case EXEC_OUTPUT_SYSLOG: | |
28dbc1e8 | 663 | case EXEC_OUTPUT_SYSLOG_AND_CONSOLE: |
9a6bca7a | 664 | case EXEC_OUTPUT_KMSG: |
28dbc1e8 | 665 | case EXEC_OUTPUT_KMSG_AND_CONSOLE: |
706343f4 LP |
666 | case EXEC_OUTPUT_JOURNAL: |
667 | case EXEC_OUTPUT_JOURNAL_AND_CONSOLE: | |
af635cf3 | 668 | r = connect_logger_as(unit, context, params, o, ident, fileno, uid, gid); |
47c1d80d | 669 | if (r < 0) { |
82677ae4 | 670 | log_unit_warning_errno(unit, r, "Failed to connect %s to the journal socket, ignoring: %m", fileno == STDOUT_FILENO ? "stdout" : "stderr"); |
eb17e935 | 671 | r = open_null_as(O_WRONLY, fileno); |
7bce046b LP |
672 | } else { |
673 | struct stat st; | |
674 | ||
675 | /* If we connected this fd to the journal via a stream, patch the device/inode into the passed | |
676 | * parameters, but only then. This is useful so that we can set $JOURNAL_STREAM that permits | |
ab2116b1 LP |
677 | * services to detect whether they are connected to the journal or not. |
678 | * | |
679 | * If both stdout and stderr are connected to a stream then let's make sure to store the data | |
680 | * about STDERR as that's usually the best way to do logging. */ | |
7bce046b | 681 | |
ab2116b1 LP |
682 | if (fstat(fileno, &st) >= 0 && |
683 | (*journal_stream_ino == 0 || fileno == STDERR_FILENO)) { | |
7bce046b LP |
684 | *journal_stream_dev = st.st_dev; |
685 | *journal_stream_ino = st.st_ino; | |
686 | } | |
47c1d80d MS |
687 | } |
688 | return r; | |
4f2d528d LP |
689 | |
690 | case EXEC_OUTPUT_SOCKET: | |
691 | assert(socket_fd >= 0); | |
e75a9ed1 | 692 | |
eb17e935 | 693 | return dup2(socket_fd, fileno) < 0 ? -errno : fileno; |
94f04347 | 694 | |
52c239d7 | 695 | case EXEC_OUTPUT_NAMED_FD: |
e75a9ed1 LP |
696 | assert(named_iofds[fileno] >= 0); |
697 | ||
52c239d7 LB |
698 | (void) fd_nonblock(named_iofds[fileno], false); |
699 | return dup2(named_iofds[fileno], fileno) < 0 ? -errno : fileno; | |
700 | ||
566b7d23 ZD |
701 | case EXEC_OUTPUT_FILE: |
702 | case EXEC_OUTPUT_FILE_APPEND: { | |
2038c3f5 | 703 | bool rw; |
566b7d23 | 704 | int fd, flags; |
2038c3f5 LP |
705 | |
706 | assert(context->stdio_file[fileno]); | |
707 | ||
708 | rw = context->std_input == EXEC_INPUT_FILE && | |
709 | streq_ptr(context->stdio_file[fileno], context->stdio_file[STDIN_FILENO]); | |
710 | ||
711 | if (rw) | |
712 | return dup2(STDIN_FILENO, fileno) < 0 ? -errno : fileno; | |
713 | ||
566b7d23 ZD |
714 | flags = O_WRONLY; |
715 | if (o == EXEC_OUTPUT_FILE_APPEND) | |
716 | flags |= O_APPEND; | |
717 | ||
718 | fd = acquire_path(context->stdio_file[fileno], flags, 0666 & ~context->umask); | |
2038c3f5 LP |
719 | if (fd < 0) |
720 | return fd; | |
721 | ||
566b7d23 | 722 | return move_fd(fd, fileno, 0); |
2038c3f5 LP |
723 | } |
724 | ||
94f04347 | 725 | default: |
80876c20 | 726 | assert_not_reached("Unknown error type"); |
94f04347 | 727 | } |
071830ff LP |
728 | } |
729 | ||
02a51aba LP |
730 | static int chown_terminal(int fd, uid_t uid) { |
731 | struct stat st; | |
732 | ||
733 | assert(fd >= 0); | |
02a51aba | 734 | |
1ff74fb6 LP |
735 | /* Before we chown/chmod the TTY, let's ensure this is actually a tty */ |
736 | if (isatty(fd) < 1) | |
737 | return 0; | |
738 | ||
02a51aba | 739 | /* This might fail. What matters are the results. */ |
bab45044 LP |
740 | (void) fchown(fd, uid, -1); |
741 | (void) fchmod(fd, TTY_MODE); | |
02a51aba LP |
742 | |
743 | if (fstat(fd, &st) < 0) | |
744 | return -errno; | |
745 | ||
d8b4e2e9 | 746 | if (st.st_uid != uid || (st.st_mode & 0777) != TTY_MODE) |
02a51aba LP |
747 | return -EPERM; |
748 | ||
749 | return 0; | |
750 | } | |
751 | ||
7d5ceb64 | 752 | static int setup_confirm_stdio(const char *vc, int *_saved_stdin, int *_saved_stdout) { |
3d18b167 LP |
753 | _cleanup_close_ int fd = -1, saved_stdin = -1, saved_stdout = -1; |
754 | int r; | |
80876c20 | 755 | |
80876c20 LP |
756 | assert(_saved_stdin); |
757 | assert(_saved_stdout); | |
758 | ||
af6da548 LP |
759 | saved_stdin = fcntl(STDIN_FILENO, F_DUPFD, 3); |
760 | if (saved_stdin < 0) | |
761 | return -errno; | |
80876c20 | 762 | |
af6da548 | 763 | saved_stdout = fcntl(STDOUT_FILENO, F_DUPFD, 3); |
3d18b167 LP |
764 | if (saved_stdout < 0) |
765 | return -errno; | |
80876c20 | 766 | |
8854d795 | 767 | fd = acquire_terminal(vc, ACQUIRE_TERMINAL_WAIT, DEFAULT_CONFIRM_USEC); |
3d18b167 LP |
768 | if (fd < 0) |
769 | return fd; | |
80876c20 | 770 | |
af6da548 LP |
771 | r = chown_terminal(fd, getuid()); |
772 | if (r < 0) | |
3d18b167 | 773 | return r; |
02a51aba | 774 | |
3d18b167 LP |
775 | r = reset_terminal_fd(fd, true); |
776 | if (r < 0) | |
777 | return r; | |
80876c20 | 778 | |
2b33ab09 | 779 | r = rearrange_stdio(fd, fd, STDERR_FILENO); |
3d18b167 | 780 | fd = -1; |
2b33ab09 LP |
781 | if (r < 0) |
782 | return r; | |
80876c20 LP |
783 | |
784 | *_saved_stdin = saved_stdin; | |
785 | *_saved_stdout = saved_stdout; | |
786 | ||
3d18b167 | 787 | saved_stdin = saved_stdout = -1; |
80876c20 | 788 | |
3d18b167 | 789 | return 0; |
80876c20 LP |
790 | } |
791 | ||
63d77c92 | 792 | static void write_confirm_error_fd(int err, int fd, const Unit *u) { |
3b20f877 FB |
793 | assert(err < 0); |
794 | ||
795 | if (err == -ETIMEDOUT) | |
63d77c92 | 796 | dprintf(fd, "Confirmation question timed out for %s, assuming positive response.\n", u->id); |
3b20f877 FB |
797 | else { |
798 | errno = -err; | |
63d77c92 | 799 | dprintf(fd, "Couldn't ask confirmation for %s: %m, assuming positive response.\n", u->id); |
3b20f877 FB |
800 | } |
801 | } | |
802 | ||
63d77c92 | 803 | static void write_confirm_error(int err, const char *vc, const Unit *u) { |
03e334a1 | 804 | _cleanup_close_ int fd = -1; |
80876c20 | 805 | |
3b20f877 | 806 | assert(vc); |
80876c20 | 807 | |
7d5ceb64 | 808 | fd = open_terminal(vc, O_WRONLY|O_NOCTTY|O_CLOEXEC); |
af6da548 | 809 | if (fd < 0) |
3b20f877 | 810 | return; |
80876c20 | 811 | |
63d77c92 | 812 | write_confirm_error_fd(err, fd, u); |
af6da548 | 813 | } |
80876c20 | 814 | |
3d18b167 | 815 | static int restore_confirm_stdio(int *saved_stdin, int *saved_stdout) { |
af6da548 | 816 | int r = 0; |
80876c20 | 817 | |
af6da548 LP |
818 | assert(saved_stdin); |
819 | assert(saved_stdout); | |
820 | ||
821 | release_terminal(); | |
822 | ||
823 | if (*saved_stdin >= 0) | |
80876c20 | 824 | if (dup2(*saved_stdin, STDIN_FILENO) < 0) |
af6da548 | 825 | r = -errno; |
80876c20 | 826 | |
af6da548 | 827 | if (*saved_stdout >= 0) |
80876c20 | 828 | if (dup2(*saved_stdout, STDOUT_FILENO) < 0) |
af6da548 | 829 | r = -errno; |
80876c20 | 830 | |
3d18b167 LP |
831 | *saved_stdin = safe_close(*saved_stdin); |
832 | *saved_stdout = safe_close(*saved_stdout); | |
af6da548 LP |
833 | |
834 | return r; | |
835 | } | |
836 | ||
3b20f877 FB |
837 | enum { |
838 | CONFIRM_PRETEND_FAILURE = -1, | |
839 | CONFIRM_PRETEND_SUCCESS = 0, | |
840 | CONFIRM_EXECUTE = 1, | |
841 | }; | |
842 | ||
eedf223a | 843 | static int ask_for_confirmation(const char *vc, Unit *u, const char *cmdline) { |
af6da548 | 844 | int saved_stdout = -1, saved_stdin = -1, r; |
2bcd3c26 | 845 | _cleanup_free_ char *e = NULL; |
3b20f877 | 846 | char c; |
af6da548 | 847 | |
3b20f877 | 848 | /* For any internal errors, assume a positive response. */ |
7d5ceb64 | 849 | r = setup_confirm_stdio(vc, &saved_stdin, &saved_stdout); |
3b20f877 | 850 | if (r < 0) { |
63d77c92 | 851 | write_confirm_error(r, vc, u); |
3b20f877 FB |
852 | return CONFIRM_EXECUTE; |
853 | } | |
af6da548 | 854 | |
b0eb2944 FB |
855 | /* confirm_spawn might have been disabled while we were sleeping. */ |
856 | if (manager_is_confirm_spawn_disabled(u->manager)) { | |
857 | r = 1; | |
858 | goto restore_stdio; | |
859 | } | |
af6da548 | 860 | |
2bcd3c26 FB |
861 | e = ellipsize(cmdline, 60, 100); |
862 | if (!e) { | |
863 | log_oom(); | |
864 | r = CONFIRM_EXECUTE; | |
865 | goto restore_stdio; | |
866 | } | |
af6da548 | 867 | |
d172b175 | 868 | for (;;) { |
539622bd | 869 | r = ask_char(&c, "yfshiDjcn", "Execute %s? [y, f, s – h for help] ", e); |
d172b175 | 870 | if (r < 0) { |
63d77c92 | 871 | write_confirm_error_fd(r, STDOUT_FILENO, u); |
d172b175 FB |
872 | r = CONFIRM_EXECUTE; |
873 | goto restore_stdio; | |
874 | } | |
af6da548 | 875 | |
d172b175 | 876 | switch (c) { |
b0eb2944 FB |
877 | case 'c': |
878 | printf("Resuming normal execution.\n"); | |
879 | manager_disable_confirm_spawn(); | |
880 | r = 1; | |
881 | break; | |
dd6f9ac0 FB |
882 | case 'D': |
883 | unit_dump(u, stdout, " "); | |
884 | continue; /* ask again */ | |
d172b175 FB |
885 | case 'f': |
886 | printf("Failing execution.\n"); | |
887 | r = CONFIRM_PRETEND_FAILURE; | |
888 | break; | |
889 | case 'h': | |
b0eb2944 FB |
890 | printf(" c - continue, proceed without asking anymore\n" |
891 | " D - dump, show the state of the unit\n" | |
dd6f9ac0 | 892 | " f - fail, don't execute the command and pretend it failed\n" |
d172b175 | 893 | " h - help\n" |
eedf223a | 894 | " i - info, show a short summary of the unit\n" |
56fde33a | 895 | " j - jobs, show jobs that are in progress\n" |
d172b175 FB |
896 | " s - skip, don't execute the command and pretend it succeeded\n" |
897 | " y - yes, execute the command\n"); | |
dd6f9ac0 | 898 | continue; /* ask again */ |
eedf223a FB |
899 | case 'i': |
900 | printf(" Description: %s\n" | |
901 | " Unit: %s\n" | |
902 | " Command: %s\n", | |
903 | u->id, u->description, cmdline); | |
904 | continue; /* ask again */ | |
56fde33a FB |
905 | case 'j': |
906 | manager_dump_jobs(u->manager, stdout, " "); | |
907 | continue; /* ask again */ | |
539622bd FB |
908 | case 'n': |
909 | /* 'n' was removed in favor of 'f'. */ | |
910 | printf("Didn't understand 'n', did you mean 'f'?\n"); | |
911 | continue; /* ask again */ | |
d172b175 FB |
912 | case 's': |
913 | printf("Skipping execution.\n"); | |
914 | r = CONFIRM_PRETEND_SUCCESS; | |
915 | break; | |
916 | case 'y': | |
917 | r = CONFIRM_EXECUTE; | |
918 | break; | |
919 | default: | |
920 | assert_not_reached("Unhandled choice"); | |
921 | } | |
3b20f877 | 922 | break; |
3b20f877 | 923 | } |
af6da548 | 924 | |
3b20f877 | 925 | restore_stdio: |
af6da548 | 926 | restore_confirm_stdio(&saved_stdin, &saved_stdout); |
af6da548 | 927 | return r; |
80876c20 LP |
928 | } |
929 | ||
4d885bd3 DH |
930 | static int get_fixed_user(const ExecContext *c, const char **user, |
931 | uid_t *uid, gid_t *gid, | |
932 | const char **home, const char **shell) { | |
81a2b7ce | 933 | int r; |
4d885bd3 | 934 | const char *name; |
81a2b7ce | 935 | |
4d885bd3 | 936 | assert(c); |
81a2b7ce | 937 | |
23deef88 LP |
938 | if (!c->user) |
939 | return 0; | |
940 | ||
4d885bd3 DH |
941 | /* Note that we don't set $HOME or $SHELL if they are not particularly enlightening anyway |
942 | * (i.e. are "/" or "/bin/nologin"). */ | |
81a2b7ce | 943 | |
23deef88 | 944 | name = c->user; |
fafff8f1 | 945 | r = get_user_creds(&name, uid, gid, home, shell, USER_CREDS_CLEAN); |
4d885bd3 DH |
946 | if (r < 0) |
947 | return r; | |
81a2b7ce | 948 | |
4d885bd3 DH |
949 | *user = name; |
950 | return 0; | |
951 | } | |
952 | ||
953 | static int get_fixed_group(const ExecContext *c, const char **group, gid_t *gid) { | |
954 | int r; | |
955 | const char *name; | |
956 | ||
957 | assert(c); | |
958 | ||
959 | if (!c->group) | |
960 | return 0; | |
961 | ||
962 | name = c->group; | |
fafff8f1 | 963 | r = get_group_creds(&name, gid, 0); |
4d885bd3 DH |
964 | if (r < 0) |
965 | return r; | |
966 | ||
967 | *group = name; | |
968 | return 0; | |
969 | } | |
970 | ||
cdc5d5c5 DH |
971 | static int get_supplementary_groups(const ExecContext *c, const char *user, |
972 | const char *group, gid_t gid, | |
973 | gid_t **supplementary_gids, int *ngids) { | |
4d885bd3 DH |
974 | char **i; |
975 | int r, k = 0; | |
976 | int ngroups_max; | |
977 | bool keep_groups = false; | |
978 | gid_t *groups = NULL; | |
979 | _cleanup_free_ gid_t *l_gids = NULL; | |
980 | ||
981 | assert(c); | |
982 | ||
bbeea271 DH |
983 | /* |
984 | * If user is given, then lookup GID and supplementary groups list. | |
985 | * We avoid NSS lookups for gid=0. Also we have to initialize groups | |
cdc5d5c5 DH |
986 | * here and as early as possible so we keep the list of supplementary |
987 | * groups of the caller. | |
bbeea271 DH |
988 | */ |
989 | if (user && gid_is_valid(gid) && gid != 0) { | |
990 | /* First step, initialize groups from /etc/groups */ | |
991 | if (initgroups(user, gid) < 0) | |
992 | return -errno; | |
993 | ||
994 | keep_groups = true; | |
995 | } | |
996 | ||
ac6e8be6 | 997 | if (strv_isempty(c->supplementary_groups)) |
4d885bd3 DH |
998 | return 0; |
999 | ||
366ddd25 DH |
1000 | /* |
1001 | * If SupplementaryGroups= was passed then NGROUPS_MAX has to | |
1002 | * be positive, otherwise fail. | |
1003 | */ | |
1004 | errno = 0; | |
1005 | ngroups_max = (int) sysconf(_SC_NGROUPS_MAX); | |
1006 | if (ngroups_max <= 0) { | |
1007 | if (errno > 0) | |
1008 | return -errno; | |
1009 | else | |
1010 | return -EOPNOTSUPP; /* For all other values */ | |
1011 | } | |
1012 | ||
4d885bd3 DH |
1013 | l_gids = new(gid_t, ngroups_max); |
1014 | if (!l_gids) | |
1015 | return -ENOMEM; | |
81a2b7ce | 1016 | |
4d885bd3 DH |
1017 | if (keep_groups) { |
1018 | /* | |
1019 | * Lookup the list of groups that the user belongs to, we | |
1020 | * avoid NSS lookups here too for gid=0. | |
1021 | */ | |
1022 | k = ngroups_max; | |
1023 | if (getgrouplist(user, gid, l_gids, &k) < 0) | |
1024 | return -EINVAL; | |
1025 | } else | |
1026 | k = 0; | |
81a2b7ce | 1027 | |
4d885bd3 DH |
1028 | STRV_FOREACH(i, c->supplementary_groups) { |
1029 | const char *g; | |
81a2b7ce | 1030 | |
4d885bd3 DH |
1031 | if (k >= ngroups_max) |
1032 | return -E2BIG; | |
81a2b7ce | 1033 | |
4d885bd3 | 1034 | g = *i; |
fafff8f1 | 1035 | r = get_group_creds(&g, l_gids+k, 0); |
4d885bd3 DH |
1036 | if (r < 0) |
1037 | return r; | |
81a2b7ce | 1038 | |
4d885bd3 DH |
1039 | k++; |
1040 | } | |
81a2b7ce | 1041 | |
4d885bd3 DH |
1042 | /* |
1043 | * Sets ngids to zero to drop all supplementary groups, happens | |
1044 | * when we are under root and SupplementaryGroups= is empty. | |
1045 | */ | |
1046 | if (k == 0) { | |
1047 | *ngids = 0; | |
1048 | return 0; | |
1049 | } | |
81a2b7ce | 1050 | |
4d885bd3 DH |
1051 | /* Otherwise get the final list of supplementary groups */ |
1052 | groups = memdup(l_gids, sizeof(gid_t) * k); | |
1053 | if (!groups) | |
1054 | return -ENOMEM; | |
1055 | ||
1056 | *supplementary_gids = groups; | |
1057 | *ngids = k; | |
1058 | ||
1059 | groups = NULL; | |
1060 | ||
1061 | return 0; | |
1062 | } | |
1063 | ||
34cf6c43 | 1064 | static int enforce_groups(gid_t gid, const gid_t *supplementary_gids, int ngids) { |
4d885bd3 DH |
1065 | int r; |
1066 | ||
709dbeac YW |
1067 | /* Handle SupplementaryGroups= if it is not empty */ |
1068 | if (ngids > 0) { | |
4d885bd3 DH |
1069 | r = maybe_setgroups(ngids, supplementary_gids); |
1070 | if (r < 0) | |
97f0e76f | 1071 | return r; |
4d885bd3 | 1072 | } |
81a2b7ce | 1073 | |
4d885bd3 DH |
1074 | if (gid_is_valid(gid)) { |
1075 | /* Then set our gids */ | |
1076 | if (setresgid(gid, gid, gid) < 0) | |
1077 | return -errno; | |
81a2b7ce LP |
1078 | } |
1079 | ||
1080 | return 0; | |
1081 | } | |
1082 | ||
1083 | static int enforce_user(const ExecContext *context, uid_t uid) { | |
81a2b7ce LP |
1084 | assert(context); |
1085 | ||
4d885bd3 DH |
1086 | if (!uid_is_valid(uid)) |
1087 | return 0; | |
1088 | ||
479050b3 | 1089 | /* Sets (but doesn't look up) the uid and make sure we keep the |
81a2b7ce LP |
1090 | * capabilities while doing so. */ |
1091 | ||
479050b3 | 1092 | if (context->capability_ambient_set != 0) { |
81a2b7ce LP |
1093 | |
1094 | /* First step: If we need to keep capabilities but | |
1095 | * drop privileges we need to make sure we keep our | |
cbb21cca | 1096 | * caps, while we drop privileges. */ |
693ced48 | 1097 | if (uid != 0) { |
cbb21cca | 1098 | int sb = context->secure_bits | 1<<SECURE_KEEP_CAPS; |
693ced48 LP |
1099 | |
1100 | if (prctl(PR_GET_SECUREBITS) != sb) | |
1101 | if (prctl(PR_SET_SECUREBITS, sb) < 0) | |
1102 | return -errno; | |
1103 | } | |
81a2b7ce LP |
1104 | } |
1105 | ||
479050b3 | 1106 | /* Second step: actually set the uids */ |
81a2b7ce LP |
1107 | if (setresuid(uid, uid, uid) < 0) |
1108 | return -errno; | |
1109 | ||
1110 | /* At this point we should have all necessary capabilities but | |
1111 | are otherwise a normal user. However, the caps might got | |
1112 | corrupted due to the setresuid() so we need clean them up | |
1113 | later. This is done outside of this call. */ | |
1114 | ||
1115 | return 0; | |
1116 | } | |
1117 | ||
349cc4a5 | 1118 | #if HAVE_PAM |
5b6319dc LP |
1119 | |
1120 | static int null_conv( | |
1121 | int num_msg, | |
1122 | const struct pam_message **msg, | |
1123 | struct pam_response **resp, | |
1124 | void *appdata_ptr) { | |
1125 | ||
1126 | /* We don't support conversations */ | |
1127 | ||
1128 | return PAM_CONV_ERR; | |
1129 | } | |
1130 | ||
cefc33ae LP |
1131 | #endif |
1132 | ||
5b6319dc LP |
1133 | static int setup_pam( |
1134 | const char *name, | |
1135 | const char *user, | |
940c5210 | 1136 | uid_t uid, |
2d6fce8d | 1137 | gid_t gid, |
5b6319dc | 1138 | const char *tty, |
2065ca69 | 1139 | char ***env, |
da6053d0 | 1140 | int fds[], size_t n_fds) { |
5b6319dc | 1141 | |
349cc4a5 | 1142 | #if HAVE_PAM |
cefc33ae | 1143 | |
5b6319dc LP |
1144 | static const struct pam_conv conv = { |
1145 | .conv = null_conv, | |
1146 | .appdata_ptr = NULL | |
1147 | }; | |
1148 | ||
2d7c6aa2 | 1149 | _cleanup_(barrier_destroy) Barrier barrier = BARRIER_NULL; |
5b6319dc | 1150 | pam_handle_t *handle = NULL; |
d6e5f3ad | 1151 | sigset_t old_ss; |
7bb70b6e | 1152 | int pam_code = PAM_SUCCESS, r; |
84eada2f | 1153 | char **nv, **e = NULL; |
5b6319dc LP |
1154 | bool close_session = false; |
1155 | pid_t pam_pid = 0, parent_pid; | |
970edce6 | 1156 | int flags = 0; |
5b6319dc LP |
1157 | |
1158 | assert(name); | |
1159 | assert(user); | |
2065ca69 | 1160 | assert(env); |
5b6319dc LP |
1161 | |
1162 | /* We set up PAM in the parent process, then fork. The child | |
35b8ca3a | 1163 | * will then stay around until killed via PR_GET_PDEATHSIG or |
5b6319dc LP |
1164 | * systemd via the cgroup logic. It will then remove the PAM |
1165 | * session again. The parent process will exec() the actual | |
1166 | * daemon. We do things this way to ensure that the main PID | |
1167 | * of the daemon is the one we initially fork()ed. */ | |
1168 | ||
7bb70b6e LP |
1169 | r = barrier_create(&barrier); |
1170 | if (r < 0) | |
2d7c6aa2 DH |
1171 | goto fail; |
1172 | ||
553d2243 | 1173 | if (log_get_max_level() < LOG_DEBUG) |
970edce6 ZJS |
1174 | flags |= PAM_SILENT; |
1175 | ||
f546241b ZJS |
1176 | pam_code = pam_start(name, user, &conv, &handle); |
1177 | if (pam_code != PAM_SUCCESS) { | |
5b6319dc LP |
1178 | handle = NULL; |
1179 | goto fail; | |
1180 | } | |
1181 | ||
3cd24c1a LP |
1182 | if (!tty) { |
1183 | _cleanup_free_ char *q = NULL; | |
1184 | ||
1185 | /* Hmm, so no TTY was explicitly passed, but an fd passed to us directly might be a TTY. Let's figure | |
1186 | * out if that's the case, and read the TTY off it. */ | |
1187 | ||
1188 | if (getttyname_malloc(STDIN_FILENO, &q) >= 0) | |
1189 | tty = strjoina("/dev/", q); | |
1190 | } | |
1191 | ||
f546241b ZJS |
1192 | if (tty) { |
1193 | pam_code = pam_set_item(handle, PAM_TTY, tty); | |
1194 | if (pam_code != PAM_SUCCESS) | |
5b6319dc | 1195 | goto fail; |
f546241b | 1196 | } |
5b6319dc | 1197 | |
84eada2f JW |
1198 | STRV_FOREACH(nv, *env) { |
1199 | pam_code = pam_putenv(handle, *nv); | |
2065ca69 JW |
1200 | if (pam_code != PAM_SUCCESS) |
1201 | goto fail; | |
1202 | } | |
1203 | ||
970edce6 | 1204 | pam_code = pam_acct_mgmt(handle, flags); |
f546241b | 1205 | if (pam_code != PAM_SUCCESS) |
5b6319dc LP |
1206 | goto fail; |
1207 | ||
970edce6 | 1208 | pam_code = pam_open_session(handle, flags); |
f546241b | 1209 | if (pam_code != PAM_SUCCESS) |
5b6319dc LP |
1210 | goto fail; |
1211 | ||
1212 | close_session = true; | |
1213 | ||
f546241b ZJS |
1214 | e = pam_getenvlist(handle); |
1215 | if (!e) { | |
5b6319dc LP |
1216 | pam_code = PAM_BUF_ERR; |
1217 | goto fail; | |
1218 | } | |
1219 | ||
1220 | /* Block SIGTERM, so that we know that it won't get lost in | |
1221 | * the child */ | |
ce30c8dc | 1222 | |
72c0a2c2 | 1223 | assert_se(sigprocmask_many(SIG_BLOCK, &old_ss, SIGTERM, -1) >= 0); |
5b6319dc | 1224 | |
df0ff127 | 1225 | parent_pid = getpid_cached(); |
5b6319dc | 1226 | |
4c253ed1 LP |
1227 | r = safe_fork("(sd-pam)", 0, &pam_pid); |
1228 | if (r < 0) | |
5b6319dc | 1229 | goto fail; |
4c253ed1 | 1230 | if (r == 0) { |
7bb70b6e | 1231 | int sig, ret = EXIT_PAM; |
5b6319dc LP |
1232 | |
1233 | /* The child's job is to reset the PAM session on | |
1234 | * termination */ | |
2d7c6aa2 | 1235 | barrier_set_role(&barrier, BARRIER_CHILD); |
5b6319dc | 1236 | |
4c253ed1 LP |
1237 | /* Make sure we don't keep open the passed fds in this child. We assume that otherwise only those fds |
1238 | * are open here that have been opened by PAM. */ | |
1239 | (void) close_many(fds, n_fds); | |
5b6319dc | 1240 | |
940c5210 AK |
1241 | /* Drop privileges - we don't need any to pam_close_session |
1242 | * and this will make PR_SET_PDEATHSIG work in most cases. | |
1243 | * If this fails, ignore the error - but expect sd-pam threads | |
1244 | * to fail to exit normally */ | |
2d6fce8d | 1245 | |
97f0e76f LP |
1246 | r = maybe_setgroups(0, NULL); |
1247 | if (r < 0) | |
1248 | log_warning_errno(r, "Failed to setgroups() in sd-pam: %m"); | |
2d6fce8d LP |
1249 | if (setresgid(gid, gid, gid) < 0) |
1250 | log_warning_errno(errno, "Failed to setresgid() in sd-pam: %m"); | |
940c5210 | 1251 | if (setresuid(uid, uid, uid) < 0) |
2d6fce8d | 1252 | log_warning_errno(errno, "Failed to setresuid() in sd-pam: %m"); |
940c5210 | 1253 | |
ce30c8dc LP |
1254 | (void) ignore_signals(SIGPIPE, -1); |
1255 | ||
940c5210 AK |
1256 | /* Wait until our parent died. This will only work if |
1257 | * the above setresuid() succeeds, otherwise the kernel | |
1258 | * will not allow unprivileged parents kill their privileged | |
1259 | * children this way. We rely on the control groups kill logic | |
5b6319dc LP |
1260 | * to do the rest for us. */ |
1261 | if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0) | |
1262 | goto child_finish; | |
1263 | ||
2d7c6aa2 DH |
1264 | /* Tell the parent that our setup is done. This is especially |
1265 | * important regarding dropping privileges. Otherwise, unit | |
643f4706 ZJS |
1266 | * setup might race against our setresuid(2) call. |
1267 | * | |
1268 | * If the parent aborted, we'll detect this below, hence ignore | |
1269 | * return failure here. */ | |
1270 | (void) barrier_place(&barrier); | |
2d7c6aa2 | 1271 | |
643f4706 | 1272 | /* Check if our parent process might already have died? */ |
5b6319dc | 1273 | if (getppid() == parent_pid) { |
d6e5f3ad DM |
1274 | sigset_t ss; |
1275 | ||
1276 | assert_se(sigemptyset(&ss) >= 0); | |
1277 | assert_se(sigaddset(&ss, SIGTERM) >= 0); | |
1278 | ||
3dead8d9 LP |
1279 | for (;;) { |
1280 | if (sigwait(&ss, &sig) < 0) { | |
1281 | if (errno == EINTR) | |
1282 | continue; | |
1283 | ||
1284 | goto child_finish; | |
1285 | } | |
5b6319dc | 1286 | |
3dead8d9 LP |
1287 | assert(sig == SIGTERM); |
1288 | break; | |
1289 | } | |
5b6319dc LP |
1290 | } |
1291 | ||
3dead8d9 | 1292 | /* If our parent died we'll end the session */ |
f546241b | 1293 | if (getppid() != parent_pid) { |
970edce6 | 1294 | pam_code = pam_close_session(handle, flags); |
f546241b | 1295 | if (pam_code != PAM_SUCCESS) |
5b6319dc | 1296 | goto child_finish; |
f546241b | 1297 | } |
5b6319dc | 1298 | |
7bb70b6e | 1299 | ret = 0; |
5b6319dc LP |
1300 | |
1301 | child_finish: | |
970edce6 | 1302 | pam_end(handle, pam_code | flags); |
7bb70b6e | 1303 | _exit(ret); |
5b6319dc LP |
1304 | } |
1305 | ||
2d7c6aa2 DH |
1306 | barrier_set_role(&barrier, BARRIER_PARENT); |
1307 | ||
5b6319dc LP |
1308 | /* If the child was forked off successfully it will do all the |
1309 | * cleanups, so forget about the handle here. */ | |
1310 | handle = NULL; | |
1311 | ||
3b8bddde | 1312 | /* Unblock SIGTERM again in the parent */ |
72c0a2c2 | 1313 | assert_se(sigprocmask(SIG_SETMASK, &old_ss, NULL) >= 0); |
5b6319dc LP |
1314 | |
1315 | /* We close the log explicitly here, since the PAM modules | |
1316 | * might have opened it, but we don't want this fd around. */ | |
1317 | closelog(); | |
1318 | ||
2d7c6aa2 DH |
1319 | /* Synchronously wait for the child to initialize. We don't care for |
1320 | * errors as we cannot recover. However, warn loudly if it happens. */ | |
1321 | if (!barrier_place_and_sync(&barrier)) | |
1322 | log_error("PAM initialization failed"); | |
1323 | ||
130d3d22 | 1324 | return strv_free_and_replace(*env, e); |
5b6319dc LP |
1325 | |
1326 | fail: | |
970edce6 ZJS |
1327 | if (pam_code != PAM_SUCCESS) { |
1328 | log_error("PAM failed: %s", pam_strerror(handle, pam_code)); | |
7bb70b6e LP |
1329 | r = -EPERM; /* PAM errors do not map to errno */ |
1330 | } else | |
1331 | log_error_errno(r, "PAM failed: %m"); | |
9ba35398 | 1332 | |
5b6319dc LP |
1333 | if (handle) { |
1334 | if (close_session) | |
970edce6 | 1335 | pam_code = pam_close_session(handle, flags); |
5b6319dc | 1336 | |
970edce6 | 1337 | pam_end(handle, pam_code | flags); |
5b6319dc LP |
1338 | } |
1339 | ||
1340 | strv_free(e); | |
5b6319dc LP |
1341 | closelog(); |
1342 | ||
7bb70b6e | 1343 | return r; |
cefc33ae LP |
1344 | #else |
1345 | return 0; | |
5b6319dc | 1346 | #endif |
cefc33ae | 1347 | } |
5b6319dc | 1348 | |
5d6b1584 LP |
1349 | static void rename_process_from_path(const char *path) { |
1350 | char process_name[11]; | |
1351 | const char *p; | |
1352 | size_t l; | |
1353 | ||
1354 | /* This resulting string must fit in 10 chars (i.e. the length | |
1355 | * of "/sbin/init") to look pretty in /bin/ps */ | |
1356 | ||
2b6bf07d | 1357 | p = basename(path); |
5d6b1584 LP |
1358 | if (isempty(p)) { |
1359 | rename_process("(...)"); | |
1360 | return; | |
1361 | } | |
1362 | ||
1363 | l = strlen(p); | |
1364 | if (l > 8) { | |
1365 | /* The end of the process name is usually more | |
1366 | * interesting, since the first bit might just be | |
1367 | * "systemd-" */ | |
1368 | p = p + l - 8; | |
1369 | l = 8; | |
1370 | } | |
1371 | ||
1372 | process_name[0] = '('; | |
1373 | memcpy(process_name+1, p, l); | |
1374 | process_name[1+l] = ')'; | |
1375 | process_name[1+l+1] = 0; | |
1376 | ||
1377 | rename_process(process_name); | |
1378 | } | |
1379 | ||
469830d1 LP |
1380 | static bool context_has_address_families(const ExecContext *c) { |
1381 | assert(c); | |
1382 | ||
1383 | return c->address_families_whitelist || | |
1384 | !set_isempty(c->address_families); | |
1385 | } | |
1386 | ||
1387 | static bool context_has_syscall_filters(const ExecContext *c) { | |
1388 | assert(c); | |
1389 | ||
1390 | return c->syscall_whitelist || | |
8cfa775f | 1391 | !hashmap_isempty(c->syscall_filter); |
469830d1 LP |
1392 | } |
1393 | ||
1394 | static bool context_has_no_new_privileges(const ExecContext *c) { | |
1395 | assert(c); | |
1396 | ||
1397 | if (c->no_new_privileges) | |
1398 | return true; | |
1399 | ||
1400 | if (have_effective_cap(CAP_SYS_ADMIN)) /* if we are privileged, we don't need NNP */ | |
1401 | return false; | |
1402 | ||
1403 | /* We need NNP if we have any form of seccomp and are unprivileged */ | |
1404 | return context_has_address_families(c) || | |
1405 | c->memory_deny_write_execute || | |
1406 | c->restrict_realtime || | |
1407 | exec_context_restrict_namespaces_set(c) || | |
1408 | c->protect_kernel_tunables || | |
1409 | c->protect_kernel_modules || | |
1410 | c->private_devices || | |
1411 | context_has_syscall_filters(c) || | |
78e864e5 TM |
1412 | !set_isempty(c->syscall_archs) || |
1413 | c->lock_personality; | |
469830d1 LP |
1414 | } |
1415 | ||
349cc4a5 | 1416 | #if HAVE_SECCOMP |
17df7223 | 1417 | |
83f12b27 | 1418 | static bool skip_seccomp_unavailable(const Unit* u, const char* msg) { |
f673b62d LP |
1419 | |
1420 | if (is_seccomp_available()) | |
1421 | return false; | |
1422 | ||
f673b62d | 1423 | log_unit_debug(u, "SECCOMP features not detected in the kernel, skipping %s", msg); |
f673b62d | 1424 | return true; |
83f12b27 FS |
1425 | } |
1426 | ||
165a31c0 | 1427 | static int apply_syscall_filter(const Unit* u, const ExecContext *c, bool needs_ambient_hack) { |
469830d1 | 1428 | uint32_t negative_action, default_action, action; |
165a31c0 | 1429 | int r; |
8351ceae | 1430 | |
469830d1 | 1431 | assert(u); |
c0467cf3 | 1432 | assert(c); |
8351ceae | 1433 | |
469830d1 | 1434 | if (!context_has_syscall_filters(c)) |
83f12b27 FS |
1435 | return 0; |
1436 | ||
469830d1 LP |
1437 | if (skip_seccomp_unavailable(u, "SystemCallFilter=")) |
1438 | return 0; | |
e9642be2 | 1439 | |
469830d1 | 1440 | negative_action = c->syscall_errno == 0 ? SCMP_ACT_KILL : SCMP_ACT_ERRNO(c->syscall_errno); |
e9642be2 | 1441 | |
469830d1 LP |
1442 | if (c->syscall_whitelist) { |
1443 | default_action = negative_action; | |
1444 | action = SCMP_ACT_ALLOW; | |
7c66bae2 | 1445 | } else { |
469830d1 LP |
1446 | default_action = SCMP_ACT_ALLOW; |
1447 | action = negative_action; | |
57183d11 | 1448 | } |
8351ceae | 1449 | |
165a31c0 LP |
1450 | if (needs_ambient_hack) { |
1451 | r = seccomp_filter_set_add(c->syscall_filter, c->syscall_whitelist, syscall_filter_sets + SYSCALL_FILTER_SET_SETUID); | |
1452 | if (r < 0) | |
1453 | return r; | |
1454 | } | |
1455 | ||
b54f36c6 | 1456 | return seccomp_load_syscall_filter_set_raw(default_action, c->syscall_filter, action, false); |
4298d0b5 LP |
1457 | } |
1458 | ||
469830d1 LP |
1459 | static int apply_syscall_archs(const Unit *u, const ExecContext *c) { |
1460 | assert(u); | |
4298d0b5 LP |
1461 | assert(c); |
1462 | ||
469830d1 | 1463 | if (set_isempty(c->syscall_archs)) |
83f12b27 FS |
1464 | return 0; |
1465 | ||
469830d1 LP |
1466 | if (skip_seccomp_unavailable(u, "SystemCallArchitectures=")) |
1467 | return 0; | |
4298d0b5 | 1468 | |
469830d1 LP |
1469 | return seccomp_restrict_archs(c->syscall_archs); |
1470 | } | |
4298d0b5 | 1471 | |
469830d1 LP |
1472 | static int apply_address_families(const Unit* u, const ExecContext *c) { |
1473 | assert(u); | |
1474 | assert(c); | |
4298d0b5 | 1475 | |
469830d1 LP |
1476 | if (!context_has_address_families(c)) |
1477 | return 0; | |
4298d0b5 | 1478 | |
469830d1 LP |
1479 | if (skip_seccomp_unavailable(u, "RestrictAddressFamilies=")) |
1480 | return 0; | |
4298d0b5 | 1481 | |
469830d1 | 1482 | return seccomp_restrict_address_families(c->address_families, c->address_families_whitelist); |
8351ceae | 1483 | } |
4298d0b5 | 1484 | |
83f12b27 | 1485 | static int apply_memory_deny_write_execute(const Unit* u, const ExecContext *c) { |
469830d1 | 1486 | assert(u); |
f3e43635 TM |
1487 | assert(c); |
1488 | ||
469830d1 | 1489 | if (!c->memory_deny_write_execute) |
83f12b27 FS |
1490 | return 0; |
1491 | ||
469830d1 LP |
1492 | if (skip_seccomp_unavailable(u, "MemoryDenyWriteExecute=")) |
1493 | return 0; | |
f3e43635 | 1494 | |
469830d1 | 1495 | return seccomp_memory_deny_write_execute(); |
f3e43635 TM |
1496 | } |
1497 | ||
83f12b27 | 1498 | static int apply_restrict_realtime(const Unit* u, const ExecContext *c) { |
469830d1 | 1499 | assert(u); |
f4170c67 LP |
1500 | assert(c); |
1501 | ||
469830d1 | 1502 | if (!c->restrict_realtime) |
83f12b27 FS |
1503 | return 0; |
1504 | ||
469830d1 LP |
1505 | if (skip_seccomp_unavailable(u, "RestrictRealtime=")) |
1506 | return 0; | |
f4170c67 | 1507 | |
469830d1 | 1508 | return seccomp_restrict_realtime(); |
f4170c67 LP |
1509 | } |
1510 | ||
59e856c7 | 1511 | static int apply_protect_sysctl(const Unit *u, const ExecContext *c) { |
469830d1 | 1512 | assert(u); |
59eeb84b LP |
1513 | assert(c); |
1514 | ||
1515 | /* Turn off the legacy sysctl() system call. Many distributions turn this off while building the kernel, but | |
1516 | * let's protect even those systems where this is left on in the kernel. */ | |
1517 | ||
469830d1 | 1518 | if (!c->protect_kernel_tunables) |
59eeb84b LP |
1519 | return 0; |
1520 | ||
469830d1 LP |
1521 | if (skip_seccomp_unavailable(u, "ProtectKernelTunables=")) |
1522 | return 0; | |
59eeb84b | 1523 | |
469830d1 | 1524 | return seccomp_protect_sysctl(); |
59eeb84b LP |
1525 | } |
1526 | ||
59e856c7 | 1527 | static int apply_protect_kernel_modules(const Unit *u, const ExecContext *c) { |
469830d1 | 1528 | assert(u); |
502d704e DH |
1529 | assert(c); |
1530 | ||
25a8d8a0 | 1531 | /* Turn off module syscalls on ProtectKernelModules=yes */ |
502d704e | 1532 | |
469830d1 LP |
1533 | if (!c->protect_kernel_modules) |
1534 | return 0; | |
1535 | ||
502d704e DH |
1536 | if (skip_seccomp_unavailable(u, "ProtectKernelModules=")) |
1537 | return 0; | |
1538 | ||
b54f36c6 | 1539 | return seccomp_load_syscall_filter_set(SCMP_ACT_ALLOW, syscall_filter_sets + SYSCALL_FILTER_SET_MODULE, SCMP_ACT_ERRNO(EPERM), false); |
502d704e DH |
1540 | } |
1541 | ||
59e856c7 | 1542 | static int apply_private_devices(const Unit *u, const ExecContext *c) { |
469830d1 | 1543 | assert(u); |
ba128bb8 LP |
1544 | assert(c); |
1545 | ||
8f81a5f6 | 1546 | /* If PrivateDevices= is set, also turn off iopl and all @raw-io syscalls. */ |
ba128bb8 | 1547 | |
469830d1 LP |
1548 | if (!c->private_devices) |
1549 | return 0; | |
1550 | ||
ba128bb8 LP |
1551 | if (skip_seccomp_unavailable(u, "PrivateDevices=")) |
1552 | return 0; | |
1553 | ||
b54f36c6 | 1554 | return seccomp_load_syscall_filter_set(SCMP_ACT_ALLOW, syscall_filter_sets + SYSCALL_FILTER_SET_RAW_IO, SCMP_ACT_ERRNO(EPERM), false); |
ba128bb8 LP |
1555 | } |
1556 | ||
34cf6c43 | 1557 | static int apply_restrict_namespaces(const Unit *u, const ExecContext *c) { |
469830d1 | 1558 | assert(u); |
add00535 LP |
1559 | assert(c); |
1560 | ||
1561 | if (!exec_context_restrict_namespaces_set(c)) | |
1562 | return 0; | |
1563 | ||
1564 | if (skip_seccomp_unavailable(u, "RestrictNamespaces=")) | |
1565 | return 0; | |
1566 | ||
1567 | return seccomp_restrict_namespaces(c->restrict_namespaces); | |
1568 | } | |
1569 | ||
78e864e5 | 1570 | static int apply_lock_personality(const Unit* u, const ExecContext *c) { |
e8132d63 LP |
1571 | unsigned long personality; |
1572 | int r; | |
78e864e5 TM |
1573 | |
1574 | assert(u); | |
1575 | assert(c); | |
1576 | ||
1577 | if (!c->lock_personality) | |
1578 | return 0; | |
1579 | ||
1580 | if (skip_seccomp_unavailable(u, "LockPersonality=")) | |
1581 | return 0; | |
1582 | ||
e8132d63 LP |
1583 | personality = c->personality; |
1584 | ||
1585 | /* If personality is not specified, use either PER_LINUX or PER_LINUX32 depending on what is currently set. */ | |
1586 | if (personality == PERSONALITY_INVALID) { | |
1587 | ||
1588 | r = opinionated_personality(&personality); | |
1589 | if (r < 0) | |
1590 | return r; | |
1591 | } | |
78e864e5 TM |
1592 | |
1593 | return seccomp_lock_personality(personality); | |
1594 | } | |
1595 | ||
c0467cf3 | 1596 | #endif |
8351ceae | 1597 | |
3042bbeb | 1598 | static void do_idle_pipe_dance(int idle_pipe[static 4]) { |
31a7eb86 ZJS |
1599 | assert(idle_pipe); |
1600 | ||
54eb2300 LP |
1601 | idle_pipe[1] = safe_close(idle_pipe[1]); |
1602 | idle_pipe[2] = safe_close(idle_pipe[2]); | |
31a7eb86 ZJS |
1603 | |
1604 | if (idle_pipe[0] >= 0) { | |
1605 | int r; | |
1606 | ||
1607 | r = fd_wait_for_event(idle_pipe[0], POLLHUP, IDLE_TIMEOUT_USEC); | |
1608 | ||
1609 | if (idle_pipe[3] >= 0 && r == 0 /* timeout */) { | |
c7cc737f LP |
1610 | ssize_t n; |
1611 | ||
31a7eb86 | 1612 | /* Signal systemd that we are bored and want to continue. */ |
c7cc737f LP |
1613 | n = write(idle_pipe[3], "x", 1); |
1614 | if (n > 0) | |
cd972d69 ZJS |
1615 | /* Wait for systemd to react to the signal above. */ |
1616 | fd_wait_for_event(idle_pipe[0], POLLHUP, IDLE_TIMEOUT2_USEC); | |
31a7eb86 ZJS |
1617 | } |
1618 | ||
54eb2300 | 1619 | idle_pipe[0] = safe_close(idle_pipe[0]); |
31a7eb86 ZJS |
1620 | |
1621 | } | |
1622 | ||
54eb2300 | 1623 | idle_pipe[3] = safe_close(idle_pipe[3]); |
31a7eb86 ZJS |
1624 | } |
1625 | ||
fb2042dd YW |
1626 | static const char *exec_directory_env_name_to_string(ExecDirectoryType t); |
1627 | ||
7cae38c4 | 1628 | static int build_environment( |
34cf6c43 | 1629 | const Unit *u, |
9fa95f85 | 1630 | const ExecContext *c, |
1e22b5cd | 1631 | const ExecParameters *p, |
da6053d0 | 1632 | size_t n_fds, |
7cae38c4 LP |
1633 | const char *home, |
1634 | const char *username, | |
1635 | const char *shell, | |
7bce046b LP |
1636 | dev_t journal_stream_dev, |
1637 | ino_t journal_stream_ino, | |
7cae38c4 LP |
1638 | char ***ret) { |
1639 | ||
1640 | _cleanup_strv_free_ char **our_env = NULL; | |
fb2042dd | 1641 | ExecDirectoryType t; |
da6053d0 | 1642 | size_t n_env = 0; |
7cae38c4 LP |
1643 | char *x; |
1644 | ||
4b58153d | 1645 | assert(u); |
7cae38c4 | 1646 | assert(c); |
7c1cb6f1 | 1647 | assert(p); |
7cae38c4 LP |
1648 | assert(ret); |
1649 | ||
fb2042dd | 1650 | our_env = new0(char*, 14 + _EXEC_DIRECTORY_TYPE_MAX); |
7cae38c4 LP |
1651 | if (!our_env) |
1652 | return -ENOMEM; | |
1653 | ||
1654 | if (n_fds > 0) { | |
8dd4c05b LP |
1655 | _cleanup_free_ char *joined = NULL; |
1656 | ||
df0ff127 | 1657 | if (asprintf(&x, "LISTEN_PID="PID_FMT, getpid_cached()) < 0) |
7cae38c4 LP |
1658 | return -ENOMEM; |
1659 | our_env[n_env++] = x; | |
1660 | ||
da6053d0 | 1661 | if (asprintf(&x, "LISTEN_FDS=%zu", n_fds) < 0) |
7cae38c4 LP |
1662 | return -ENOMEM; |
1663 | our_env[n_env++] = x; | |
8dd4c05b | 1664 | |
1e22b5cd | 1665 | joined = strv_join(p->fd_names, ":"); |
8dd4c05b LP |
1666 | if (!joined) |
1667 | return -ENOMEM; | |
1668 | ||
605405c6 | 1669 | x = strjoin("LISTEN_FDNAMES=", joined); |
8dd4c05b LP |
1670 | if (!x) |
1671 | return -ENOMEM; | |
1672 | our_env[n_env++] = x; | |
7cae38c4 LP |
1673 | } |
1674 | ||
b08af3b1 | 1675 | if ((p->flags & EXEC_SET_WATCHDOG) && p->watchdog_usec > 0) { |
df0ff127 | 1676 | if (asprintf(&x, "WATCHDOG_PID="PID_FMT, getpid_cached()) < 0) |
09812eb7 LP |
1677 | return -ENOMEM; |
1678 | our_env[n_env++] = x; | |
1679 | ||
1e22b5cd | 1680 | if (asprintf(&x, "WATCHDOG_USEC="USEC_FMT, p->watchdog_usec) < 0) |
09812eb7 LP |
1681 | return -ENOMEM; |
1682 | our_env[n_env++] = x; | |
1683 | } | |
1684 | ||
fd63e712 LP |
1685 | /* If this is D-Bus, tell the nss-systemd module, since it relies on being able to use D-Bus look up dynamic |
1686 | * users via PID 1, possibly dead-locking the dbus daemon. This way it will not use D-Bus to resolve names, but | |
1687 | * check the database directly. */ | |
ac647978 | 1688 | if (p->flags & EXEC_NSS_BYPASS_BUS) { |
fd63e712 LP |
1689 | x = strdup("SYSTEMD_NSS_BYPASS_BUS=1"); |
1690 | if (!x) | |
1691 | return -ENOMEM; | |
1692 | our_env[n_env++] = x; | |
1693 | } | |
1694 | ||
7cae38c4 LP |
1695 | if (home) { |
1696 | x = strappend("HOME=", home); | |
1697 | if (!x) | |
1698 | return -ENOMEM; | |
1699 | our_env[n_env++] = x; | |
1700 | } | |
1701 | ||
1702 | if (username) { | |
1703 | x = strappend("LOGNAME=", username); | |
1704 | if (!x) | |
1705 | return -ENOMEM; | |
1706 | our_env[n_env++] = x; | |
1707 | ||
1708 | x = strappend("USER=", username); | |
1709 | if (!x) | |
1710 | return -ENOMEM; | |
1711 | our_env[n_env++] = x; | |
1712 | } | |
1713 | ||
1714 | if (shell) { | |
1715 | x = strappend("SHELL=", shell); | |
1716 | if (!x) | |
1717 | return -ENOMEM; | |
1718 | our_env[n_env++] = x; | |
1719 | } | |
1720 | ||
4b58153d LP |
1721 | if (!sd_id128_is_null(u->invocation_id)) { |
1722 | if (asprintf(&x, "INVOCATION_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(u->invocation_id)) < 0) | |
1723 | return -ENOMEM; | |
1724 | ||
1725 | our_env[n_env++] = x; | |
1726 | } | |
1727 | ||
6af760f3 LP |
1728 | if (exec_context_needs_term(c)) { |
1729 | const char *tty_path, *term = NULL; | |
1730 | ||
1731 | tty_path = exec_context_tty_path(c); | |
1732 | ||
1733 | /* If we are forked off PID 1 and we are supposed to operate on /dev/console, then let's try to inherit | |
1734 | * the $TERM set for PID 1. This is useful for containers so that the $TERM the container manager | |
1735 | * passes to PID 1 ends up all the way in the console login shown. */ | |
1736 | ||
1737 | if (path_equal(tty_path, "/dev/console") && getppid() == 1) | |
1738 | term = getenv("TERM"); | |
1739 | if (!term) | |
1740 | term = default_term_for_tty(tty_path); | |
7cae38c4 | 1741 | |
6af760f3 | 1742 | x = strappend("TERM=", term); |
7cae38c4 LP |
1743 | if (!x) |
1744 | return -ENOMEM; | |
1745 | our_env[n_env++] = x; | |
1746 | } | |
1747 | ||
7bce046b LP |
1748 | if (journal_stream_dev != 0 && journal_stream_ino != 0) { |
1749 | if (asprintf(&x, "JOURNAL_STREAM=" DEV_FMT ":" INO_FMT, journal_stream_dev, journal_stream_ino) < 0) | |
1750 | return -ENOMEM; | |
1751 | ||
1752 | our_env[n_env++] = x; | |
1753 | } | |
1754 | ||
fb2042dd YW |
1755 | for (t = 0; t < _EXEC_DIRECTORY_TYPE_MAX; t++) { |
1756 | _cleanup_free_ char *pre = NULL, *joined = NULL; | |
1757 | const char *n; | |
1758 | ||
1759 | if (!p->prefix[t]) | |
1760 | continue; | |
1761 | ||
1762 | if (strv_isempty(c->directories[t].paths)) | |
1763 | continue; | |
1764 | ||
1765 | n = exec_directory_env_name_to_string(t); | |
1766 | if (!n) | |
1767 | continue; | |
1768 | ||
1769 | pre = strjoin(p->prefix[t], "/"); | |
1770 | if (!pre) | |
1771 | return -ENOMEM; | |
1772 | ||
1773 | joined = strv_join_prefix(c->directories[t].paths, ":", pre); | |
1774 | if (!joined) | |
1775 | return -ENOMEM; | |
1776 | ||
1777 | x = strjoin(n, "=", joined); | |
1778 | if (!x) | |
1779 | return -ENOMEM; | |
1780 | ||
1781 | our_env[n_env++] = x; | |
1782 | } | |
1783 | ||
7cae38c4 | 1784 | our_env[n_env++] = NULL; |
fb2042dd | 1785 | assert(n_env <= 14 + _EXEC_DIRECTORY_TYPE_MAX); |
7cae38c4 | 1786 | |
ae2a15bc | 1787 | *ret = TAKE_PTR(our_env); |
7cae38c4 LP |
1788 | |
1789 | return 0; | |
1790 | } | |
1791 | ||
b4c14404 FB |
1792 | static int build_pass_environment(const ExecContext *c, char ***ret) { |
1793 | _cleanup_strv_free_ char **pass_env = NULL; | |
1794 | size_t n_env = 0, n_bufsize = 0; | |
1795 | char **i; | |
1796 | ||
1797 | STRV_FOREACH(i, c->pass_environment) { | |
1798 | _cleanup_free_ char *x = NULL; | |
1799 | char *v; | |
1800 | ||
1801 | v = getenv(*i); | |
1802 | if (!v) | |
1803 | continue; | |
605405c6 | 1804 | x = strjoin(*i, "=", v); |
b4c14404 FB |
1805 | if (!x) |
1806 | return -ENOMEM; | |
00819cc1 | 1807 | |
b4c14404 FB |
1808 | if (!GREEDY_REALLOC(pass_env, n_bufsize, n_env + 2)) |
1809 | return -ENOMEM; | |
00819cc1 | 1810 | |
1cc6c93a | 1811 | pass_env[n_env++] = TAKE_PTR(x); |
b4c14404 | 1812 | pass_env[n_env] = NULL; |
b4c14404 FB |
1813 | } |
1814 | ||
ae2a15bc | 1815 | *ret = TAKE_PTR(pass_env); |
b4c14404 FB |
1816 | |
1817 | return 0; | |
1818 | } | |
1819 | ||
8b44a3d2 LP |
1820 | static bool exec_needs_mount_namespace( |
1821 | const ExecContext *context, | |
1822 | const ExecParameters *params, | |
4657abb5 | 1823 | const ExecRuntime *runtime) { |
8b44a3d2 LP |
1824 | |
1825 | assert(context); | |
1826 | assert(params); | |
1827 | ||
915e6d16 LP |
1828 | if (context->root_image) |
1829 | return true; | |
1830 | ||
2a624c36 AP |
1831 | if (!strv_isempty(context->read_write_paths) || |
1832 | !strv_isempty(context->read_only_paths) || | |
1833 | !strv_isempty(context->inaccessible_paths)) | |
8b44a3d2 LP |
1834 | return true; |
1835 | ||
42b1d8e0 | 1836 | if (context->n_bind_mounts > 0) |
d2d6c096 LP |
1837 | return true; |
1838 | ||
2abd4e38 YW |
1839 | if (context->n_temporary_filesystems > 0) |
1840 | return true; | |
1841 | ||
8b44a3d2 LP |
1842 | if (context->mount_flags != 0) |
1843 | return true; | |
1844 | ||
1845 | if (context->private_tmp && runtime && (runtime->tmp_dir || runtime->var_tmp_dir)) | |
1846 | return true; | |
1847 | ||
8b44a3d2 | 1848 | if (context->private_devices || |
228af36f | 1849 | context->private_mounts || |
8b44a3d2 | 1850 | context->protect_system != PROTECT_SYSTEM_NO || |
59eeb84b LP |
1851 | context->protect_home != PROTECT_HOME_NO || |
1852 | context->protect_kernel_tunables || | |
c575770b | 1853 | context->protect_kernel_modules || |
59eeb84b | 1854 | context->protect_control_groups) |
8b44a3d2 LP |
1855 | return true; |
1856 | ||
37c56f89 YW |
1857 | if (context->root_directory) { |
1858 | ExecDirectoryType t; | |
1859 | ||
1860 | if (context->mount_apivfs) | |
1861 | return true; | |
1862 | ||
1863 | for (t = 0; t < _EXEC_DIRECTORY_TYPE_MAX; t++) { | |
1864 | if (!params->prefix[t]) | |
1865 | continue; | |
1866 | ||
1867 | if (!strv_isempty(context->directories[t].paths)) | |
1868 | return true; | |
1869 | } | |
1870 | } | |
5d997827 | 1871 | |
42b1d8e0 | 1872 | if (context->dynamic_user && |
b43ee82f | 1873 | (!strv_isempty(context->directories[EXEC_DIRECTORY_STATE].paths) || |
42b1d8e0 YW |
1874 | !strv_isempty(context->directories[EXEC_DIRECTORY_CACHE].paths) || |
1875 | !strv_isempty(context->directories[EXEC_DIRECTORY_LOGS].paths))) | |
1876 | return true; | |
1877 | ||
8b44a3d2 LP |
1878 | return false; |
1879 | } | |
1880 | ||
d251207d LP |
1881 | static int setup_private_users(uid_t uid, gid_t gid) { |
1882 | _cleanup_free_ char *uid_map = NULL, *gid_map = NULL; | |
1883 | _cleanup_close_pair_ int errno_pipe[2] = { -1, -1 }; | |
1884 | _cleanup_close_ int unshare_ready_fd = -1; | |
1885 | _cleanup_(sigkill_waitp) pid_t pid = 0; | |
1886 | uint64_t c = 1; | |
d251207d LP |
1887 | ssize_t n; |
1888 | int r; | |
1889 | ||
1890 | /* Set up a user namespace and map root to root, the selected UID/GID to itself, and everything else to | |
1891 | * nobody. In order to be able to write this mapping we need CAP_SETUID in the original user namespace, which | |
1892 | * we however lack after opening the user namespace. To work around this we fork() a temporary child process, | |
1893 | * which waits for the parent to create the new user namespace while staying in the original namespace. The | |
1894 | * child then writes the UID mapping, under full privileges. The parent waits for the child to finish and | |
1895 | * continues execution normally. */ | |
1896 | ||
587ab01b ZJS |
1897 | if (uid != 0 && uid_is_valid(uid)) { |
1898 | r = asprintf(&uid_map, | |
1899 | "0 0 1\n" /* Map root → root */ | |
1900 | UID_FMT " " UID_FMT " 1\n", /* Map $UID → $UID */ | |
1901 | uid, uid); | |
1902 | if (r < 0) | |
1903 | return -ENOMEM; | |
1904 | } else { | |
e0f3720e | 1905 | uid_map = strdup("0 0 1\n"); /* The case where the above is the same */ |
587ab01b ZJS |
1906 | if (!uid_map) |
1907 | return -ENOMEM; | |
1908 | } | |
d251207d | 1909 | |
587ab01b ZJS |
1910 | if (gid != 0 && gid_is_valid(gid)) { |
1911 | r = asprintf(&gid_map, | |
1912 | "0 0 1\n" /* Map root → root */ | |
1913 | GID_FMT " " GID_FMT " 1\n", /* Map $GID → $GID */ | |
1914 | gid, gid); | |
1915 | if (r < 0) | |
1916 | return -ENOMEM; | |
1917 | } else { | |
d251207d | 1918 | gid_map = strdup("0 0 1\n"); /* The case where the above is the same */ |
587ab01b ZJS |
1919 | if (!gid_map) |
1920 | return -ENOMEM; | |
1921 | } | |
d251207d LP |
1922 | |
1923 | /* Create a communication channel so that the parent can tell the child when it finished creating the user | |
1924 | * namespace. */ | |
1925 | unshare_ready_fd = eventfd(0, EFD_CLOEXEC); | |
1926 | if (unshare_ready_fd < 0) | |
1927 | return -errno; | |
1928 | ||
1929 | /* Create a communication channel so that the child can tell the parent a proper error code in case it | |
1930 | * failed. */ | |
1931 | if (pipe2(errno_pipe, O_CLOEXEC) < 0) | |
1932 | return -errno; | |
1933 | ||
4c253ed1 LP |
1934 | r = safe_fork("(sd-userns)", FORK_RESET_SIGNALS|FORK_DEATHSIG, &pid); |
1935 | if (r < 0) | |
1936 | return r; | |
1937 | if (r == 0) { | |
d251207d LP |
1938 | _cleanup_close_ int fd = -1; |
1939 | const char *a; | |
1940 | pid_t ppid; | |
1941 | ||
1942 | /* Child process, running in the original user namespace. Let's update the parent's UID/GID map from | |
1943 | * here, after the parent opened its own user namespace. */ | |
1944 | ||
1945 | ppid = getppid(); | |
1946 | errno_pipe[0] = safe_close(errno_pipe[0]); | |
1947 | ||
1948 | /* Wait until the parent unshared the user namespace */ | |
1949 | if (read(unshare_ready_fd, &c, sizeof(c)) < 0) { | |
1950 | r = -errno; | |
1951 | goto child_fail; | |
1952 | } | |
1953 | ||
1954 | /* Disable the setgroups() system call in the child user namespace, for good. */ | |
1955 | a = procfs_file_alloca(ppid, "setgroups"); | |
1956 | fd = open(a, O_WRONLY|O_CLOEXEC); | |
1957 | if (fd < 0) { | |
1958 | if (errno != ENOENT) { | |
1959 | r = -errno; | |
1960 | goto child_fail; | |
1961 | } | |
1962 | ||
1963 | /* If the file is missing the kernel is too old, let's continue anyway. */ | |
1964 | } else { | |
1965 | if (write(fd, "deny\n", 5) < 0) { | |
1966 | r = -errno; | |
1967 | goto child_fail; | |
1968 | } | |
1969 | ||
1970 | fd = safe_close(fd); | |
1971 | } | |
1972 | ||
1973 | /* First write the GID map */ | |
1974 | a = procfs_file_alloca(ppid, "gid_map"); | |
1975 | fd = open(a, O_WRONLY|O_CLOEXEC); | |
1976 | if (fd < 0) { | |
1977 | r = -errno; | |
1978 | goto child_fail; | |
1979 | } | |
1980 | if (write(fd, gid_map, strlen(gid_map)) < 0) { | |
1981 | r = -errno; | |
1982 | goto child_fail; | |
1983 | } | |
1984 | fd = safe_close(fd); | |
1985 | ||
1986 | /* The write the UID map */ | |
1987 | a = procfs_file_alloca(ppid, "uid_map"); | |
1988 | fd = open(a, O_WRONLY|O_CLOEXEC); | |
1989 | if (fd < 0) { | |
1990 | r = -errno; | |
1991 | goto child_fail; | |
1992 | } | |
1993 | if (write(fd, uid_map, strlen(uid_map)) < 0) { | |
1994 | r = -errno; | |
1995 | goto child_fail; | |
1996 | } | |
1997 | ||
1998 | _exit(EXIT_SUCCESS); | |
1999 | ||
2000 | child_fail: | |
2001 | (void) write(errno_pipe[1], &r, sizeof(r)); | |
2002 | _exit(EXIT_FAILURE); | |
2003 | } | |
2004 | ||
2005 | errno_pipe[1] = safe_close(errno_pipe[1]); | |
2006 | ||
2007 | if (unshare(CLONE_NEWUSER) < 0) | |
2008 | return -errno; | |
2009 | ||
2010 | /* Let the child know that the namespace is ready now */ | |
2011 | if (write(unshare_ready_fd, &c, sizeof(c)) < 0) | |
2012 | return -errno; | |
2013 | ||
2014 | /* Try to read an error code from the child */ | |
2015 | n = read(errno_pipe[0], &r, sizeof(r)); | |
2016 | if (n < 0) | |
2017 | return -errno; | |
2018 | if (n == sizeof(r)) { /* an error code was sent to us */ | |
2019 | if (r < 0) | |
2020 | return r; | |
2021 | return -EIO; | |
2022 | } | |
2023 | if (n != 0) /* on success we should have read 0 bytes */ | |
2024 | return -EIO; | |
2025 | ||
2e87a1fd LP |
2026 | r = wait_for_terminate_and_check("(sd-userns)", pid, 0); |
2027 | pid = 0; | |
d251207d LP |
2028 | if (r < 0) |
2029 | return r; | |
2e87a1fd | 2030 | if (r != EXIT_SUCCESS) /* If something strange happened with the child, let's consider this fatal, too */ |
d251207d LP |
2031 | return -EIO; |
2032 | ||
2033 | return 0; | |
2034 | } | |
2035 | ||
3536f49e | 2036 | static int setup_exec_directory( |
07689d5d LP |
2037 | const ExecContext *context, |
2038 | const ExecParameters *params, | |
2039 | uid_t uid, | |
3536f49e | 2040 | gid_t gid, |
3536f49e YW |
2041 | ExecDirectoryType type, |
2042 | int *exit_status) { | |
07689d5d | 2043 | |
72fd1768 | 2044 | static const int exit_status_table[_EXEC_DIRECTORY_TYPE_MAX] = { |
3536f49e YW |
2045 | [EXEC_DIRECTORY_RUNTIME] = EXIT_RUNTIME_DIRECTORY, |
2046 | [EXEC_DIRECTORY_STATE] = EXIT_STATE_DIRECTORY, | |
2047 | [EXEC_DIRECTORY_CACHE] = EXIT_CACHE_DIRECTORY, | |
2048 | [EXEC_DIRECTORY_LOGS] = EXIT_LOGS_DIRECTORY, | |
2049 | [EXEC_DIRECTORY_CONFIGURATION] = EXIT_CONFIGURATION_DIRECTORY, | |
2050 | }; | |
07689d5d LP |
2051 | char **rt; |
2052 | int r; | |
2053 | ||
2054 | assert(context); | |
2055 | assert(params); | |
72fd1768 | 2056 | assert(type >= 0 && type < _EXEC_DIRECTORY_TYPE_MAX); |
3536f49e | 2057 | assert(exit_status); |
07689d5d | 2058 | |
3536f49e YW |
2059 | if (!params->prefix[type]) |
2060 | return 0; | |
2061 | ||
8679efde | 2062 | if (params->flags & EXEC_CHOWN_DIRECTORIES) { |
3536f49e YW |
2063 | if (!uid_is_valid(uid)) |
2064 | uid = 0; | |
2065 | if (!gid_is_valid(gid)) | |
2066 | gid = 0; | |
2067 | } | |
2068 | ||
2069 | STRV_FOREACH(rt, context->directories[type].paths) { | |
6c47cd7d | 2070 | _cleanup_free_ char *p = NULL, *pp = NULL; |
07689d5d | 2071 | |
3536f49e YW |
2072 | p = strjoin(params->prefix[type], "/", *rt); |
2073 | if (!p) { | |
2074 | r = -ENOMEM; | |
2075 | goto fail; | |
2076 | } | |
07689d5d | 2077 | |
23a7448e YW |
2078 | r = mkdir_parents_label(p, 0755); |
2079 | if (r < 0) | |
3536f49e | 2080 | goto fail; |
23a7448e | 2081 | |
8092a48c YW |
2082 | if (context->dynamic_user && |
2083 | !IN_SET(type, EXEC_DIRECTORY_RUNTIME, EXEC_DIRECTORY_CONFIGURATION)) { | |
6c9c51e5 | 2084 | _cleanup_free_ char *private_root = NULL; |
6c47cd7d LP |
2085 | |
2086 | /* So, here's one extra complication when dealing with DynamicUser=1 units. In that case we | |
2087 | * want to avoid leaving a directory around fully accessible that is owned by a dynamic user | |
2088 | * whose UID is later on reused. To lock this down we use the same trick used by container | |
2089 | * managers to prohibit host users to get access to files of the same UID in containers: we | |
2090 | * place everything inside a directory that has an access mode of 0700 and is owned root:root, | |
2091 | * so that it acts as security boundary for unprivileged host code. We then use fs namespacing | |
2092 | * to make this directory permeable for the service itself. | |
2093 | * | |
2094 | * Specifically: for a service which wants a special directory "foo/" we first create a | |
2095 | * directory "private/" with access mode 0700 owned by root:root. Then we place "foo" inside of | |
2096 | * that directory (i.e. "private/foo/"), and make "foo" a symlink to "private/foo". This way, | |
2097 | * privileged host users can access "foo/" as usual, but unprivileged host users can't look | |
2098 | * into it. Inside of the namespaceof the container "private/" is replaced by a more liberally | |
2099 | * accessible tmpfs, into which the host's "private/foo/" is mounted under the same name, thus | |
2100 | * disabling the access boundary for the service and making sure it only gets access to the | |
2101 | * dirs it needs but no others. Tricky? Yes, absolutely, but it works! | |
2102 | * | |
2103 | * Note that we don't do this for EXEC_DIRECTORY_CONFIGURATION as that's assumed not to be | |
8092a48c YW |
2104 | * owned by the service itself. |
2105 | * Also, note that we don't do this for EXEC_DIRECTORY_RUNTIME as that's often used for sharing | |
2106 | * files or sockets with other services. */ | |
6c47cd7d LP |
2107 | |
2108 | private_root = strjoin(params->prefix[type], "/private"); | |
2109 | if (!private_root) { | |
2110 | r = -ENOMEM; | |
2111 | goto fail; | |
2112 | } | |
2113 | ||
2114 | /* First set up private root if it doesn't exist yet, with access mode 0700 and owned by root:root */ | |
37c1d5e9 | 2115 | r = mkdir_safe_label(private_root, 0700, 0, 0, MKDIR_WARN_MODE); |
6c47cd7d LP |
2116 | if (r < 0) |
2117 | goto fail; | |
2118 | ||
2119 | pp = strjoin(private_root, "/", *rt); | |
2120 | if (!pp) { | |
2121 | r = -ENOMEM; | |
2122 | goto fail; | |
2123 | } | |
2124 | ||
2125 | /* Create all directories between the configured directory and this private root, and mark them 0755 */ | |
2126 | r = mkdir_parents_label(pp, 0755); | |
2127 | if (r < 0) | |
2128 | goto fail; | |
2129 | ||
949befd3 LP |
2130 | if (is_dir(p, false) > 0 && |
2131 | (laccess(pp, F_OK) < 0 && errno == ENOENT)) { | |
2132 | ||
2133 | /* Hmm, the private directory doesn't exist yet, but the normal one exists? If so, move | |
2134 | * it over. Most likely the service has been upgraded from one that didn't use | |
2135 | * DynamicUser=1, to one that does. */ | |
2136 | ||
2137 | if (rename(p, pp) < 0) { | |
2138 | r = -errno; | |
2139 | goto fail; | |
2140 | } | |
2141 | } else { | |
2142 | /* Otherwise, create the actual directory for the service */ | |
2143 | ||
2144 | r = mkdir_label(pp, context->directories[type].mode); | |
2145 | if (r < 0 && r != -EEXIST) | |
2146 | goto fail; | |
2147 | } | |
6c47cd7d | 2148 | |
6c47cd7d | 2149 | /* And link it up from the original place */ |
6c9c51e5 | 2150 | r = symlink_idempotent(pp, p, true); |
6c47cd7d LP |
2151 | if (r < 0) |
2152 | goto fail; | |
2153 | ||
30c81ce2 ZJS |
2154 | /* Lock down the access mode */ |
2155 | if (chmod(pp, context->directories[type].mode) < 0) { | |
2156 | r = -errno; | |
2157 | goto fail; | |
2158 | } | |
6c47cd7d LP |
2159 | } else { |
2160 | r = mkdir_label(p, context->directories[type].mode); | |
fdff1da2 | 2161 | if (r < 0 && r != -EEXIST) |
6c47cd7d | 2162 | goto fail; |
6cff72eb TY |
2163 | if (r == -EEXIST) { |
2164 | struct stat st; | |
2165 | ||
2166 | if (stat(p, &st) < 0) { | |
2167 | r = -errno; | |
2168 | goto fail; | |
2169 | } | |
2170 | if (((st.st_mode ^ context->directories[type].mode) & 07777) != 0) | |
2171 | log_warning("%s \'%s\' already exists but the mode is different. " | |
2172 | "(filesystem: %o %sMode: %o)", | |
2173 | exec_directory_type_to_string(type), *rt, | |
2174 | st.st_mode & 07777, exec_directory_type_to_string(type), context->directories[type].mode & 07777); | |
2175 | if (!context->dynamic_user) | |
2176 | continue; | |
2177 | } | |
a1164ae3 | 2178 | } |
07689d5d | 2179 | |
c71b2eb7 LP |
2180 | /* Don't change the owner of the configuration directory, as in the common case it is not written to by |
2181 | * a service, and shall not be writable. */ | |
2182 | if (type == EXEC_DIRECTORY_CONFIGURATION) | |
2183 | continue; | |
2184 | ||
a1164ae3 | 2185 | /* Then, change the ownership of the whole tree, if necessary */ |
30c81ce2 | 2186 | r = path_chown_recursive(pp ?: p, uid, gid); |
07689d5d | 2187 | if (r < 0) |
3536f49e | 2188 | goto fail; |
07689d5d LP |
2189 | } |
2190 | ||
2191 | return 0; | |
3536f49e YW |
2192 | |
2193 | fail: | |
2194 | *exit_status = exit_status_table[type]; | |
3536f49e | 2195 | return r; |
07689d5d LP |
2196 | } |
2197 | ||
92b423b9 | 2198 | #if ENABLE_SMACK |
cefc33ae LP |
2199 | static int setup_smack( |
2200 | const ExecContext *context, | |
2201 | const ExecCommand *command) { | |
2202 | ||
cefc33ae LP |
2203 | int r; |
2204 | ||
2205 | assert(context); | |
2206 | assert(command); | |
2207 | ||
cefc33ae LP |
2208 | if (context->smack_process_label) { |
2209 | r = mac_smack_apply_pid(0, context->smack_process_label); | |
2210 | if (r < 0) | |
2211 | return r; | |
2212 | } | |
2213 | #ifdef SMACK_DEFAULT_PROCESS_LABEL | |
2214 | else { | |
2215 | _cleanup_free_ char *exec_label = NULL; | |
2216 | ||
2217 | r = mac_smack_read(command->path, SMACK_ATTR_EXEC, &exec_label); | |
4c701096 | 2218 | if (r < 0 && !IN_SET(r, -ENODATA, -EOPNOTSUPP)) |
cefc33ae LP |
2219 | return r; |
2220 | ||
2221 | r = mac_smack_apply_pid(0, exec_label ? : SMACK_DEFAULT_PROCESS_LABEL); | |
2222 | if (r < 0) | |
2223 | return r; | |
2224 | } | |
cefc33ae LP |
2225 | #endif |
2226 | ||
2227 | return 0; | |
2228 | } | |
92b423b9 | 2229 | #endif |
cefc33ae | 2230 | |
6c47cd7d LP |
2231 | static int compile_bind_mounts( |
2232 | const ExecContext *context, | |
2233 | const ExecParameters *params, | |
2234 | BindMount **ret_bind_mounts, | |
da6053d0 | 2235 | size_t *ret_n_bind_mounts, |
6c47cd7d LP |
2236 | char ***ret_empty_directories) { |
2237 | ||
2238 | _cleanup_strv_free_ char **empty_directories = NULL; | |
2239 | BindMount *bind_mounts; | |
da6053d0 | 2240 | size_t n, h = 0, i; |
6c47cd7d LP |
2241 | ExecDirectoryType t; |
2242 | int r; | |
2243 | ||
2244 | assert(context); | |
2245 | assert(params); | |
2246 | assert(ret_bind_mounts); | |
2247 | assert(ret_n_bind_mounts); | |
2248 | assert(ret_empty_directories); | |
2249 | ||
2250 | n = context->n_bind_mounts; | |
2251 | for (t = 0; t < _EXEC_DIRECTORY_TYPE_MAX; t++) { | |
2252 | if (!params->prefix[t]) | |
2253 | continue; | |
2254 | ||
2255 | n += strv_length(context->directories[t].paths); | |
2256 | } | |
2257 | ||
2258 | if (n <= 0) { | |
2259 | *ret_bind_mounts = NULL; | |
2260 | *ret_n_bind_mounts = 0; | |
2261 | *ret_empty_directories = NULL; | |
2262 | return 0; | |
2263 | } | |
2264 | ||
2265 | bind_mounts = new(BindMount, n); | |
2266 | if (!bind_mounts) | |
2267 | return -ENOMEM; | |
2268 | ||
a8cabc61 | 2269 | for (i = 0; i < context->n_bind_mounts; i++) { |
6c47cd7d LP |
2270 | BindMount *item = context->bind_mounts + i; |
2271 | char *s, *d; | |
2272 | ||
2273 | s = strdup(item->source); | |
2274 | if (!s) { | |
2275 | r = -ENOMEM; | |
2276 | goto finish; | |
2277 | } | |
2278 | ||
2279 | d = strdup(item->destination); | |
2280 | if (!d) { | |
2281 | free(s); | |
2282 | r = -ENOMEM; | |
2283 | goto finish; | |
2284 | } | |
2285 | ||
2286 | bind_mounts[h++] = (BindMount) { | |
2287 | .source = s, | |
2288 | .destination = d, | |
2289 | .read_only = item->read_only, | |
2290 | .recursive = item->recursive, | |
2291 | .ignore_enoent = item->ignore_enoent, | |
2292 | }; | |
2293 | } | |
2294 | ||
2295 | for (t = 0; t < _EXEC_DIRECTORY_TYPE_MAX; t++) { | |
2296 | char **suffix; | |
2297 | ||
2298 | if (!params->prefix[t]) | |
2299 | continue; | |
2300 | ||
2301 | if (strv_isempty(context->directories[t].paths)) | |
2302 | continue; | |
2303 | ||
8092a48c | 2304 | if (context->dynamic_user && |
5609f688 YW |
2305 | !IN_SET(t, EXEC_DIRECTORY_RUNTIME, EXEC_DIRECTORY_CONFIGURATION) && |
2306 | !(context->root_directory || context->root_image)) { | |
6c47cd7d LP |
2307 | char *private_root; |
2308 | ||
2309 | /* So this is for a dynamic user, and we need to make sure the process can access its own | |
2310 | * directory. For that we overmount the usually inaccessible "private" subdirectory with a | |
2311 | * tmpfs that makes it accessible and is empty except for the submounts we do this for. */ | |
2312 | ||
2313 | private_root = strjoin(params->prefix[t], "/private"); | |
2314 | if (!private_root) { | |
2315 | r = -ENOMEM; | |
2316 | goto finish; | |
2317 | } | |
2318 | ||
2319 | r = strv_consume(&empty_directories, private_root); | |
a635a7ae | 2320 | if (r < 0) |
6c47cd7d | 2321 | goto finish; |
6c47cd7d LP |
2322 | } |
2323 | ||
2324 | STRV_FOREACH(suffix, context->directories[t].paths) { | |
2325 | char *s, *d; | |
2326 | ||
8092a48c YW |
2327 | if (context->dynamic_user && |
2328 | !IN_SET(t, EXEC_DIRECTORY_RUNTIME, EXEC_DIRECTORY_CONFIGURATION)) | |
6c47cd7d LP |
2329 | s = strjoin(params->prefix[t], "/private/", *suffix); |
2330 | else | |
2331 | s = strjoin(params->prefix[t], "/", *suffix); | |
2332 | if (!s) { | |
2333 | r = -ENOMEM; | |
2334 | goto finish; | |
2335 | } | |
2336 | ||
5609f688 YW |
2337 | if (context->dynamic_user && |
2338 | !IN_SET(t, EXEC_DIRECTORY_RUNTIME, EXEC_DIRECTORY_CONFIGURATION) && | |
2339 | (context->root_directory || context->root_image)) | |
2340 | /* When RootDirectory= or RootImage= are set, then the symbolic link to the private | |
2341 | * directory is not created on the root directory. So, let's bind-mount the directory | |
2342 | * on the 'non-private' place. */ | |
2343 | d = strjoin(params->prefix[t], "/", *suffix); | |
2344 | else | |
2345 | d = strdup(s); | |
6c47cd7d LP |
2346 | if (!d) { |
2347 | free(s); | |
2348 | r = -ENOMEM; | |
2349 | goto finish; | |
2350 | } | |
2351 | ||
2352 | bind_mounts[h++] = (BindMount) { | |
2353 | .source = s, | |
2354 | .destination = d, | |
2355 | .read_only = false, | |
2356 | .recursive = true, | |
2357 | .ignore_enoent = false, | |
2358 | }; | |
2359 | } | |
2360 | } | |
2361 | ||
2362 | assert(h == n); | |
2363 | ||
2364 | *ret_bind_mounts = bind_mounts; | |
2365 | *ret_n_bind_mounts = n; | |
ae2a15bc | 2366 | *ret_empty_directories = TAKE_PTR(empty_directories); |
6c47cd7d LP |
2367 | |
2368 | return (int) n; | |
2369 | ||
2370 | finish: | |
2371 | bind_mount_free_many(bind_mounts, h); | |
2372 | return r; | |
2373 | } | |
2374 | ||
6818c54c | 2375 | static int apply_mount_namespace( |
34cf6c43 YW |
2376 | const Unit *u, |
2377 | const ExecCommand *command, | |
6818c54c LP |
2378 | const ExecContext *context, |
2379 | const ExecParameters *params, | |
34cf6c43 | 2380 | const ExecRuntime *runtime) { |
6818c54c | 2381 | |
7bcef4ef | 2382 | _cleanup_strv_free_ char **empty_directories = NULL; |
93c6bb51 | 2383 | char *tmp = NULL, *var = NULL; |
915e6d16 | 2384 | const char *root_dir = NULL, *root_image = NULL; |
228af36f | 2385 | NamespaceInfo ns_info; |
165a31c0 | 2386 | bool needs_sandboxing; |
6c47cd7d | 2387 | BindMount *bind_mounts = NULL; |
da6053d0 | 2388 | size_t n_bind_mounts = 0; |
6818c54c | 2389 | int r; |
93c6bb51 | 2390 | |
2b3c1b9e DH |
2391 | assert(context); |
2392 | ||
93c6bb51 DH |
2393 | /* The runtime struct only contains the parent of the private /tmp, |
2394 | * which is non-accessible to world users. Inside of it there's a /tmp | |
2395 | * that is sticky, and that's the one we want to use here. */ | |
2396 | ||
2397 | if (context->private_tmp && runtime) { | |
2398 | if (runtime->tmp_dir) | |
2399 | tmp = strjoina(runtime->tmp_dir, "/tmp"); | |
2400 | if (runtime->var_tmp_dir) | |
2401 | var = strjoina(runtime->var_tmp_dir, "/tmp"); | |
2402 | } | |
2403 | ||
915e6d16 LP |
2404 | if (params->flags & EXEC_APPLY_CHROOT) { |
2405 | root_image = context->root_image; | |
2406 | ||
2407 | if (!root_image) | |
2408 | root_dir = context->root_directory; | |
2409 | } | |
93c6bb51 | 2410 | |
6c47cd7d LP |
2411 | r = compile_bind_mounts(context, params, &bind_mounts, &n_bind_mounts, &empty_directories); |
2412 | if (r < 0) | |
2413 | return r; | |
2414 | ||
165a31c0 | 2415 | needs_sandboxing = (params->flags & EXEC_APPLY_SANDBOXING) && !(command->flags & EXEC_COMMAND_FULLY_PRIVILEGED); |
b5a33299 YW |
2416 | if (needs_sandboxing) |
2417 | ns_info = (NamespaceInfo) { | |
2418 | .ignore_protect_paths = false, | |
2419 | .private_dev = context->private_devices, | |
2420 | .protect_control_groups = context->protect_control_groups, | |
2421 | .protect_kernel_tunables = context->protect_kernel_tunables, | |
2422 | .protect_kernel_modules = context->protect_kernel_modules, | |
2423 | .mount_apivfs = context->mount_apivfs, | |
228af36f | 2424 | .private_mounts = context->private_mounts, |
b5a33299 | 2425 | }; |
228af36f LP |
2426 | else if (!context->dynamic_user && root_dir) |
2427 | /* | |
2428 | * If DynamicUser=no and RootDirectory= is set then lets pass a relaxed | |
2429 | * sandbox info, otherwise enforce it, don't ignore protected paths and | |
2430 | * fail if we are enable to apply the sandbox inside the mount namespace. | |
2431 | */ | |
2432 | ns_info = (NamespaceInfo) { | |
2433 | .ignore_protect_paths = true, | |
2434 | }; | |
2435 | else | |
2436 | ns_info = (NamespaceInfo) {}; | |
b5a33299 | 2437 | |
915e6d16 | 2438 | r = setup_namespace(root_dir, root_image, |
7bcef4ef | 2439 | &ns_info, context->read_write_paths, |
165a31c0 LP |
2440 | needs_sandboxing ? context->read_only_paths : NULL, |
2441 | needs_sandboxing ? context->inaccessible_paths : NULL, | |
6c47cd7d LP |
2442 | empty_directories, |
2443 | bind_mounts, | |
2444 | n_bind_mounts, | |
2abd4e38 YW |
2445 | context->temporary_filesystems, |
2446 | context->n_temporary_filesystems, | |
93c6bb51 DH |
2447 | tmp, |
2448 | var, | |
165a31c0 LP |
2449 | needs_sandboxing ? context->protect_home : PROTECT_HOME_NO, |
2450 | needs_sandboxing ? context->protect_system : PROTECT_SYSTEM_NO, | |
915e6d16 LP |
2451 | context->mount_flags, |
2452 | DISSECT_IMAGE_DISCARD_ON_LOOP); | |
93c6bb51 | 2453 | |
6c47cd7d LP |
2454 | bind_mount_free_many(bind_mounts, n_bind_mounts); |
2455 | ||
1beab8b0 LP |
2456 | /* If we couldn't set up the namespace this is probably due to a missing capability. setup_namespace() reports |
2457 | * that with a special, recognizable error ENOANO. In this case, silently proceeed, but only if exclusively | |
2458 | * sandboxing options were used, i.e. nothing such as RootDirectory= or BindMount= that would result in a | |
2459 | * completely different execution environment. */ | |
aca835ed YW |
2460 | if (r == -ENOANO) { |
2461 | if (n_bind_mounts == 0 && | |
2462 | context->n_temporary_filesystems == 0 && | |
2463 | !root_dir && !root_image && | |
2464 | !context->dynamic_user) { | |
2465 | log_unit_debug(u, "Failed to set up namespace, assuming containerized execution and ignoring."); | |
2466 | return 0; | |
2467 | } | |
2468 | ||
2194547e LP |
2469 | log_unit_debug(u, "Failed to set up namespace, and refusing to continue since the selected namespacing options alter mount environment non-trivially.\n" |
2470 | "Bind mounts: %zu, temporary filesystems: %zu, root directory: %s, root image: %s, dynamic user: %s", | |
2471 | n_bind_mounts, context->n_temporary_filesystems, yes_no(root_dir), yes_no(root_image), yes_no(context->dynamic_user)); | |
2472 | ||
aca835ed | 2473 | return -EOPNOTSUPP; |
93c6bb51 DH |
2474 | } |
2475 | ||
2476 | return r; | |
2477 | } | |
2478 | ||
915e6d16 LP |
2479 | static int apply_working_directory( |
2480 | const ExecContext *context, | |
2481 | const ExecParameters *params, | |
2482 | const char *home, | |
376fecf6 LP |
2483 | const bool needs_mount_ns, |
2484 | int *exit_status) { | |
915e6d16 | 2485 | |
6732edab | 2486 | const char *d, *wd; |
2b3c1b9e DH |
2487 | |
2488 | assert(context); | |
376fecf6 | 2489 | assert(exit_status); |
2b3c1b9e | 2490 | |
6732edab LP |
2491 | if (context->working_directory_home) { |
2492 | ||
376fecf6 LP |
2493 | if (!home) { |
2494 | *exit_status = EXIT_CHDIR; | |
6732edab | 2495 | return -ENXIO; |
376fecf6 | 2496 | } |
6732edab | 2497 | |
2b3c1b9e | 2498 | wd = home; |
6732edab LP |
2499 | |
2500 | } else if (context->working_directory) | |
2b3c1b9e DH |
2501 | wd = context->working_directory; |
2502 | else | |
2503 | wd = "/"; | |
e7f1e7c6 DH |
2504 | |
2505 | if (params->flags & EXEC_APPLY_CHROOT) { | |
2506 | if (!needs_mount_ns && context->root_directory) | |
376fecf6 LP |
2507 | if (chroot(context->root_directory) < 0) { |
2508 | *exit_status = EXIT_CHROOT; | |
e7f1e7c6 | 2509 | return -errno; |
376fecf6 | 2510 | } |
e7f1e7c6 | 2511 | |
2b3c1b9e DH |
2512 | d = wd; |
2513 | } else | |
3b0e5bb5 | 2514 | d = prefix_roota(context->root_directory, wd); |
e7f1e7c6 | 2515 | |
376fecf6 LP |
2516 | if (chdir(d) < 0 && !context->working_directory_missing_ok) { |
2517 | *exit_status = EXIT_CHDIR; | |
2b3c1b9e | 2518 | return -errno; |
376fecf6 | 2519 | } |
e7f1e7c6 DH |
2520 | |
2521 | return 0; | |
2522 | } | |
2523 | ||
b1edf445 | 2524 | static int setup_keyring( |
34cf6c43 | 2525 | const Unit *u, |
b1edf445 LP |
2526 | const ExecContext *context, |
2527 | const ExecParameters *p, | |
2528 | uid_t uid, gid_t gid) { | |
2529 | ||
74dd6b51 | 2530 | key_serial_t keyring; |
e64c2d0b DJL |
2531 | int r = 0; |
2532 | uid_t saved_uid; | |
2533 | gid_t saved_gid; | |
74dd6b51 LP |
2534 | |
2535 | assert(u); | |
b1edf445 | 2536 | assert(context); |
74dd6b51 LP |
2537 | assert(p); |
2538 | ||
2539 | /* Let's set up a new per-service "session" kernel keyring for each system service. This has the benefit that | |
2540 | * each service runs with its own keyring shared among all processes of the service, but with no hook-up beyond | |
2541 | * that scope, and in particular no link to the per-UID keyring. If we don't do this the keyring will be | |
2542 | * automatically created on-demand and then linked to the per-UID keyring, by the kernel. The kernel's built-in | |
2543 | * on-demand behaviour is very appropriate for login users, but probably not so much for system services, where | |
2544 | * UIDs are not necessarily specific to a service but reused (at least in the case of UID 0). */ | |
2545 | ||
b1edf445 LP |
2546 | if (context->keyring_mode == EXEC_KEYRING_INHERIT) |
2547 | return 0; | |
2548 | ||
e64c2d0b DJL |
2549 | /* Acquiring a reference to the user keyring is nasty. We briefly change identity in order to get things set up |
2550 | * properly by the kernel. If we don't do that then we can't create it atomically, and that sucks for parallel | |
2551 | * execution. This mimics what pam_keyinit does, too. Setting up session keyring, to be owned by the right user | |
2552 | * & group is just as nasty as acquiring a reference to the user keyring. */ | |
2553 | ||
2554 | saved_uid = getuid(); | |
2555 | saved_gid = getgid(); | |
2556 | ||
2557 | if (gid_is_valid(gid) && gid != saved_gid) { | |
2558 | if (setregid(gid, -1) < 0) | |
2559 | return log_unit_error_errno(u, errno, "Failed to change GID for user keyring: %m"); | |
2560 | } | |
2561 | ||
2562 | if (uid_is_valid(uid) && uid != saved_uid) { | |
2563 | if (setreuid(uid, -1) < 0) { | |
2564 | r = log_unit_error_errno(u, errno, "Failed to change UID for user keyring: %m"); | |
2565 | goto out; | |
2566 | } | |
2567 | } | |
2568 | ||
74dd6b51 LP |
2569 | keyring = keyctl(KEYCTL_JOIN_SESSION_KEYRING, 0, 0, 0, 0); |
2570 | if (keyring == -1) { | |
2571 | if (errno == ENOSYS) | |
8002fb97 | 2572 | log_unit_debug_errno(u, errno, "Kernel keyring not supported, ignoring."); |
74dd6b51 | 2573 | else if (IN_SET(errno, EACCES, EPERM)) |
8002fb97 | 2574 | log_unit_debug_errno(u, errno, "Kernel keyring access prohibited, ignoring."); |
74dd6b51 | 2575 | else if (errno == EDQUOT) |
8002fb97 | 2576 | log_unit_debug_errno(u, errno, "Out of kernel keyrings to allocate, ignoring."); |
74dd6b51 | 2577 | else |
e64c2d0b | 2578 | r = log_unit_error_errno(u, errno, "Setting up kernel keyring failed: %m"); |
74dd6b51 | 2579 | |
e64c2d0b | 2580 | goto out; |
74dd6b51 LP |
2581 | } |
2582 | ||
e64c2d0b DJL |
2583 | /* When requested link the user keyring into the session keyring. */ |
2584 | if (context->keyring_mode == EXEC_KEYRING_SHARED) { | |
2585 | ||
2586 | if (keyctl(KEYCTL_LINK, | |
2587 | KEY_SPEC_USER_KEYRING, | |
2588 | KEY_SPEC_SESSION_KEYRING, 0, 0) < 0) { | |
2589 | r = log_unit_error_errno(u, errno, "Failed to link user keyring into session keyring: %m"); | |
2590 | goto out; | |
2591 | } | |
2592 | } | |
2593 | ||
2594 | /* Restore uid/gid back */ | |
2595 | if (uid_is_valid(uid) && uid != saved_uid) { | |
2596 | if (setreuid(saved_uid, -1) < 0) { | |
2597 | r = log_unit_error_errno(u, errno, "Failed to change UID back for user keyring: %m"); | |
2598 | goto out; | |
2599 | } | |
2600 | } | |
2601 | ||
2602 | if (gid_is_valid(gid) && gid != saved_gid) { | |
2603 | if (setregid(saved_gid, -1) < 0) | |
2604 | return log_unit_error_errno(u, errno, "Failed to change GID back for user keyring: %m"); | |
2605 | } | |
2606 | ||
2607 | /* Populate they keyring with the invocation ID by default, as original saved_uid. */ | |
b3415f5d LP |
2608 | if (!sd_id128_is_null(u->invocation_id)) { |
2609 | key_serial_t key; | |
2610 | ||
2611 | key = add_key("user", "invocation_id", &u->invocation_id, sizeof(u->invocation_id), KEY_SPEC_SESSION_KEYRING); | |
2612 | if (key == -1) | |
8002fb97 | 2613 | log_unit_debug_errno(u, errno, "Failed to add invocation ID to keyring, ignoring: %m"); |
b3415f5d LP |
2614 | else { |
2615 | if (keyctl(KEYCTL_SETPERM, key, | |
2616 | KEY_POS_VIEW|KEY_POS_READ|KEY_POS_SEARCH| | |
2617 | KEY_USR_VIEW|KEY_USR_READ|KEY_USR_SEARCH, 0, 0) < 0) | |
e64c2d0b | 2618 | r = log_unit_error_errno(u, errno, "Failed to restrict invocation ID permission: %m"); |
b3415f5d LP |
2619 | } |
2620 | } | |
2621 | ||
e64c2d0b DJL |
2622 | out: |
2623 | /* Revert back uid & gid for the the last time, and exit */ | |
2624 | /* no extra logging, as only the first already reported error matters */ | |
2625 | if (getuid() != saved_uid) | |
2626 | (void) setreuid(saved_uid, -1); | |
b1edf445 | 2627 | |
e64c2d0b DJL |
2628 | if (getgid() != saved_gid) |
2629 | (void) setregid(saved_gid, -1); | |
b1edf445 | 2630 | |
e64c2d0b | 2631 | return r; |
74dd6b51 LP |
2632 | } |
2633 | ||
3042bbeb | 2634 | static void append_socket_pair(int *array, size_t *n, const int pair[static 2]) { |
29206d46 LP |
2635 | assert(array); |
2636 | assert(n); | |
2637 | ||
2638 | if (!pair) | |
2639 | return; | |
2640 | ||
2641 | if (pair[0] >= 0) | |
2642 | array[(*n)++] = pair[0]; | |
2643 | if (pair[1] >= 0) | |
2644 | array[(*n)++] = pair[1]; | |
2645 | } | |
2646 | ||
a34ceba6 LP |
2647 | static int close_remaining_fds( |
2648 | const ExecParameters *params, | |
34cf6c43 YW |
2649 | const ExecRuntime *runtime, |
2650 | const DynamicCreds *dcreds, | |
00d9ef85 | 2651 | int user_lookup_fd, |
a34ceba6 | 2652 | int socket_fd, |
5686391b | 2653 | int exec_fd, |
da6053d0 | 2654 | int *fds, size_t n_fds) { |
a34ceba6 | 2655 | |
da6053d0 | 2656 | size_t n_dont_close = 0; |
00d9ef85 | 2657 | int dont_close[n_fds + 12]; |
a34ceba6 LP |
2658 | |
2659 | assert(params); | |
2660 | ||
2661 | if (params->stdin_fd >= 0) | |
2662 | dont_close[n_dont_close++] = params->stdin_fd; | |
2663 | if (params->stdout_fd >= 0) | |
2664 | dont_close[n_dont_close++] = params->stdout_fd; | |
2665 | if (params->stderr_fd >= 0) | |
2666 | dont_close[n_dont_close++] = params->stderr_fd; | |
2667 | ||
2668 | if (socket_fd >= 0) | |
2669 | dont_close[n_dont_close++] = socket_fd; | |
5686391b LP |
2670 | if (exec_fd >= 0) |
2671 | dont_close[n_dont_close++] = exec_fd; | |
a34ceba6 LP |
2672 | if (n_fds > 0) { |
2673 | memcpy(dont_close + n_dont_close, fds, sizeof(int) * n_fds); | |
2674 | n_dont_close += n_fds; | |
2675 | } | |
2676 | ||
29206d46 LP |
2677 | if (runtime) |
2678 | append_socket_pair(dont_close, &n_dont_close, runtime->netns_storage_socket); | |
2679 | ||
2680 | if (dcreds) { | |
2681 | if (dcreds->user) | |
2682 | append_socket_pair(dont_close, &n_dont_close, dcreds->user->storage_socket); | |
2683 | if (dcreds->group) | |
2684 | append_socket_pair(dont_close, &n_dont_close, dcreds->group->storage_socket); | |
a34ceba6 LP |
2685 | } |
2686 | ||
00d9ef85 LP |
2687 | if (user_lookup_fd >= 0) |
2688 | dont_close[n_dont_close++] = user_lookup_fd; | |
2689 | ||
a34ceba6 LP |
2690 | return close_all_fds(dont_close, n_dont_close); |
2691 | } | |
2692 | ||
00d9ef85 LP |
2693 | static int send_user_lookup( |
2694 | Unit *unit, | |
2695 | int user_lookup_fd, | |
2696 | uid_t uid, | |
2697 | gid_t gid) { | |
2698 | ||
2699 | assert(unit); | |
2700 | ||
2701 | /* Send the resolved UID/GID to PID 1 after we learnt it. We send a single datagram, containing the UID/GID | |
2702 | * data as well as the unit name. Note that we suppress sending this if no user/group to resolve was | |
2703 | * specified. */ | |
2704 | ||
2705 | if (user_lookup_fd < 0) | |
2706 | return 0; | |
2707 | ||
2708 | if (!uid_is_valid(uid) && !gid_is_valid(gid)) | |
2709 | return 0; | |
2710 | ||
2711 | if (writev(user_lookup_fd, | |
2712 | (struct iovec[]) { | |
e6a7ec4b LP |
2713 | IOVEC_INIT(&uid, sizeof(uid)), |
2714 | IOVEC_INIT(&gid, sizeof(gid)), | |
2715 | IOVEC_INIT_STRING(unit->id) }, 3) < 0) | |
00d9ef85 LP |
2716 | return -errno; |
2717 | ||
2718 | return 0; | |
2719 | } | |
2720 | ||
6732edab LP |
2721 | static int acquire_home(const ExecContext *c, uid_t uid, const char** home, char **buf) { |
2722 | int r; | |
2723 | ||
2724 | assert(c); | |
2725 | assert(home); | |
2726 | assert(buf); | |
2727 | ||
2728 | /* If WorkingDirectory=~ is set, try to acquire a usable home directory. */ | |
2729 | ||
2730 | if (*home) | |
2731 | return 0; | |
2732 | ||
2733 | if (!c->working_directory_home) | |
2734 | return 0; | |
2735 | ||
2736 | if (uid == 0) { | |
2737 | /* Hardcode /root as home directory for UID 0 */ | |
2738 | *home = "/root"; | |
2739 | return 1; | |
2740 | } | |
2741 | ||
2742 | r = get_home_dir(buf); | |
2743 | if (r < 0) | |
2744 | return r; | |
2745 | ||
2746 | *home = *buf; | |
2747 | return 1; | |
2748 | } | |
2749 | ||
da50b85a LP |
2750 | static int compile_suggested_paths(const ExecContext *c, const ExecParameters *p, char ***ret) { |
2751 | _cleanup_strv_free_ char ** list = NULL; | |
2752 | ExecDirectoryType t; | |
2753 | int r; | |
2754 | ||
2755 | assert(c); | |
2756 | assert(p); | |
2757 | assert(ret); | |
2758 | ||
2759 | assert(c->dynamic_user); | |
2760 | ||
2761 | /* Compile a list of paths that it might make sense to read the owning UID from to use as initial candidate for | |
2762 | * dynamic UID allocation, in order to save us from doing costly recursive chown()s of the special | |
2763 | * directories. */ | |
2764 | ||
2765 | for (t = 0; t < _EXEC_DIRECTORY_TYPE_MAX; t++) { | |
2766 | char **i; | |
2767 | ||
2768 | if (t == EXEC_DIRECTORY_CONFIGURATION) | |
2769 | continue; | |
2770 | ||
2771 | if (!p->prefix[t]) | |
2772 | continue; | |
2773 | ||
2774 | STRV_FOREACH(i, c->directories[t].paths) { | |
2775 | char *e; | |
2776 | ||
8092a48c YW |
2777 | if (t == EXEC_DIRECTORY_RUNTIME) |
2778 | e = strjoin(p->prefix[t], "/", *i); | |
2779 | else | |
2780 | e = strjoin(p->prefix[t], "/private/", *i); | |
da50b85a LP |
2781 | if (!e) |
2782 | return -ENOMEM; | |
2783 | ||
2784 | r = strv_consume(&list, e); | |
2785 | if (r < 0) | |
2786 | return r; | |
2787 | } | |
2788 | } | |
2789 | ||
ae2a15bc | 2790 | *ret = TAKE_PTR(list); |
da50b85a LP |
2791 | |
2792 | return 0; | |
2793 | } | |
2794 | ||
34cf6c43 YW |
2795 | static char *exec_command_line(char **argv); |
2796 | ||
78f93209 LP |
2797 | static int exec_parameters_get_cgroup_path(const ExecParameters *params, char **ret) { |
2798 | bool using_subcgroup; | |
2799 | char *p; | |
2800 | ||
2801 | assert(params); | |
2802 | assert(ret); | |
2803 | ||
2804 | if (!params->cgroup_path) | |
2805 | return -EINVAL; | |
2806 | ||
2807 | /* If we are called for a unit where cgroup delegation is on, and the payload created its own populated | |
2808 | * subcgroup (which we expect it to do, after all it asked for delegation), then we cannot place the control | |
2809 | * processes started after the main unit's process in the unit's main cgroup because it is now an inner one, | |
2810 | * and inner cgroups may not contain processes. Hence, if delegation is on, and this is a control process, | |
2811 | * let's use ".control" as subcgroup instead. Note that we do so only for ExecStartPost=, ExecReload=, | |
2812 | * ExecStop=, ExecStopPost=, i.e. for the commands where the main process is already forked. For ExecStartPre= | |
2813 | * this is not necessary, the cgroup is still empty. We distinguish these cases with the EXEC_CONTROL_CGROUP | |
2814 | * flag, which is only passed for the former statements, not for the latter. */ | |
2815 | ||
2816 | using_subcgroup = FLAGS_SET(params->flags, EXEC_CONTROL_CGROUP|EXEC_CGROUP_DELEGATE|EXEC_IS_CONTROL); | |
2817 | if (using_subcgroup) | |
2818 | p = strjoin(params->cgroup_path, "/.control"); | |
2819 | else | |
2820 | p = strdup(params->cgroup_path); | |
2821 | if (!p) | |
2822 | return -ENOMEM; | |
2823 | ||
2824 | *ret = p; | |
2825 | return using_subcgroup; | |
2826 | } | |
2827 | ||
ff0af2a1 | 2828 | static int exec_child( |
f2341e0a | 2829 | Unit *unit, |
34cf6c43 | 2830 | const ExecCommand *command, |
ff0af2a1 LP |
2831 | const ExecContext *context, |
2832 | const ExecParameters *params, | |
2833 | ExecRuntime *runtime, | |
29206d46 | 2834 | DynamicCreds *dcreds, |
ff0af2a1 | 2835 | int socket_fd, |
52c239d7 | 2836 | int named_iofds[3], |
4c47affc | 2837 | int *fds, |
da6053d0 | 2838 | size_t n_socket_fds, |
25b583d7 | 2839 | size_t n_storage_fds, |
ff0af2a1 | 2840 | char **files_env, |
00d9ef85 | 2841 | int user_lookup_fd, |
12145637 | 2842 | int *exit_status) { |
d35fbf6b | 2843 | |
2065ca69 | 2844 | _cleanup_strv_free_ char **our_env = NULL, **pass_env = NULL, **accum_env = NULL, **final_argv = NULL; |
5686391b | 2845 | int *fds_with_exec_fd, n_fds_with_exec_fd, r, ngids = 0, exec_fd = -1; |
4d885bd3 DH |
2846 | _cleanup_free_ gid_t *supplementary_gids = NULL; |
2847 | const char *username = NULL, *groupname = NULL; | |
5686391b | 2848 | _cleanup_free_ char *home_buffer = NULL; |
2b3c1b9e | 2849 | const char *home = NULL, *shell = NULL; |
7bce046b LP |
2850 | dev_t journal_stream_dev = 0; |
2851 | ino_t journal_stream_ino = 0; | |
165a31c0 LP |
2852 | bool needs_sandboxing, /* Do we need to set up full sandboxing? (i.e. all namespacing, all MAC stuff, caps, yadda yadda */ |
2853 | needs_setuid, /* Do we need to do the actual setresuid()/setresgid() calls? */ | |
2854 | needs_mount_namespace, /* Do we need to set up a mount namespace for this kernel? */ | |
2855 | needs_ambient_hack; /* Do we need to apply the ambient capabilities hack? */ | |
349cc4a5 | 2856 | #if HAVE_SELINUX |
7f59dd35 | 2857 | _cleanup_free_ char *mac_selinux_context_net = NULL; |
43b1f709 | 2858 | bool use_selinux = false; |
ecfbc84f | 2859 | #endif |
f9fa32f0 | 2860 | #if ENABLE_SMACK |
43b1f709 | 2861 | bool use_smack = false; |
ecfbc84f | 2862 | #endif |
349cc4a5 | 2863 | #if HAVE_APPARMOR |
43b1f709 | 2864 | bool use_apparmor = false; |
ecfbc84f | 2865 | #endif |
fed1e721 LP |
2866 | uid_t uid = UID_INVALID; |
2867 | gid_t gid = GID_INVALID; | |
da6053d0 | 2868 | size_t n_fds; |
3536f49e | 2869 | ExecDirectoryType dt; |
165a31c0 | 2870 | int secure_bits; |
034c6ed7 | 2871 | |
f2341e0a | 2872 | assert(unit); |
5cb5a6ff LP |
2873 | assert(command); |
2874 | assert(context); | |
d35fbf6b | 2875 | assert(params); |
ff0af2a1 | 2876 | assert(exit_status); |
d35fbf6b DM |
2877 | |
2878 | rename_process_from_path(command->path); | |
2879 | ||
2880 | /* We reset exactly these signals, since they are the | |
2881 | * only ones we set to SIG_IGN in the main daemon. All | |
2882 | * others we leave untouched because we set them to | |
2883 | * SIG_DFL or a valid handler initially, both of which | |
2884 | * will be demoted to SIG_DFL. */ | |
ce30c8dc LP |
2885 | (void) default_signals(SIGNALS_CRASH_HANDLER, |
2886 | SIGNALS_IGNORE, -1); | |
d35fbf6b DM |
2887 | |
2888 | if (context->ignore_sigpipe) | |
ce30c8dc | 2889 | (void) ignore_signals(SIGPIPE, -1); |
d35fbf6b | 2890 | |
ff0af2a1 LP |
2891 | r = reset_signal_mask(); |
2892 | if (r < 0) { | |
2893 | *exit_status = EXIT_SIGNAL_MASK; | |
12145637 | 2894 | return log_unit_error_errno(unit, r, "Failed to set process signal mask: %m"); |
d35fbf6b | 2895 | } |
034c6ed7 | 2896 | |
d35fbf6b DM |
2897 | if (params->idle_pipe) |
2898 | do_idle_pipe_dance(params->idle_pipe); | |
4f2d528d | 2899 | |
2c027c62 LP |
2900 | /* Close fds we don't need very early to make sure we don't block init reexecution because it cannot bind its |
2901 | * sockets. Among the fds we close are the logging fds, and we want to keep them closed, so that we don't have | |
2902 | * any fds open we don't really want open during the transition. In order to make logging work, we switch the | |
2903 | * log subsystem into open_when_needed mode, so that it reopens the logs on every single log call. */ | |
ff0af2a1 | 2904 | |
d35fbf6b | 2905 | log_forget_fds(); |
2c027c62 | 2906 | log_set_open_when_needed(true); |
4f2d528d | 2907 | |
40a80078 LP |
2908 | /* In case anything used libc syslog(), close this here, too */ |
2909 | closelog(); | |
2910 | ||
5686391b LP |
2911 | n_fds = n_socket_fds + n_storage_fds; |
2912 | r = close_remaining_fds(params, runtime, dcreds, user_lookup_fd, socket_fd, params->exec_fd, fds, n_fds); | |
ff0af2a1 LP |
2913 | if (r < 0) { |
2914 | *exit_status = EXIT_FDS; | |
12145637 | 2915 | return log_unit_error_errno(unit, r, "Failed to close unwanted file descriptors: %m"); |
8c7be95e LP |
2916 | } |
2917 | ||
d35fbf6b DM |
2918 | if (!context->same_pgrp) |
2919 | if (setsid() < 0) { | |
ff0af2a1 | 2920 | *exit_status = EXIT_SETSID; |
12145637 | 2921 | return log_unit_error_errno(unit, errno, "Failed to create new process session: %m"); |
d35fbf6b | 2922 | } |
9e2f7c11 | 2923 | |
1e22b5cd | 2924 | exec_context_tty_reset(context, params); |
d35fbf6b | 2925 | |
c891efaf | 2926 | if (unit_shall_confirm_spawn(unit)) { |
7d5ceb64 | 2927 | const char *vc = params->confirm_spawn; |
3b20f877 FB |
2928 | _cleanup_free_ char *cmdline = NULL; |
2929 | ||
ee39ca20 | 2930 | cmdline = exec_command_line(command->argv); |
3b20f877 | 2931 | if (!cmdline) { |
0460aa5c | 2932 | *exit_status = EXIT_MEMORY; |
12145637 | 2933 | return log_oom(); |
3b20f877 | 2934 | } |
d35fbf6b | 2935 | |
eedf223a | 2936 | r = ask_for_confirmation(vc, unit, cmdline); |
3b20f877 FB |
2937 | if (r != CONFIRM_EXECUTE) { |
2938 | if (r == CONFIRM_PRETEND_SUCCESS) { | |
2939 | *exit_status = EXIT_SUCCESS; | |
2940 | return 0; | |
2941 | } | |
ff0af2a1 | 2942 | *exit_status = EXIT_CONFIRM; |
12145637 | 2943 | log_unit_error(unit, "Execution cancelled by the user"); |
d35fbf6b | 2944 | return -ECANCELED; |
d35fbf6b DM |
2945 | } |
2946 | } | |
1a63a750 | 2947 | |
d521916d LP |
2948 | /* We are about to invoke NSS and PAM modules. Let's tell them what we are doing here, maybe they care. This is |
2949 | * used by nss-resolve to disable itself when we are about to start systemd-resolved, to avoid deadlocks. Note | |
2950 | * that these env vars do not survive the execve(), which means they really only apply to the PAM and NSS | |
2951 | * invocations themselves. Also note that while we'll only invoke NSS modules involved in user management they | |
2952 | * might internally call into other NSS modules that are involved in hostname resolution, we never know. */ | |
2953 | if (setenv("SYSTEMD_ACTIVATION_UNIT", unit->id, true) != 0 || | |
2954 | setenv("SYSTEMD_ACTIVATION_SCOPE", MANAGER_IS_SYSTEM(unit->manager) ? "system" : "user", true) != 0) { | |
2955 | *exit_status = EXIT_MEMORY; | |
2956 | return log_unit_error_errno(unit, errno, "Failed to update environment: %m"); | |
2957 | } | |
2958 | ||
29206d46 | 2959 | if (context->dynamic_user && dcreds) { |
da50b85a | 2960 | _cleanup_strv_free_ char **suggested_paths = NULL; |
29206d46 | 2961 | |
d521916d LP |
2962 | /* On top of that, make sure we bypass our own NSS module nss-systemd comprehensively for any NSS |
2963 | * checks, if DynamicUser=1 is used, as we shouldn't create a feedback loop with ourselves here.*/ | |
409093fe LP |
2964 | if (putenv((char*) "SYSTEMD_NSS_DYNAMIC_BYPASS=1") != 0) { |
2965 | *exit_status = EXIT_USER; | |
12145637 | 2966 | return log_unit_error_errno(unit, errno, "Failed to update environment: %m"); |
409093fe LP |
2967 | } |
2968 | ||
da50b85a LP |
2969 | r = compile_suggested_paths(context, params, &suggested_paths); |
2970 | if (r < 0) { | |
2971 | *exit_status = EXIT_MEMORY; | |
2972 | return log_oom(); | |
2973 | } | |
2974 | ||
2975 | r = dynamic_creds_realize(dcreds, suggested_paths, &uid, &gid); | |
ff0af2a1 LP |
2976 | if (r < 0) { |
2977 | *exit_status = EXIT_USER; | |
e2b0cc34 YW |
2978 | if (r == -EILSEQ) { |
2979 | log_unit_error(unit, "Failed to update dynamic user credentials: User or group with specified name already exists."); | |
2980 | return -EOPNOTSUPP; | |
2981 | } | |
12145637 | 2982 | return log_unit_error_errno(unit, r, "Failed to update dynamic user credentials: %m"); |
524daa8c | 2983 | } |
524daa8c | 2984 | |
70dd455c | 2985 | if (!uid_is_valid(uid)) { |
29206d46 | 2986 | *exit_status = EXIT_USER; |
12145637 | 2987 | log_unit_error(unit, "UID validation failed for \""UID_FMT"\"", uid); |
70dd455c ZJS |
2988 | return -ESRCH; |
2989 | } | |
2990 | ||
2991 | if (!gid_is_valid(gid)) { | |
2992 | *exit_status = EXIT_USER; | |
12145637 | 2993 | log_unit_error(unit, "GID validation failed for \""GID_FMT"\"", gid); |
29206d46 LP |
2994 | return -ESRCH; |
2995 | } | |
5bc7452b | 2996 | |
29206d46 LP |
2997 | if (dcreds->user) |
2998 | username = dcreds->user->name; | |
2999 | ||
3000 | } else { | |
4d885bd3 DH |
3001 | r = get_fixed_user(context, &username, &uid, &gid, &home, &shell); |
3002 | if (r < 0) { | |
3003 | *exit_status = EXIT_USER; | |
12145637 | 3004 | return log_unit_error_errno(unit, r, "Failed to determine user credentials: %m"); |
5bc7452b | 3005 | } |
5bc7452b | 3006 | |
4d885bd3 DH |
3007 | r = get_fixed_group(context, &groupname, &gid); |
3008 | if (r < 0) { | |
3009 | *exit_status = EXIT_GROUP; | |
12145637 | 3010 | return log_unit_error_errno(unit, r, "Failed to determine group credentials: %m"); |
4d885bd3 | 3011 | } |
cdc5d5c5 | 3012 | } |
29206d46 | 3013 | |
cdc5d5c5 DH |
3014 | /* Initialize user supplementary groups and get SupplementaryGroups= ones */ |
3015 | r = get_supplementary_groups(context, username, groupname, gid, | |
3016 | &supplementary_gids, &ngids); | |
3017 | if (r < 0) { | |
3018 | *exit_status = EXIT_GROUP; | |
12145637 | 3019 | return log_unit_error_errno(unit, r, "Failed to determine supplementary groups: %m"); |
29206d46 | 3020 | } |
5bc7452b | 3021 | |
00d9ef85 LP |
3022 | r = send_user_lookup(unit, user_lookup_fd, uid, gid); |
3023 | if (r < 0) { | |
3024 | *exit_status = EXIT_USER; | |
12145637 | 3025 | return log_unit_error_errno(unit, r, "Failed to send user credentials to PID1: %m"); |
00d9ef85 LP |
3026 | } |
3027 | ||
3028 | user_lookup_fd = safe_close(user_lookup_fd); | |
3029 | ||
6732edab LP |
3030 | r = acquire_home(context, uid, &home, &home_buffer); |
3031 | if (r < 0) { | |
3032 | *exit_status = EXIT_CHDIR; | |
12145637 | 3033 | return log_unit_error_errno(unit, r, "Failed to determine $HOME for user: %m"); |
6732edab LP |
3034 | } |
3035 | ||
d35fbf6b DM |
3036 | /* If a socket is connected to STDIN/STDOUT/STDERR, we |
3037 | * must sure to drop O_NONBLOCK */ | |
3038 | if (socket_fd >= 0) | |
a34ceba6 | 3039 | (void) fd_nonblock(socket_fd, false); |
acbb0225 | 3040 | |
4c70a4a7 MS |
3041 | /* Journald will try to look-up our cgroup in order to populate _SYSTEMD_CGROUP and _SYSTEMD_UNIT fields. |
3042 | * Hence we need to migrate to the target cgroup from init.scope before connecting to journald */ | |
3043 | if (params->cgroup_path) { | |
3044 | _cleanup_free_ char *p = NULL; | |
3045 | ||
3046 | r = exec_parameters_get_cgroup_path(params, &p); | |
3047 | if (r < 0) { | |
3048 | *exit_status = EXIT_CGROUP; | |
3049 | return log_unit_error_errno(unit, r, "Failed to acquire cgroup path: %m"); | |
3050 | } | |
3051 | ||
3052 | r = cg_attach_everywhere(params->cgroup_supported, p, 0, NULL, NULL); | |
3053 | if (r < 0) { | |
3054 | *exit_status = EXIT_CGROUP; | |
3055 | return log_unit_error_errno(unit, r, "Failed to attach to cgroup %s: %m", p); | |
3056 | } | |
3057 | } | |
3058 | ||
52c239d7 | 3059 | r = setup_input(context, params, socket_fd, named_iofds); |
ff0af2a1 LP |
3060 | if (r < 0) { |
3061 | *exit_status = EXIT_STDIN; | |
12145637 | 3062 | return log_unit_error_errno(unit, r, "Failed to set up standard input: %m"); |
d35fbf6b | 3063 | } |
034c6ed7 | 3064 | |
52c239d7 | 3065 | r = setup_output(unit, context, params, STDOUT_FILENO, socket_fd, named_iofds, basename(command->path), uid, gid, &journal_stream_dev, &journal_stream_ino); |
ff0af2a1 LP |
3066 | if (r < 0) { |
3067 | *exit_status = EXIT_STDOUT; | |
12145637 | 3068 | return log_unit_error_errno(unit, r, "Failed to set up standard output: %m"); |
d35fbf6b DM |
3069 | } |
3070 | ||
52c239d7 | 3071 | r = setup_output(unit, context, params, STDERR_FILENO, socket_fd, named_iofds, basename(command->path), uid, gid, &journal_stream_dev, &journal_stream_ino); |
ff0af2a1 LP |
3072 | if (r < 0) { |
3073 | *exit_status = EXIT_STDERR; | |
12145637 | 3074 | return log_unit_error_errno(unit, r, "Failed to set up standard error output: %m"); |
d35fbf6b DM |
3075 | } |
3076 | ||
d35fbf6b | 3077 | if (context->oom_score_adjust_set) { |
9f8168eb LP |
3078 | /* When we can't make this change due to EPERM, then let's silently skip over it. User namespaces |
3079 | * prohibit write access to this file, and we shouldn't trip up over that. */ | |
3080 | r = set_oom_score_adjust(context->oom_score_adjust); | |
12145637 | 3081 | if (IN_SET(r, -EPERM, -EACCES)) |
f2341e0a | 3082 | log_unit_debug_errno(unit, r, "Failed to adjust OOM setting, assuming containerized execution, ignoring: %m"); |
12145637 | 3083 | else if (r < 0) { |
ff0af2a1 | 3084 | *exit_status = EXIT_OOM_ADJUST; |
12145637 | 3085 | return log_unit_error_errno(unit, r, "Failed to adjust OOM setting: %m"); |
613b411c | 3086 | } |
d35fbf6b DM |
3087 | } |
3088 | ||
3089 | if (context->nice_set) | |
3090 | if (setpriority(PRIO_PROCESS, 0, context->nice) < 0) { | |
ff0af2a1 | 3091 | *exit_status = EXIT_NICE; |
12145637 | 3092 | return log_unit_error_errno(unit, errno, "Failed to set up process scheduling priority (nice level): %m"); |
613b411c LP |
3093 | } |
3094 | ||
d35fbf6b DM |
3095 | if (context->cpu_sched_set) { |
3096 | struct sched_param param = { | |
3097 | .sched_priority = context->cpu_sched_priority, | |
3098 | }; | |
3099 | ||
ff0af2a1 LP |
3100 | r = sched_setscheduler(0, |
3101 | context->cpu_sched_policy | | |
3102 | (context->cpu_sched_reset_on_fork ? | |
3103 | SCHED_RESET_ON_FORK : 0), | |
3104 | ¶m); | |
3105 | if (r < 0) { | |
3106 | *exit_status = EXIT_SETSCHEDULER; | |
12145637 | 3107 | return log_unit_error_errno(unit, errno, "Failed to set up CPU scheduling: %m"); |
fc9b2a84 | 3108 | } |
d35fbf6b | 3109 | } |
fc9b2a84 | 3110 | |
d35fbf6b DM |
3111 | if (context->cpuset) |
3112 | if (sched_setaffinity(0, CPU_ALLOC_SIZE(context->cpuset_ncpus), context->cpuset) < 0) { | |
ff0af2a1 | 3113 | *exit_status = EXIT_CPUAFFINITY; |
12145637 | 3114 | return log_unit_error_errno(unit, errno, "Failed to set up CPU affinity: %m"); |
034c6ed7 LP |
3115 | } |
3116 | ||
d35fbf6b DM |
3117 | if (context->ioprio_set) |
3118 | if (ioprio_set(IOPRIO_WHO_PROCESS, 0, context->ioprio) < 0) { | |
ff0af2a1 | 3119 | *exit_status = EXIT_IOPRIO; |
12145637 | 3120 | return log_unit_error_errno(unit, errno, "Failed to set up IO scheduling priority: %m"); |
d35fbf6b | 3121 | } |
da726a4d | 3122 | |
d35fbf6b DM |
3123 | if (context->timer_slack_nsec != NSEC_INFINITY) |
3124 | if (prctl(PR_SET_TIMERSLACK, context->timer_slack_nsec) < 0) { | |
ff0af2a1 | 3125 | *exit_status = EXIT_TIMERSLACK; |
12145637 | 3126 | return log_unit_error_errno(unit, errno, "Failed to set up timer slack: %m"); |
4c2630eb | 3127 | } |
9eba9da4 | 3128 | |
21022b9d LP |
3129 | if (context->personality != PERSONALITY_INVALID) { |
3130 | r = safe_personality(context->personality); | |
3131 | if (r < 0) { | |
ff0af2a1 | 3132 | *exit_status = EXIT_PERSONALITY; |
12145637 | 3133 | return log_unit_error_errno(unit, r, "Failed to set up execution domain (personality): %m"); |
4c2630eb | 3134 | } |
21022b9d | 3135 | } |
94f04347 | 3136 | |
d35fbf6b | 3137 | if (context->utmp_id) |
df0ff127 | 3138 | utmp_put_init_process(context->utmp_id, getpid_cached(), getsid(0), |
6a93917d | 3139 | context->tty_path, |
023a4f67 LP |
3140 | context->utmp_mode == EXEC_UTMP_INIT ? INIT_PROCESS : |
3141 | context->utmp_mode == EXEC_UTMP_LOGIN ? LOGIN_PROCESS : | |
3142 | USER_PROCESS, | |
6a93917d | 3143 | username); |
d35fbf6b | 3144 | |
e0d2adfd | 3145 | if (context->user) { |
ff0af2a1 LP |
3146 | r = chown_terminal(STDIN_FILENO, uid); |
3147 | if (r < 0) { | |
3148 | *exit_status = EXIT_STDIN; | |
12145637 | 3149 | return log_unit_error_errno(unit, r, "Failed to change ownership of terminal: %m"); |
071830ff | 3150 | } |
d35fbf6b | 3151 | } |
8e274523 | 3152 | |
4e1dfa45 | 3153 | /* If delegation is enabled we'll pass ownership of the cgroup to the user of the new process. On cgroup v1 |
62b9bb26 | 3154 | * this is only about systemd's own hierarchy, i.e. not the controller hierarchies, simply because that's not |
4e1dfa45 | 3155 | * safe. On cgroup v2 there's only one hierarchy anyway, and delegation is safe there, hence in that case only |
62b9bb26 | 3156 | * touch a single hierarchy too. */ |
584b8688 | 3157 | if (params->cgroup_path && context->user && (params->flags & EXEC_CGROUP_DELEGATE)) { |
62b9bb26 | 3158 | r = cg_set_access(SYSTEMD_CGROUP_CONTROLLER, params->cgroup_path, uid, gid); |
ff0af2a1 LP |
3159 | if (r < 0) { |
3160 | *exit_status = EXIT_CGROUP; | |
12145637 | 3161 | return log_unit_error_errno(unit, r, "Failed to adjust control group access: %m"); |
034c6ed7 | 3162 | } |
d35fbf6b | 3163 | } |
034c6ed7 | 3164 | |
72fd1768 | 3165 | for (dt = 0; dt < _EXEC_DIRECTORY_TYPE_MAX; dt++) { |
8679efde | 3166 | r = setup_exec_directory(context, params, uid, gid, dt, exit_status); |
12145637 LP |
3167 | if (r < 0) |
3168 | return log_unit_error_errno(unit, r, "Failed to set up special execution directory in %s: %m", params->prefix[dt]); | |
d35fbf6b | 3169 | } |
94f04347 | 3170 | |
7bce046b | 3171 | r = build_environment( |
fd63e712 | 3172 | unit, |
7bce046b LP |
3173 | context, |
3174 | params, | |
3175 | n_fds, | |
3176 | home, | |
3177 | username, | |
3178 | shell, | |
3179 | journal_stream_dev, | |
3180 | journal_stream_ino, | |
3181 | &our_env); | |
2065ca69 JW |
3182 | if (r < 0) { |
3183 | *exit_status = EXIT_MEMORY; | |
12145637 | 3184 | return log_oom(); |
2065ca69 JW |
3185 | } |
3186 | ||
3187 | r = build_pass_environment(context, &pass_env); | |
3188 | if (r < 0) { | |
3189 | *exit_status = EXIT_MEMORY; | |
12145637 | 3190 | return log_oom(); |
2065ca69 JW |
3191 | } |
3192 | ||
3193 | accum_env = strv_env_merge(5, | |
3194 | params->environment, | |
3195 | our_env, | |
3196 | pass_env, | |
3197 | context->environment, | |
3198 | files_env, | |
3199 | NULL); | |
3200 | if (!accum_env) { | |
3201 | *exit_status = EXIT_MEMORY; | |
12145637 | 3202 | return log_oom(); |
2065ca69 | 3203 | } |
1280503b | 3204 | accum_env = strv_env_clean(accum_env); |
2065ca69 | 3205 | |
096424d1 | 3206 | (void) umask(context->umask); |
b213e1c1 | 3207 | |
b1edf445 | 3208 | r = setup_keyring(unit, context, params, uid, gid); |
74dd6b51 LP |
3209 | if (r < 0) { |
3210 | *exit_status = EXIT_KEYRING; | |
12145637 | 3211 | return log_unit_error_errno(unit, r, "Failed to set up kernel keyring: %m"); |
74dd6b51 LP |
3212 | } |
3213 | ||
165a31c0 | 3214 | /* We need sandboxing if the caller asked us to apply it and the command isn't explicitly excepted from it */ |
1703fa41 | 3215 | needs_sandboxing = (params->flags & EXEC_APPLY_SANDBOXING) && !(command->flags & EXEC_COMMAND_FULLY_PRIVILEGED); |
7f18ef0a | 3216 | |
165a31c0 LP |
3217 | /* We need the ambient capability hack, if the caller asked us to apply it and the command is marked for it, and the kernel doesn't actually support ambient caps */ |
3218 | needs_ambient_hack = (params->flags & EXEC_APPLY_SANDBOXING) && (command->flags & EXEC_COMMAND_AMBIENT_MAGIC) && !ambient_capabilities_supported(); | |
7f18ef0a | 3219 | |
165a31c0 LP |
3220 | /* We need setresuid() if the caller asked us to apply sandboxing and the command isn't explicitly excepted from either whole sandboxing or just setresuid() itself, and the ambient hack is not desired */ |
3221 | if (needs_ambient_hack) | |
3222 | needs_setuid = false; | |
3223 | else | |
3224 | needs_setuid = (params->flags & EXEC_APPLY_SANDBOXING) && !(command->flags & (EXEC_COMMAND_FULLY_PRIVILEGED|EXEC_COMMAND_NO_SETUID)); | |
3225 | ||
3226 | if (needs_sandboxing) { | |
7f18ef0a FK |
3227 | /* MAC enablement checks need to be done before a new mount ns is created, as they rely on /sys being |
3228 | * present. The actual MAC context application will happen later, as late as possible, to avoid | |
3229 | * impacting our own code paths. */ | |
3230 | ||
349cc4a5 | 3231 | #if HAVE_SELINUX |
43b1f709 | 3232 | use_selinux = mac_selinux_use(); |
7f18ef0a | 3233 | #endif |
f9fa32f0 | 3234 | #if ENABLE_SMACK |
43b1f709 | 3235 | use_smack = mac_smack_use(); |
7f18ef0a | 3236 | #endif |
349cc4a5 | 3237 | #if HAVE_APPARMOR |
43b1f709 | 3238 | use_apparmor = mac_apparmor_use(); |
7f18ef0a | 3239 | #endif |
165a31c0 | 3240 | } |
7f18ef0a | 3241 | |
ce932d2d LP |
3242 | if (needs_sandboxing) { |
3243 | int which_failed; | |
3244 | ||
3245 | /* Let's set the resource limits before we call into PAM, so that pam_limits wins over what | |
3246 | * is set here. (See below.) */ | |
3247 | ||
3248 | r = setrlimit_closest_all((const struct rlimit* const *) context->rlimit, &which_failed); | |
3249 | if (r < 0) { | |
3250 | *exit_status = EXIT_LIMITS; | |
3251 | return log_unit_error_errno(unit, r, "Failed to adjust resource limit RLIMIT_%s: %m", rlimit_to_string(which_failed)); | |
3252 | } | |
3253 | } | |
3254 | ||
165a31c0 | 3255 | if (needs_setuid) { |
ce932d2d LP |
3256 | |
3257 | /* Let's call into PAM after we set up our own idea of resource limits to that pam_limits | |
3258 | * wins here. (See above.) */ | |
3259 | ||
165a31c0 LP |
3260 | if (context->pam_name && username) { |
3261 | r = setup_pam(context->pam_name, username, uid, gid, context->tty_path, &accum_env, fds, n_fds); | |
3262 | if (r < 0) { | |
3263 | *exit_status = EXIT_PAM; | |
12145637 | 3264 | return log_unit_error_errno(unit, r, "Failed to set up PAM session: %m"); |
165a31c0 LP |
3265 | } |
3266 | } | |
b213e1c1 | 3267 | } |
ac45f971 | 3268 | |
d35fbf6b | 3269 | if (context->private_network && runtime && runtime->netns_storage_socket[0] >= 0) { |
6e2d7c4f MS |
3270 | if (ns_type_supported(NAMESPACE_NET)) { |
3271 | r = setup_netns(runtime->netns_storage_socket); | |
3272 | if (r < 0) { | |
3273 | *exit_status = EXIT_NETWORK; | |
3274 | return log_unit_error_errno(unit, r, "Failed to set up network namespacing: %m"); | |
3275 | } | |
3276 | } else | |
3277 | log_unit_warning(unit, "PrivateNetwork=yes is configured, but the kernel does not support network namespaces, ignoring."); | |
d35fbf6b | 3278 | } |
169c1bda | 3279 | |
ee818b89 | 3280 | needs_mount_namespace = exec_needs_mount_namespace(context, params, runtime); |
ee818b89 | 3281 | if (needs_mount_namespace) { |
6818c54c | 3282 | r = apply_mount_namespace(unit, command, context, params, runtime); |
3fbe8dbe LP |
3283 | if (r < 0) { |
3284 | *exit_status = EXIT_NAMESPACE; | |
12145637 | 3285 | return log_unit_error_errno(unit, r, "Failed to set up mount namespacing: %m"); |
3fbe8dbe | 3286 | } |
d35fbf6b | 3287 | } |
81a2b7ce | 3288 | |
bbeea271 | 3289 | /* Drop groups as early as possbile */ |
165a31c0 | 3290 | if (needs_setuid) { |
709dbeac | 3291 | r = enforce_groups(gid, supplementary_gids, ngids); |
096424d1 LP |
3292 | if (r < 0) { |
3293 | *exit_status = EXIT_GROUP; | |
12145637 | 3294 | return log_unit_error_errno(unit, r, "Changing group credentials failed: %m"); |
096424d1 | 3295 | } |
165a31c0 | 3296 | } |
096424d1 | 3297 | |
165a31c0 | 3298 | if (needs_sandboxing) { |
349cc4a5 | 3299 | #if HAVE_SELINUX |
43b1f709 | 3300 | if (use_selinux && params->selinux_context_net && socket_fd >= 0) { |
937ccce9 LP |
3301 | r = mac_selinux_get_child_mls_label(socket_fd, command->path, context->selinux_context, &mac_selinux_context_net); |
3302 | if (r < 0) { | |
3303 | *exit_status = EXIT_SELINUX_CONTEXT; | |
12145637 | 3304 | return log_unit_error_errno(unit, r, "Failed to determine SELinux context: %m"); |
937ccce9 | 3305 | } |
9008e1ac | 3306 | } |
9008e1ac MS |
3307 | #endif |
3308 | ||
937ccce9 LP |
3309 | if (context->private_users) { |
3310 | r = setup_private_users(uid, gid); | |
3311 | if (r < 0) { | |
3312 | *exit_status = EXIT_USER; | |
12145637 | 3313 | return log_unit_error_errno(unit, r, "Failed to set up user namespacing: %m"); |
937ccce9 | 3314 | } |
d251207d LP |
3315 | } |
3316 | } | |
3317 | ||
165a31c0 | 3318 | /* We repeat the fd closing here, to make sure that nothing is leaked from the PAM modules. Note that we are |
5686391b LP |
3319 | * more aggressive this time since socket_fd and the netns fds we don't need anymore. We do keep the exec_fd |
3320 | * however if we have it as we want to keep it open until the final execve(). */ | |
3321 | ||
3322 | if (params->exec_fd >= 0) { | |
3323 | exec_fd = params->exec_fd; | |
3324 | ||
3325 | if (exec_fd < 3 + (int) n_fds) { | |
3326 | int moved_fd; | |
3327 | ||
3328 | /* Let's move the exec fd far up, so that it's outside of the fd range we want to pass to the | |
3329 | * process we are about to execute. */ | |
3330 | ||
3331 | moved_fd = fcntl(exec_fd, F_DUPFD_CLOEXEC, 3 + (int) n_fds); | |
3332 | if (moved_fd < 0) { | |
3333 | *exit_status = EXIT_FDS; | |
3334 | return log_unit_error_errno(unit, errno, "Couldn't move exec fd up: %m"); | |
3335 | } | |
3336 | ||
3337 | safe_close(exec_fd); | |
3338 | exec_fd = moved_fd; | |
3339 | } else { | |
3340 | /* This fd should be FD_CLOEXEC already, but let's make sure. */ | |
3341 | r = fd_cloexec(exec_fd, true); | |
3342 | if (r < 0) { | |
3343 | *exit_status = EXIT_FDS; | |
3344 | return log_unit_error_errno(unit, r, "Failed to make exec fd FD_CLOEXEC: %m"); | |
3345 | } | |
3346 | } | |
3347 | ||
3348 | fds_with_exec_fd = newa(int, n_fds + 1); | |
7e8d494b | 3349 | memcpy_safe(fds_with_exec_fd, fds, n_fds * sizeof(int)); |
5686391b LP |
3350 | fds_with_exec_fd[n_fds] = exec_fd; |
3351 | n_fds_with_exec_fd = n_fds + 1; | |
3352 | } else { | |
3353 | fds_with_exec_fd = fds; | |
3354 | n_fds_with_exec_fd = n_fds; | |
3355 | } | |
3356 | ||
3357 | r = close_all_fds(fds_with_exec_fd, n_fds_with_exec_fd); | |
ff0af2a1 LP |
3358 | if (r >= 0) |
3359 | r = shift_fds(fds, n_fds); | |
3360 | if (r >= 0) | |
25b583d7 | 3361 | r = flags_fds(fds, n_socket_fds, n_storage_fds, context->non_blocking); |
ff0af2a1 LP |
3362 | if (r < 0) { |
3363 | *exit_status = EXIT_FDS; | |
12145637 | 3364 | return log_unit_error_errno(unit, r, "Failed to adjust passed file descriptors: %m"); |
d35fbf6b | 3365 | } |
e66cf1a3 | 3366 | |
5686391b LP |
3367 | /* At this point, the fds we want to pass to the program are all ready and set up, with O_CLOEXEC turned off |
3368 | * and at the right fd numbers. The are no other fds open, with one exception: the exec_fd if it is defined, | |
3369 | * and it has O_CLOEXEC set, after all we want it to be closed by the execve(), so that our parent knows we | |
3370 | * came this far. */ | |
3371 | ||
165a31c0 | 3372 | secure_bits = context->secure_bits; |
e66cf1a3 | 3373 | |
165a31c0 LP |
3374 | if (needs_sandboxing) { |
3375 | uint64_t bset; | |
e66cf1a3 | 3376 | |
ce932d2d LP |
3377 | /* Set the RTPRIO resource limit to 0, but only if nothing else was explicitly |
3378 | * requested. (Note this is placed after the general resource limit initialization, see | |
3379 | * above, in order to take precedence.) */ | |
f4170c67 LP |
3380 | if (context->restrict_realtime && !context->rlimit[RLIMIT_RTPRIO]) { |
3381 | if (setrlimit(RLIMIT_RTPRIO, &RLIMIT_MAKE_CONST(0)) < 0) { | |
3382 | *exit_status = EXIT_LIMITS; | |
12145637 | 3383 | return log_unit_error_errno(unit, errno, "Failed to adjust RLIMIT_RTPRIO resource limit: %m"); |
f4170c67 LP |
3384 | } |
3385 | } | |
3386 | ||
37ac2744 JB |
3387 | #if ENABLE_SMACK |
3388 | /* LSM Smack needs the capability CAP_MAC_ADMIN to change the current execution security context of the | |
3389 | * process. This is the latest place before dropping capabilities. Other MAC context are set later. */ | |
3390 | if (use_smack) { | |
3391 | r = setup_smack(context, command); | |
3392 | if (r < 0) { | |
3393 | *exit_status = EXIT_SMACK_PROCESS_LABEL; | |
3394 | return log_unit_error_errno(unit, r, "Failed to set SMACK process label: %m"); | |
3395 | } | |
3396 | } | |
3397 | #endif | |
3398 | ||
165a31c0 LP |
3399 | bset = context->capability_bounding_set; |
3400 | /* If the ambient caps hack is enabled (which means the kernel can't do them, and the user asked for | |
3401 | * our magic fallback), then let's add some extra caps, so that the service can drop privs of its own, | |
3402 | * instead of us doing that */ | |
3403 | if (needs_ambient_hack) | |
3404 | bset |= (UINT64_C(1) << CAP_SETPCAP) | | |
3405 | (UINT64_C(1) << CAP_SETUID) | | |
3406 | (UINT64_C(1) << CAP_SETGID); | |
3407 | ||
3408 | if (!cap_test_all(bset)) { | |
3409 | r = capability_bounding_set_drop(bset, false); | |
ff0af2a1 LP |
3410 | if (r < 0) { |
3411 | *exit_status = EXIT_CAPABILITIES; | |
12145637 | 3412 | return log_unit_error_errno(unit, r, "Failed to drop capabilities: %m"); |
3b8bddde | 3413 | } |
4c2630eb | 3414 | } |
3b8bddde | 3415 | |
755d4b67 IP |
3416 | /* This is done before enforce_user, but ambient set |
3417 | * does not survive over setresuid() if keep_caps is not set. */ | |
165a31c0 LP |
3418 | if (!needs_ambient_hack && |
3419 | context->capability_ambient_set != 0) { | |
755d4b67 IP |
3420 | r = capability_ambient_set_apply(context->capability_ambient_set, true); |
3421 | if (r < 0) { | |
3422 | *exit_status = EXIT_CAPABILITIES; | |
12145637 | 3423 | return log_unit_error_errno(unit, r, "Failed to apply ambient capabilities (before UID change): %m"); |
755d4b67 | 3424 | } |
755d4b67 | 3425 | } |
165a31c0 | 3426 | } |
755d4b67 | 3427 | |
165a31c0 | 3428 | if (needs_setuid) { |
d35fbf6b | 3429 | if (context->user) { |
ff0af2a1 LP |
3430 | r = enforce_user(context, uid); |
3431 | if (r < 0) { | |
3432 | *exit_status = EXIT_USER; | |
12145637 | 3433 | return log_unit_error_errno(unit, r, "Failed to change UID to " UID_FMT ": %m", uid); |
5b6319dc | 3434 | } |
165a31c0 LP |
3435 | |
3436 | if (!needs_ambient_hack && | |
3437 | context->capability_ambient_set != 0) { | |
755d4b67 IP |
3438 | |
3439 | /* Fix the ambient capabilities after user change. */ | |
3440 | r = capability_ambient_set_apply(context->capability_ambient_set, false); | |
3441 | if (r < 0) { | |
3442 | *exit_status = EXIT_CAPABILITIES; | |
12145637 | 3443 | return log_unit_error_errno(unit, r, "Failed to apply ambient capabilities (after UID change): %m"); |
755d4b67 IP |
3444 | } |
3445 | ||
3446 | /* If we were asked to change user and ambient capabilities | |
3447 | * were requested, we had to add keep-caps to the securebits | |
3448 | * so that we would maintain the inherited capability set | |
3449 | * through the setresuid(). Make sure that the bit is added | |
3450 | * also to the context secure_bits so that we don't try to | |
3451 | * drop the bit away next. */ | |
3452 | ||
7f508f2c | 3453 | secure_bits |= 1<<SECURE_KEEP_CAPS; |
755d4b67 | 3454 | } |
5b6319dc | 3455 | } |
165a31c0 | 3456 | } |
d35fbf6b | 3457 | |
56ef8db9 JB |
3458 | /* Apply working directory here, because the working directory might be on NFS and only the user running |
3459 | * this service might have the correct privilege to change to the working directory */ | |
3460 | r = apply_working_directory(context, params, home, needs_mount_namespace, exit_status); | |
3461 | if (r < 0) | |
3462 | return log_unit_error_errno(unit, r, "Changing to the requested working directory failed: %m"); | |
3463 | ||
165a31c0 | 3464 | if (needs_sandboxing) { |
37ac2744 | 3465 | /* Apply other MAC contexts late, but before seccomp syscall filtering, as those should really be last to |
5cd9cd35 LP |
3466 | * influence our own codepaths as little as possible. Moreover, applying MAC contexts usually requires |
3467 | * syscalls that are subject to seccomp filtering, hence should probably be applied before the syscalls | |
3468 | * are restricted. */ | |
3469 | ||
349cc4a5 | 3470 | #if HAVE_SELINUX |
43b1f709 | 3471 | if (use_selinux) { |
5cd9cd35 LP |
3472 | char *exec_context = mac_selinux_context_net ?: context->selinux_context; |
3473 | ||
3474 | if (exec_context) { | |
3475 | r = setexeccon(exec_context); | |
3476 | if (r < 0) { | |
3477 | *exit_status = EXIT_SELINUX_CONTEXT; | |
12145637 | 3478 | return log_unit_error_errno(unit, r, "Failed to change SELinux context to %s: %m", exec_context); |
5cd9cd35 LP |
3479 | } |
3480 | } | |
3481 | } | |
3482 | #endif | |
3483 | ||
349cc4a5 | 3484 | #if HAVE_APPARMOR |
43b1f709 | 3485 | if (use_apparmor && context->apparmor_profile) { |
5cd9cd35 LP |
3486 | r = aa_change_onexec(context->apparmor_profile); |
3487 | if (r < 0 && !context->apparmor_profile_ignore) { | |
3488 | *exit_status = EXIT_APPARMOR_PROFILE; | |
12145637 | 3489 | return log_unit_error_errno(unit, errno, "Failed to prepare AppArmor profile change to %s: %m", context->apparmor_profile); |
5cd9cd35 LP |
3490 | } |
3491 | } | |
3492 | #endif | |
3493 | ||
165a31c0 LP |
3494 | /* PR_GET_SECUREBITS is not privileged, while PR_SET_SECUREBITS is. So to suppress potential EPERMs |
3495 | * we'll try not to call PR_SET_SECUREBITS unless necessary. */ | |
755d4b67 IP |
3496 | if (prctl(PR_GET_SECUREBITS) != secure_bits) |
3497 | if (prctl(PR_SET_SECUREBITS, secure_bits) < 0) { | |
ff0af2a1 | 3498 | *exit_status = EXIT_SECUREBITS; |
12145637 | 3499 | return log_unit_error_errno(unit, errno, "Failed to set process secure bits: %m"); |
ff01d048 | 3500 | } |
5b6319dc | 3501 | |
59eeb84b | 3502 | if (context_has_no_new_privileges(context)) |
d35fbf6b | 3503 | if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) < 0) { |
ff0af2a1 | 3504 | *exit_status = EXIT_NO_NEW_PRIVILEGES; |
12145637 | 3505 | return log_unit_error_errno(unit, errno, "Failed to disable new privileges: %m"); |
d35fbf6b DM |
3506 | } |
3507 | ||
349cc4a5 | 3508 | #if HAVE_SECCOMP |
469830d1 LP |
3509 | r = apply_address_families(unit, context); |
3510 | if (r < 0) { | |
3511 | *exit_status = EXIT_ADDRESS_FAMILIES; | |
12145637 | 3512 | return log_unit_error_errno(unit, r, "Failed to restrict address families: %m"); |
4c2630eb | 3513 | } |
04aa0cb9 | 3514 | |
469830d1 LP |
3515 | r = apply_memory_deny_write_execute(unit, context); |
3516 | if (r < 0) { | |
3517 | *exit_status = EXIT_SECCOMP; | |
12145637 | 3518 | return log_unit_error_errno(unit, r, "Failed to disable writing to executable memory: %m"); |
f3e43635 | 3519 | } |
f4170c67 | 3520 | |
469830d1 LP |
3521 | r = apply_restrict_realtime(unit, context); |
3522 | if (r < 0) { | |
3523 | *exit_status = EXIT_SECCOMP; | |
12145637 | 3524 | return log_unit_error_errno(unit, r, "Failed to apply realtime restrictions: %m"); |
f4170c67 LP |
3525 | } |
3526 | ||
add00535 LP |
3527 | r = apply_restrict_namespaces(unit, context); |
3528 | if (r < 0) { | |
3529 | *exit_status = EXIT_SECCOMP; | |
12145637 | 3530 | return log_unit_error_errno(unit, r, "Failed to apply namespace restrictions: %m"); |
add00535 LP |
3531 | } |
3532 | ||
469830d1 LP |
3533 | r = apply_protect_sysctl(unit, context); |
3534 | if (r < 0) { | |
3535 | *exit_status = EXIT_SECCOMP; | |
12145637 | 3536 | return log_unit_error_errno(unit, r, "Failed to apply sysctl restrictions: %m"); |
502d704e DH |
3537 | } |
3538 | ||
469830d1 LP |
3539 | r = apply_protect_kernel_modules(unit, context); |
3540 | if (r < 0) { | |
3541 | *exit_status = EXIT_SECCOMP; | |
12145637 | 3542 | return log_unit_error_errno(unit, r, "Failed to apply module loading restrictions: %m"); |
59eeb84b LP |
3543 | } |
3544 | ||
469830d1 LP |
3545 | r = apply_private_devices(unit, context); |
3546 | if (r < 0) { | |
3547 | *exit_status = EXIT_SECCOMP; | |
12145637 | 3548 | return log_unit_error_errno(unit, r, "Failed to set up private devices: %m"); |
469830d1 LP |
3549 | } |
3550 | ||
3551 | r = apply_syscall_archs(unit, context); | |
3552 | if (r < 0) { | |
3553 | *exit_status = EXIT_SECCOMP; | |
12145637 | 3554 | return log_unit_error_errno(unit, r, "Failed to apply syscall architecture restrictions: %m"); |
ba128bb8 LP |
3555 | } |
3556 | ||
78e864e5 TM |
3557 | r = apply_lock_personality(unit, context); |
3558 | if (r < 0) { | |
3559 | *exit_status = EXIT_SECCOMP; | |
12145637 | 3560 | return log_unit_error_errno(unit, r, "Failed to lock personalities: %m"); |
78e864e5 TM |
3561 | } |
3562 | ||
5cd9cd35 LP |
3563 | /* This really should remain the last step before the execve(), to make sure our own code is unaffected |
3564 | * by the filter as little as possible. */ | |
165a31c0 | 3565 | r = apply_syscall_filter(unit, context, needs_ambient_hack); |
469830d1 LP |
3566 | if (r < 0) { |
3567 | *exit_status = EXIT_SECCOMP; | |
12145637 | 3568 | return log_unit_error_errno(unit, r, "Failed to apply system call filters: %m"); |
d35fbf6b DM |
3569 | } |
3570 | #endif | |
d35fbf6b | 3571 | } |
034c6ed7 | 3572 | |
00819cc1 LP |
3573 | if (!strv_isempty(context->unset_environment)) { |
3574 | char **ee = NULL; | |
3575 | ||
3576 | ee = strv_env_delete(accum_env, 1, context->unset_environment); | |
3577 | if (!ee) { | |
3578 | *exit_status = EXIT_MEMORY; | |
12145637 | 3579 | return log_oom(); |
00819cc1 LP |
3580 | } |
3581 | ||
130d3d22 | 3582 | strv_free_and_replace(accum_env, ee); |
00819cc1 LP |
3583 | } |
3584 | ||
ee39ca20 | 3585 | final_argv = replace_env_argv(command->argv, accum_env); |
d35fbf6b | 3586 | if (!final_argv) { |
ff0af2a1 | 3587 | *exit_status = EXIT_MEMORY; |
12145637 | 3588 | return log_oom(); |
d35fbf6b | 3589 | } |
034c6ed7 | 3590 | |
f1d34068 | 3591 | if (DEBUG_LOGGING) { |
d35fbf6b | 3592 | _cleanup_free_ char *line; |
81a2b7ce | 3593 | |
d35fbf6b | 3594 | line = exec_command_line(final_argv); |
a1230ff9 | 3595 | if (line) |
f2341e0a | 3596 | log_struct(LOG_DEBUG, |
f2341e0a LP |
3597 | "EXECUTABLE=%s", command->path, |
3598 | LOG_UNIT_MESSAGE(unit, "Executing: %s", line), | |
ba360bb0 | 3599 | LOG_UNIT_ID(unit), |
a1230ff9 | 3600 | LOG_UNIT_INVOCATION_ID(unit)); |
d35fbf6b | 3601 | } |
dd305ec9 | 3602 | |
5686391b LP |
3603 | if (exec_fd >= 0) { |
3604 | uint8_t hot = 1; | |
3605 | ||
3606 | /* We have finished with all our initializations. Let's now let the manager know that. From this point | |
3607 | * on, if the manager sees POLLHUP on the exec_fd, then execve() was successful. */ | |
3608 | ||
3609 | if (write(exec_fd, &hot, sizeof(hot)) < 0) { | |
3610 | *exit_status = EXIT_EXEC; | |
3611 | return log_unit_error_errno(unit, errno, "Failed to enable exec_fd: %m"); | |
3612 | } | |
3613 | } | |
3614 | ||
2065ca69 | 3615 | execve(command->path, final_argv, accum_env); |
5686391b LP |
3616 | r = -errno; |
3617 | ||
3618 | if (exec_fd >= 0) { | |
3619 | uint8_t hot = 0; | |
3620 | ||
3621 | /* The execve() failed. This means the exec_fd is still open. Which means we need to tell the manager | |
3622 | * that POLLHUP on it no longer means execve() succeeded. */ | |
3623 | ||
3624 | if (write(exec_fd, &hot, sizeof(hot)) < 0) { | |
3625 | *exit_status = EXIT_EXEC; | |
3626 | return log_unit_error_errno(unit, errno, "Failed to disable exec_fd: %m"); | |
3627 | } | |
3628 | } | |
12145637 | 3629 | |
5686391b LP |
3630 | if (r == -ENOENT && (command->flags & EXEC_COMMAND_IGNORE_FAILURE)) { |
3631 | log_struct_errno(LOG_INFO, r, | |
12145637 LP |
3632 | "MESSAGE_ID=" SD_MESSAGE_SPAWN_FAILED_STR, |
3633 | LOG_UNIT_ID(unit), | |
3634 | LOG_UNIT_INVOCATION_ID(unit), | |
3635 | LOG_UNIT_MESSAGE(unit, "Executable %s missing, skipping: %m", | |
3636 | command->path), | |
a1230ff9 | 3637 | "EXECUTABLE=%s", command->path); |
12145637 LP |
3638 | return 0; |
3639 | } | |
3640 | ||
ff0af2a1 | 3641 | *exit_status = EXIT_EXEC; |
5686391b | 3642 | return log_unit_error_errno(unit, r, "Failed to execute command: %m"); |
d35fbf6b | 3643 | } |
81a2b7ce | 3644 | |
34cf6c43 YW |
3645 | static int exec_context_load_environment(const Unit *unit, const ExecContext *c, char ***l); |
3646 | static int exec_context_named_iofds(const ExecContext *c, const ExecParameters *p, int named_iofds[3]); | |
3647 | ||
f2341e0a LP |
3648 | int exec_spawn(Unit *unit, |
3649 | ExecCommand *command, | |
d35fbf6b DM |
3650 | const ExecContext *context, |
3651 | const ExecParameters *params, | |
3652 | ExecRuntime *runtime, | |
29206d46 | 3653 | DynamicCreds *dcreds, |
d35fbf6b | 3654 | pid_t *ret) { |
8351ceae | 3655 | |
ee39ca20 | 3656 | int socket_fd, r, named_iofds[3] = { -1, -1, -1 }, *fds = NULL; |
78f93209 | 3657 | _cleanup_free_ char *subcgroup_path = NULL; |
d35fbf6b | 3658 | _cleanup_strv_free_ char **files_env = NULL; |
da6053d0 | 3659 | size_t n_storage_fds = 0, n_socket_fds = 0; |
ff0af2a1 | 3660 | _cleanup_free_ char *line = NULL; |
d35fbf6b | 3661 | pid_t pid; |
8351ceae | 3662 | |
f2341e0a | 3663 | assert(unit); |
d35fbf6b DM |
3664 | assert(command); |
3665 | assert(context); | |
3666 | assert(ret); | |
3667 | assert(params); | |
25b583d7 | 3668 | assert(params->fds || (params->n_socket_fds + params->n_storage_fds <= 0)); |
4298d0b5 | 3669 | |
d35fbf6b DM |
3670 | if (context->std_input == EXEC_INPUT_SOCKET || |
3671 | context->std_output == EXEC_OUTPUT_SOCKET || | |
3672 | context->std_error == EXEC_OUTPUT_SOCKET) { | |
17df7223 | 3673 | |
4c47affc | 3674 | if (params->n_socket_fds > 1) { |
f2341e0a | 3675 | log_unit_error(unit, "Got more than one socket."); |
d35fbf6b | 3676 | return -EINVAL; |
ff0af2a1 | 3677 | } |
eef65bf3 | 3678 | |
4c47affc | 3679 | if (params->n_socket_fds == 0) { |
488ab41c AA |
3680 | log_unit_error(unit, "Got no socket."); |
3681 | return -EINVAL; | |
3682 | } | |
3683 | ||
d35fbf6b DM |
3684 | socket_fd = params->fds[0]; |
3685 | } else { | |
3686 | socket_fd = -1; | |
3687 | fds = params->fds; | |
9b141911 | 3688 | n_socket_fds = params->n_socket_fds; |
25b583d7 | 3689 | n_storage_fds = params->n_storage_fds; |
d35fbf6b | 3690 | } |
94f04347 | 3691 | |
34cf6c43 | 3692 | r = exec_context_named_iofds(context, params, named_iofds); |
52c239d7 LB |
3693 | if (r < 0) |
3694 | return log_unit_error_errno(unit, r, "Failed to load a named file descriptor: %m"); | |
3695 | ||
f2341e0a | 3696 | r = exec_context_load_environment(unit, context, &files_env); |
ff0af2a1 | 3697 | if (r < 0) |
f2341e0a | 3698 | return log_unit_error_errno(unit, r, "Failed to load environment files: %m"); |
034c6ed7 | 3699 | |
ee39ca20 | 3700 | line = exec_command_line(command->argv); |
d35fbf6b DM |
3701 | if (!line) |
3702 | return log_oom(); | |
fab56fc5 | 3703 | |
f2341e0a | 3704 | log_struct(LOG_DEBUG, |
f2341e0a LP |
3705 | LOG_UNIT_MESSAGE(unit, "About to execute: %s", line), |
3706 | "EXECUTABLE=%s", command->path, | |
ba360bb0 | 3707 | LOG_UNIT_ID(unit), |
a1230ff9 | 3708 | LOG_UNIT_INVOCATION_ID(unit)); |
12145637 | 3709 | |
78f93209 LP |
3710 | if (params->cgroup_path) { |
3711 | r = exec_parameters_get_cgroup_path(params, &subcgroup_path); | |
3712 | if (r < 0) | |
3713 | return log_unit_error_errno(unit, r, "Failed to acquire subcgroup path: %m"); | |
3714 | if (r > 0) { /* We are using a child cgroup */ | |
3715 | r = cg_create(SYSTEMD_CGROUP_CONTROLLER, subcgroup_path); | |
3716 | if (r < 0) | |
3717 | return log_unit_error_errno(unit, r, "Failed to create control group '%s': %m", subcgroup_path); | |
3718 | } | |
3719 | } | |
3720 | ||
d35fbf6b DM |
3721 | pid = fork(); |
3722 | if (pid < 0) | |
74129a12 | 3723 | return log_unit_error_errno(unit, errno, "Failed to fork: %m"); |
d35fbf6b DM |
3724 | |
3725 | if (pid == 0) { | |
12145637 | 3726 | int exit_status = EXIT_SUCCESS; |
ff0af2a1 | 3727 | |
f2341e0a LP |
3728 | r = exec_child(unit, |
3729 | command, | |
ff0af2a1 LP |
3730 | context, |
3731 | params, | |
3732 | runtime, | |
29206d46 | 3733 | dcreds, |
ff0af2a1 | 3734 | socket_fd, |
52c239d7 | 3735 | named_iofds, |
4c47affc | 3736 | fds, |
9b141911 | 3737 | n_socket_fds, |
25b583d7 | 3738 | n_storage_fds, |
ff0af2a1 | 3739 | files_env, |
00d9ef85 | 3740 | unit->manager->user_lookup_fds[1], |
12145637 LP |
3741 | &exit_status); |
3742 | ||
a1230ff9 | 3743 | if (r < 0) |
12145637 LP |
3744 | log_struct_errno(LOG_ERR, r, |
3745 | "MESSAGE_ID=" SD_MESSAGE_SPAWN_FAILED_STR, | |
3746 | LOG_UNIT_ID(unit), | |
3747 | LOG_UNIT_INVOCATION_ID(unit), | |
3748 | LOG_UNIT_MESSAGE(unit, "Failed at step %s spawning %s: %m", | |
3749 | exit_status_to_string(exit_status, EXIT_STATUS_SYSTEMD), | |
3750 | command->path), | |
a1230ff9 | 3751 | "EXECUTABLE=%s", command->path); |
4c2630eb | 3752 | |
ff0af2a1 | 3753 | _exit(exit_status); |
034c6ed7 LP |
3754 | } |
3755 | ||
f2341e0a | 3756 | log_unit_debug(unit, "Forked %s as "PID_FMT, command->path, pid); |
23635a85 | 3757 | |
78f93209 LP |
3758 | /* We add the new process to the cgroup both in the child (so that we can be sure that no user code is ever |
3759 | * executed outside of the cgroup) and in the parent (so that we can be sure that when we kill the cgroup the | |
3760 | * process will be killed too). */ | |
3761 | if (subcgroup_path) | |
3762 | (void) cg_attach(SYSTEMD_CGROUP_CONTROLLER, subcgroup_path, pid); | |
2da3263a | 3763 | |
b58b4116 | 3764 | exec_status_start(&command->exec_status, pid); |
9fb86720 | 3765 | |
034c6ed7 | 3766 | *ret = pid; |
5cb5a6ff LP |
3767 | return 0; |
3768 | } | |
3769 | ||
034c6ed7 | 3770 | void exec_context_init(ExecContext *c) { |
3536f49e YW |
3771 | ExecDirectoryType i; |
3772 | ||
034c6ed7 LP |
3773 | assert(c); |
3774 | ||
4c12626c | 3775 | c->umask = 0022; |
9eba9da4 | 3776 | c->ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 0); |
94f04347 | 3777 | c->cpu_sched_policy = SCHED_OTHER; |
071830ff | 3778 | c->syslog_priority = LOG_DAEMON|LOG_INFO; |
74922904 | 3779 | c->syslog_level_prefix = true; |
353e12c2 | 3780 | c->ignore_sigpipe = true; |
3a43da28 | 3781 | c->timer_slack_nsec = NSEC_INFINITY; |
050f7277 | 3782 | c->personality = PERSONALITY_INVALID; |
72fd1768 | 3783 | for (i = 0; i < _EXEC_DIRECTORY_TYPE_MAX; i++) |
3536f49e | 3784 | c->directories[i].mode = 0755; |
a103496c | 3785 | c->capability_bounding_set = CAP_ALL; |
aa9d574d YW |
3786 | assert_cc(NAMESPACE_FLAGS_INITIAL != NAMESPACE_FLAGS_ALL); |
3787 | c->restrict_namespaces = NAMESPACE_FLAGS_INITIAL; | |
d3070fbd | 3788 | c->log_level_max = -1; |
034c6ed7 LP |
3789 | } |
3790 | ||
613b411c | 3791 | void exec_context_done(ExecContext *c) { |
3536f49e | 3792 | ExecDirectoryType i; |
d3070fbd | 3793 | size_t l; |
5cb5a6ff LP |
3794 | |
3795 | assert(c); | |
3796 | ||
6796073e LP |
3797 | c->environment = strv_free(c->environment); |
3798 | c->environment_files = strv_free(c->environment_files); | |
b4c14404 | 3799 | c->pass_environment = strv_free(c->pass_environment); |
00819cc1 | 3800 | c->unset_environment = strv_free(c->unset_environment); |
8c7be95e | 3801 | |
31ce987c | 3802 | rlimit_free_all(c->rlimit); |
034c6ed7 | 3803 | |
2038c3f5 | 3804 | for (l = 0; l < 3; l++) { |
52c239d7 | 3805 | c->stdio_fdname[l] = mfree(c->stdio_fdname[l]); |
2038c3f5 LP |
3806 | c->stdio_file[l] = mfree(c->stdio_file[l]); |
3807 | } | |
52c239d7 | 3808 | |
a1e58e8e LP |
3809 | c->working_directory = mfree(c->working_directory); |
3810 | c->root_directory = mfree(c->root_directory); | |
915e6d16 | 3811 | c->root_image = mfree(c->root_image); |
a1e58e8e LP |
3812 | c->tty_path = mfree(c->tty_path); |
3813 | c->syslog_identifier = mfree(c->syslog_identifier); | |
3814 | c->user = mfree(c->user); | |
3815 | c->group = mfree(c->group); | |
034c6ed7 | 3816 | |
6796073e | 3817 | c->supplementary_groups = strv_free(c->supplementary_groups); |
94f04347 | 3818 | |
a1e58e8e | 3819 | c->pam_name = mfree(c->pam_name); |
5b6319dc | 3820 | |
2a624c36 AP |
3821 | c->read_only_paths = strv_free(c->read_only_paths); |
3822 | c->read_write_paths = strv_free(c->read_write_paths); | |
3823 | c->inaccessible_paths = strv_free(c->inaccessible_paths); | |
82c121a4 | 3824 | |
d2d6c096 | 3825 | bind_mount_free_many(c->bind_mounts, c->n_bind_mounts); |
8e06d57c YW |
3826 | c->bind_mounts = NULL; |
3827 | c->n_bind_mounts = 0; | |
2abd4e38 YW |
3828 | temporary_filesystem_free_many(c->temporary_filesystems, c->n_temporary_filesystems); |
3829 | c->temporary_filesystems = NULL; | |
3830 | c->n_temporary_filesystems = 0; | |
d2d6c096 | 3831 | |
da681e1b | 3832 | c->cpuset = cpu_set_mfree(c->cpuset); |
86a3475b | 3833 | |
a1e58e8e LP |
3834 | c->utmp_id = mfree(c->utmp_id); |
3835 | c->selinux_context = mfree(c->selinux_context); | |
3836 | c->apparmor_profile = mfree(c->apparmor_profile); | |
5b8e1b77 | 3837 | c->smack_process_label = mfree(c->smack_process_label); |
eef65bf3 | 3838 | |
8cfa775f | 3839 | c->syscall_filter = hashmap_free(c->syscall_filter); |
525d3cc7 LP |
3840 | c->syscall_archs = set_free(c->syscall_archs); |
3841 | c->address_families = set_free(c->address_families); | |
e66cf1a3 | 3842 | |
72fd1768 | 3843 | for (i = 0; i < _EXEC_DIRECTORY_TYPE_MAX; i++) |
3536f49e | 3844 | c->directories[i].paths = strv_free(c->directories[i].paths); |
d3070fbd LP |
3845 | |
3846 | c->log_level_max = -1; | |
3847 | ||
3848 | exec_context_free_log_extra_fields(c); | |
08f3be7a | 3849 | |
90fc172e AZ |
3850 | c->log_rate_limit_interval_usec = 0; |
3851 | c->log_rate_limit_burst = 0; | |
3852 | ||
08f3be7a LP |
3853 | c->stdin_data = mfree(c->stdin_data); |
3854 | c->stdin_data_size = 0; | |
e66cf1a3 LP |
3855 | } |
3856 | ||
34cf6c43 | 3857 | int exec_context_destroy_runtime_directory(const ExecContext *c, const char *runtime_prefix) { |
e66cf1a3 LP |
3858 | char **i; |
3859 | ||
3860 | assert(c); | |
3861 | ||
3862 | if (!runtime_prefix) | |
3863 | return 0; | |
3864 | ||
3536f49e | 3865 | STRV_FOREACH(i, c->directories[EXEC_DIRECTORY_RUNTIME].paths) { |
e66cf1a3 LP |
3866 | _cleanup_free_ char *p; |
3867 | ||
605405c6 | 3868 | p = strjoin(runtime_prefix, "/", *i); |
e66cf1a3 LP |
3869 | if (!p) |
3870 | return -ENOMEM; | |
3871 | ||
6c47cd7d | 3872 | /* We execute this synchronously, since we need to be sure this is gone when we start the service |
e66cf1a3 | 3873 | * next. */ |
c6878637 | 3874 | (void) rm_rf(p, REMOVE_ROOT); |
e66cf1a3 LP |
3875 | } |
3876 | ||
3877 | return 0; | |
5cb5a6ff LP |
3878 | } |
3879 | ||
34cf6c43 | 3880 | static void exec_command_done(ExecCommand *c) { |
43d0fcbd LP |
3881 | assert(c); |
3882 | ||
a1e58e8e | 3883 | c->path = mfree(c->path); |
6796073e | 3884 | c->argv = strv_free(c->argv); |
43d0fcbd LP |
3885 | } |
3886 | ||
da6053d0 LP |
3887 | void exec_command_done_array(ExecCommand *c, size_t n) { |
3888 | size_t i; | |
43d0fcbd LP |
3889 | |
3890 | for (i = 0; i < n; i++) | |
3891 | exec_command_done(c+i); | |
3892 | } | |
3893 | ||
f1acf85a | 3894 | ExecCommand* exec_command_free_list(ExecCommand *c) { |
5cb5a6ff LP |
3895 | ExecCommand *i; |
3896 | ||
3897 | while ((i = c)) { | |
71fda00f | 3898 | LIST_REMOVE(command, c, i); |
43d0fcbd | 3899 | exec_command_done(i); |
5cb5a6ff LP |
3900 | free(i); |
3901 | } | |
f1acf85a ZJS |
3902 | |
3903 | return NULL; | |
5cb5a6ff LP |
3904 | } |
3905 | ||
da6053d0 LP |
3906 | void exec_command_free_array(ExecCommand **c, size_t n) { |
3907 | size_t i; | |
034c6ed7 | 3908 | |
f1acf85a ZJS |
3909 | for (i = 0; i < n; i++) |
3910 | c[i] = exec_command_free_list(c[i]); | |
034c6ed7 LP |
3911 | } |
3912 | ||
6a1d4d9f LP |
3913 | void exec_command_reset_status_array(ExecCommand *c, size_t n) { |
3914 | size_t i; | |
3915 | ||
3916 | for (i = 0; i < n; i++) | |
3917 | exec_status_reset(&c[i].exec_status); | |
3918 | } | |
3919 | ||
3920 | void exec_command_reset_status_list_array(ExecCommand **c, size_t n) { | |
3921 | size_t i; | |
3922 | ||
3923 | for (i = 0; i < n; i++) { | |
3924 | ExecCommand *z; | |
3925 | ||
3926 | LIST_FOREACH(command, z, c[i]) | |
3927 | exec_status_reset(&z->exec_status); | |
3928 | } | |
3929 | } | |
3930 | ||
039f0e70 | 3931 | typedef struct InvalidEnvInfo { |
34cf6c43 | 3932 | const Unit *unit; |
039f0e70 LP |
3933 | const char *path; |
3934 | } InvalidEnvInfo; | |
3935 | ||
3936 | static void invalid_env(const char *p, void *userdata) { | |
3937 | InvalidEnvInfo *info = userdata; | |
3938 | ||
f2341e0a | 3939 | log_unit_error(info->unit, "Ignoring invalid environment assignment '%s': %s", p, info->path); |
039f0e70 LP |
3940 | } |
3941 | ||
52c239d7 LB |
3942 | const char* exec_context_fdname(const ExecContext *c, int fd_index) { |
3943 | assert(c); | |
3944 | ||
3945 | switch (fd_index) { | |
5073ff6b | 3946 | |
52c239d7 LB |
3947 | case STDIN_FILENO: |
3948 | if (c->std_input != EXEC_INPUT_NAMED_FD) | |
3949 | return NULL; | |
5073ff6b | 3950 | |
52c239d7 | 3951 | return c->stdio_fdname[STDIN_FILENO] ?: "stdin"; |
5073ff6b | 3952 | |
52c239d7 LB |
3953 | case STDOUT_FILENO: |
3954 | if (c->std_output != EXEC_OUTPUT_NAMED_FD) | |
3955 | return NULL; | |
5073ff6b | 3956 | |
52c239d7 | 3957 | return c->stdio_fdname[STDOUT_FILENO] ?: "stdout"; |
5073ff6b | 3958 | |
52c239d7 LB |
3959 | case STDERR_FILENO: |
3960 | if (c->std_error != EXEC_OUTPUT_NAMED_FD) | |
3961 | return NULL; | |
5073ff6b | 3962 | |
52c239d7 | 3963 | return c->stdio_fdname[STDERR_FILENO] ?: "stderr"; |
5073ff6b | 3964 | |
52c239d7 LB |
3965 | default: |
3966 | return NULL; | |
3967 | } | |
3968 | } | |
3969 | ||
3042bbeb | 3970 | static int exec_context_named_iofds(const ExecContext *c, const ExecParameters *p, int named_iofds[static 3]) { |
da6053d0 | 3971 | size_t i, targets; |
56fbd561 | 3972 | const char* stdio_fdname[3]; |
da6053d0 | 3973 | size_t n_fds; |
52c239d7 LB |
3974 | |
3975 | assert(c); | |
3976 | assert(p); | |
3977 | ||
3978 | targets = (c->std_input == EXEC_INPUT_NAMED_FD) + | |
3979 | (c->std_output == EXEC_OUTPUT_NAMED_FD) + | |
3980 | (c->std_error == EXEC_OUTPUT_NAMED_FD); | |
3981 | ||
3982 | for (i = 0; i < 3; i++) | |
3983 | stdio_fdname[i] = exec_context_fdname(c, i); | |
3984 | ||
4c47affc FB |
3985 | n_fds = p->n_storage_fds + p->n_socket_fds; |
3986 | ||
3987 | for (i = 0; i < n_fds && targets > 0; i++) | |
56fbd561 ZJS |
3988 | if (named_iofds[STDIN_FILENO] < 0 && |
3989 | c->std_input == EXEC_INPUT_NAMED_FD && | |
3990 | stdio_fdname[STDIN_FILENO] && | |
3991 | streq(p->fd_names[i], stdio_fdname[STDIN_FILENO])) { | |
3992 | ||
52c239d7 LB |
3993 | named_iofds[STDIN_FILENO] = p->fds[i]; |
3994 | targets--; | |
56fbd561 ZJS |
3995 | |
3996 | } else if (named_iofds[STDOUT_FILENO] < 0 && | |
3997 | c->std_output == EXEC_OUTPUT_NAMED_FD && | |
3998 | stdio_fdname[STDOUT_FILENO] && | |
3999 | streq(p->fd_names[i], stdio_fdname[STDOUT_FILENO])) { | |
4000 | ||
52c239d7 LB |
4001 | named_iofds[STDOUT_FILENO] = p->fds[i]; |
4002 | targets--; | |
56fbd561 ZJS |
4003 | |
4004 | } else if (named_iofds[STDERR_FILENO] < 0 && | |
4005 | c->std_error == EXEC_OUTPUT_NAMED_FD && | |
4006 | stdio_fdname[STDERR_FILENO] && | |
4007 | streq(p->fd_names[i], stdio_fdname[STDERR_FILENO])) { | |
4008 | ||
52c239d7 LB |
4009 | named_iofds[STDERR_FILENO] = p->fds[i]; |
4010 | targets--; | |
4011 | } | |
4012 | ||
56fbd561 | 4013 | return targets == 0 ? 0 : -ENOENT; |
52c239d7 LB |
4014 | } |
4015 | ||
34cf6c43 | 4016 | static int exec_context_load_environment(const Unit *unit, const ExecContext *c, char ***l) { |
8c7be95e LP |
4017 | char **i, **r = NULL; |
4018 | ||
4019 | assert(c); | |
4020 | assert(l); | |
4021 | ||
4022 | STRV_FOREACH(i, c->environment_files) { | |
4023 | char *fn; | |
52511fae ZJS |
4024 | int k; |
4025 | unsigned n; | |
8c7be95e LP |
4026 | bool ignore = false; |
4027 | char **p; | |
7fd1b19b | 4028 | _cleanup_globfree_ glob_t pglob = {}; |
8c7be95e LP |
4029 | |
4030 | fn = *i; | |
4031 | ||
4032 | if (fn[0] == '-') { | |
4033 | ignore = true; | |
313cefa1 | 4034 | fn++; |
8c7be95e LP |
4035 | } |
4036 | ||
4037 | if (!path_is_absolute(fn)) { | |
8c7be95e LP |
4038 | if (ignore) |
4039 | continue; | |
4040 | ||
4041 | strv_free(r); | |
4042 | return -EINVAL; | |
4043 | } | |
4044 | ||
2bef10ab | 4045 | /* Filename supports globbing, take all matching files */ |
d8c92e8b ZJS |
4046 | k = safe_glob(fn, 0, &pglob); |
4047 | if (k < 0) { | |
2bef10ab PL |
4048 | if (ignore) |
4049 | continue; | |
8c7be95e | 4050 | |
2bef10ab | 4051 | strv_free(r); |
d8c92e8b | 4052 | return k; |
2bef10ab | 4053 | } |
8c7be95e | 4054 | |
d8c92e8b ZJS |
4055 | /* When we don't match anything, -ENOENT should be returned */ |
4056 | assert(pglob.gl_pathc > 0); | |
4057 | ||
4058 | for (n = 0; n < pglob.gl_pathc; n++) { | |
aa8fbc74 | 4059 | k = load_env_file(NULL, pglob.gl_pathv[n], &p); |
2bef10ab PL |
4060 | if (k < 0) { |
4061 | if (ignore) | |
4062 | continue; | |
8c7be95e | 4063 | |
2bef10ab | 4064 | strv_free(r); |
2bef10ab | 4065 | return k; |
e9c1ea9d | 4066 | } |
ebc05a09 | 4067 | /* Log invalid environment variables with filename */ |
039f0e70 LP |
4068 | if (p) { |
4069 | InvalidEnvInfo info = { | |
f2341e0a | 4070 | .unit = unit, |
039f0e70 LP |
4071 | .path = pglob.gl_pathv[n] |
4072 | }; | |
4073 | ||
4074 | p = strv_env_clean_with_callback(p, invalid_env, &info); | |
4075 | } | |
8c7be95e | 4076 | |
234519ae | 4077 | if (!r) |
2bef10ab PL |
4078 | r = p; |
4079 | else { | |
4080 | char **m; | |
8c7be95e | 4081 | |
2bef10ab PL |
4082 | m = strv_env_merge(2, r, p); |
4083 | strv_free(r); | |
4084 | strv_free(p); | |
c84a9488 | 4085 | if (!m) |
2bef10ab | 4086 | return -ENOMEM; |
2bef10ab PL |
4087 | |
4088 | r = m; | |
4089 | } | |
8c7be95e LP |
4090 | } |
4091 | } | |
4092 | ||
4093 | *l = r; | |
4094 | ||
4095 | return 0; | |
4096 | } | |
4097 | ||
6ac8fdc9 | 4098 | static bool tty_may_match_dev_console(const char *tty) { |
7b912648 | 4099 | _cleanup_free_ char *resolved = NULL; |
6ac8fdc9 | 4100 | |
1e22b5cd LP |
4101 | if (!tty) |
4102 | return true; | |
4103 | ||
a119ec7c | 4104 | tty = skip_dev_prefix(tty); |
6ac8fdc9 MS |
4105 | |
4106 | /* trivial identity? */ | |
4107 | if (streq(tty, "console")) | |
4108 | return true; | |
4109 | ||
7b912648 LP |
4110 | if (resolve_dev_console(&resolved) < 0) |
4111 | return true; /* if we could not resolve, assume it may */ | |
6ac8fdc9 MS |
4112 | |
4113 | /* "tty0" means the active VC, so it may be the same sometimes */ | |
7b912648 | 4114 | return streq(resolved, tty) || (streq(resolved, "tty0") && tty_is_vc(tty)); |
6ac8fdc9 MS |
4115 | } |
4116 | ||
34cf6c43 | 4117 | bool exec_context_may_touch_console(const ExecContext *ec) { |
1e22b5cd LP |
4118 | |
4119 | return (ec->tty_reset || | |
4120 | ec->tty_vhangup || | |
4121 | ec->tty_vt_disallocate || | |
6ac8fdc9 MS |
4122 | is_terminal_input(ec->std_input) || |
4123 | is_terminal_output(ec->std_output) || | |
4124 | is_terminal_output(ec->std_error)) && | |
1e22b5cd | 4125 | tty_may_match_dev_console(exec_context_tty_path(ec)); |
6ac8fdc9 MS |
4126 | } |
4127 | ||
15ae422b LP |
4128 | static void strv_fprintf(FILE *f, char **l) { |
4129 | char **g; | |
4130 | ||
4131 | assert(f); | |
4132 | ||
4133 | STRV_FOREACH(g, l) | |
4134 | fprintf(f, " %s", *g); | |
4135 | } | |
4136 | ||
34cf6c43 | 4137 | void exec_context_dump(const ExecContext *c, FILE* f, const char *prefix) { |
d3070fbd | 4138 | ExecDirectoryType dt; |
c2bbd90b | 4139 | char **e, **d; |
94f04347 | 4140 | unsigned i; |
add00535 | 4141 | int r; |
9eba9da4 | 4142 | |
5cb5a6ff LP |
4143 | assert(c); |
4144 | assert(f); | |
4145 | ||
4ad49000 | 4146 | prefix = strempty(prefix); |
5cb5a6ff LP |
4147 | |
4148 | fprintf(f, | |
94f04347 LP |
4149 | "%sUMask: %04o\n" |
4150 | "%sWorkingDirectory: %s\n" | |
451a074f | 4151 | "%sRootDirectory: %s\n" |
15ae422b | 4152 | "%sNonBlocking: %s\n" |
64747e2d | 4153 | "%sPrivateTmp: %s\n" |
7f112f50 | 4154 | "%sPrivateDevices: %s\n" |
59eeb84b | 4155 | "%sProtectKernelTunables: %s\n" |
e66a2f65 | 4156 | "%sProtectKernelModules: %s\n" |
59eeb84b | 4157 | "%sProtectControlGroups: %s\n" |
d251207d LP |
4158 | "%sPrivateNetwork: %s\n" |
4159 | "%sPrivateUsers: %s\n" | |
1b8689f9 LP |
4160 | "%sProtectHome: %s\n" |
4161 | "%sProtectSystem: %s\n" | |
5d997827 | 4162 | "%sMountAPIVFS: %s\n" |
f3e43635 | 4163 | "%sIgnoreSIGPIPE: %s\n" |
f4170c67 | 4164 | "%sMemoryDenyWriteExecute: %s\n" |
b1edf445 LP |
4165 | "%sRestrictRealtime: %s\n" |
4166 | "%sKeyringMode: %s\n", | |
5cb5a6ff | 4167 | prefix, c->umask, |
9eba9da4 | 4168 | prefix, c->working_directory ? c->working_directory : "/", |
451a074f | 4169 | prefix, c->root_directory ? c->root_directory : "/", |
15ae422b | 4170 | prefix, yes_no(c->non_blocking), |
64747e2d | 4171 | prefix, yes_no(c->private_tmp), |
7f112f50 | 4172 | prefix, yes_no(c->private_devices), |
59eeb84b | 4173 | prefix, yes_no(c->protect_kernel_tunables), |
e66a2f65 | 4174 | prefix, yes_no(c->protect_kernel_modules), |
59eeb84b | 4175 | prefix, yes_no(c->protect_control_groups), |
d251207d LP |
4176 | prefix, yes_no(c->private_network), |
4177 | prefix, yes_no(c->private_users), | |
1b8689f9 LP |
4178 | prefix, protect_home_to_string(c->protect_home), |
4179 | prefix, protect_system_to_string(c->protect_system), | |
5d997827 | 4180 | prefix, yes_no(c->mount_apivfs), |
f3e43635 | 4181 | prefix, yes_no(c->ignore_sigpipe), |
f4170c67 | 4182 | prefix, yes_no(c->memory_deny_write_execute), |
b1edf445 LP |
4183 | prefix, yes_no(c->restrict_realtime), |
4184 | prefix, exec_keyring_mode_to_string(c->keyring_mode)); | |
fb33a393 | 4185 | |
915e6d16 LP |
4186 | if (c->root_image) |
4187 | fprintf(f, "%sRootImage: %s\n", prefix, c->root_image); | |
4188 | ||
8c7be95e LP |
4189 | STRV_FOREACH(e, c->environment) |
4190 | fprintf(f, "%sEnvironment: %s\n", prefix, *e); | |
4191 | ||
4192 | STRV_FOREACH(e, c->environment_files) | |
4193 | fprintf(f, "%sEnvironmentFile: %s\n", prefix, *e); | |
94f04347 | 4194 | |
b4c14404 FB |
4195 | STRV_FOREACH(e, c->pass_environment) |
4196 | fprintf(f, "%sPassEnvironment: %s\n", prefix, *e); | |
4197 | ||
00819cc1 LP |
4198 | STRV_FOREACH(e, c->unset_environment) |
4199 | fprintf(f, "%sUnsetEnvironment: %s\n", prefix, *e); | |
4200 | ||
53f47dfc YW |
4201 | fprintf(f, "%sRuntimeDirectoryPreserve: %s\n", prefix, exec_preserve_mode_to_string(c->runtime_directory_preserve_mode)); |
4202 | ||
72fd1768 | 4203 | for (dt = 0; dt < _EXEC_DIRECTORY_TYPE_MAX; dt++) { |
3536f49e YW |
4204 | fprintf(f, "%s%sMode: %04o\n", prefix, exec_directory_type_to_string(dt), c->directories[dt].mode); |
4205 | ||
4206 | STRV_FOREACH(d, c->directories[dt].paths) | |
4207 | fprintf(f, "%s%s: %s\n", prefix, exec_directory_type_to_string(dt), *d); | |
4208 | } | |
c2bbd90b | 4209 | |
fb33a393 LP |
4210 | if (c->nice_set) |
4211 | fprintf(f, | |
4212 | "%sNice: %i\n", | |
4213 | prefix, c->nice); | |
4214 | ||
dd6c17b1 | 4215 | if (c->oom_score_adjust_set) |
fb33a393 | 4216 | fprintf(f, |
dd6c17b1 LP |
4217 | "%sOOMScoreAdjust: %i\n", |
4218 | prefix, c->oom_score_adjust); | |
9eba9da4 | 4219 | |
94f04347 | 4220 | for (i = 0; i < RLIM_NLIMITS; i++) |
3c11da9d | 4221 | if (c->rlimit[i]) { |
4c3a2b84 | 4222 | fprintf(f, "%sLimit%s: " RLIM_FMT "\n", |
3c11da9d | 4223 | prefix, rlimit_to_string(i), c->rlimit[i]->rlim_max); |
4c3a2b84 | 4224 | fprintf(f, "%sLimit%sSoft: " RLIM_FMT "\n", |
3c11da9d EV |
4225 | prefix, rlimit_to_string(i), c->rlimit[i]->rlim_cur); |
4226 | } | |
94f04347 | 4227 | |
f8b69d1d | 4228 | if (c->ioprio_set) { |
1756a011 | 4229 | _cleanup_free_ char *class_str = NULL; |
f8b69d1d | 4230 | |
837df140 YW |
4231 | r = ioprio_class_to_string_alloc(IOPRIO_PRIO_CLASS(c->ioprio), &class_str); |
4232 | if (r >= 0) | |
4233 | fprintf(f, "%sIOSchedulingClass: %s\n", prefix, class_str); | |
4234 | ||
4235 | fprintf(f, "%sIOPriority: %lu\n", prefix, IOPRIO_PRIO_DATA(c->ioprio)); | |
f8b69d1d | 4236 | } |
94f04347 | 4237 | |
f8b69d1d | 4238 | if (c->cpu_sched_set) { |
1756a011 | 4239 | _cleanup_free_ char *policy_str = NULL; |
f8b69d1d | 4240 | |
837df140 YW |
4241 | r = sched_policy_to_string_alloc(c->cpu_sched_policy, &policy_str); |
4242 | if (r >= 0) | |
4243 | fprintf(f, "%sCPUSchedulingPolicy: %s\n", prefix, policy_str); | |
4244 | ||
94f04347 | 4245 | fprintf(f, |
38b48754 LP |
4246 | "%sCPUSchedulingPriority: %i\n" |
4247 | "%sCPUSchedulingResetOnFork: %s\n", | |
38b48754 LP |
4248 | prefix, c->cpu_sched_priority, |
4249 | prefix, yes_no(c->cpu_sched_reset_on_fork)); | |
b929bf04 | 4250 | } |
94f04347 | 4251 | |
82c121a4 | 4252 | if (c->cpuset) { |
94f04347 | 4253 | fprintf(f, "%sCPUAffinity:", prefix); |
82c121a4 LP |
4254 | for (i = 0; i < c->cpuset_ncpus; i++) |
4255 | if (CPU_ISSET_S(i, CPU_ALLOC_SIZE(c->cpuset_ncpus), c->cpuset)) | |
43a99a7a | 4256 | fprintf(f, " %u", i); |
94f04347 LP |
4257 | fputs("\n", f); |
4258 | } | |
4259 | ||
3a43da28 | 4260 | if (c->timer_slack_nsec != NSEC_INFINITY) |
ccd06097 | 4261 | fprintf(f, "%sTimerSlackNSec: "NSEC_FMT "\n", prefix, c->timer_slack_nsec); |
94f04347 LP |
4262 | |
4263 | fprintf(f, | |
80876c20 LP |
4264 | "%sStandardInput: %s\n" |
4265 | "%sStandardOutput: %s\n" | |
4266 | "%sStandardError: %s\n", | |
4267 | prefix, exec_input_to_string(c->std_input), | |
4268 | prefix, exec_output_to_string(c->std_output), | |
4269 | prefix, exec_output_to_string(c->std_error)); | |
4270 | ||
befc4a80 LP |
4271 | if (c->std_input == EXEC_INPUT_NAMED_FD) |
4272 | fprintf(f, "%sStandardInputFileDescriptorName: %s\n", prefix, c->stdio_fdname[STDIN_FILENO]); | |
4273 | if (c->std_output == EXEC_OUTPUT_NAMED_FD) | |
4274 | fprintf(f, "%sStandardOutputFileDescriptorName: %s\n", prefix, c->stdio_fdname[STDOUT_FILENO]); | |
4275 | if (c->std_error == EXEC_OUTPUT_NAMED_FD) | |
4276 | fprintf(f, "%sStandardErrorFileDescriptorName: %s\n", prefix, c->stdio_fdname[STDERR_FILENO]); | |
4277 | ||
4278 | if (c->std_input == EXEC_INPUT_FILE) | |
4279 | fprintf(f, "%sStandardInputFile: %s\n", prefix, c->stdio_file[STDIN_FILENO]); | |
4280 | if (c->std_output == EXEC_OUTPUT_FILE) | |
4281 | fprintf(f, "%sStandardOutputFile: %s\n", prefix, c->stdio_file[STDOUT_FILENO]); | |
566b7d23 ZD |
4282 | if (c->std_output == EXEC_OUTPUT_FILE_APPEND) |
4283 | fprintf(f, "%sStandardOutputFileToAppend: %s\n", prefix, c->stdio_file[STDOUT_FILENO]); | |
befc4a80 LP |
4284 | if (c->std_error == EXEC_OUTPUT_FILE) |
4285 | fprintf(f, "%sStandardErrorFile: %s\n", prefix, c->stdio_file[STDERR_FILENO]); | |
566b7d23 ZD |
4286 | if (c->std_error == EXEC_OUTPUT_FILE_APPEND) |
4287 | fprintf(f, "%sStandardErrorFileToAppend: %s\n", prefix, c->stdio_file[STDERR_FILENO]); | |
befc4a80 | 4288 | |
80876c20 LP |
4289 | if (c->tty_path) |
4290 | fprintf(f, | |
6ea832a2 LP |
4291 | "%sTTYPath: %s\n" |
4292 | "%sTTYReset: %s\n" | |
4293 | "%sTTYVHangup: %s\n" | |
4294 | "%sTTYVTDisallocate: %s\n", | |
4295 | prefix, c->tty_path, | |
4296 | prefix, yes_no(c->tty_reset), | |
4297 | prefix, yes_no(c->tty_vhangup), | |
4298 | prefix, yes_no(c->tty_vt_disallocate)); | |
94f04347 | 4299 | |
9f6444eb LP |
4300 | if (IN_SET(c->std_output, |
4301 | EXEC_OUTPUT_SYSLOG, | |
4302 | EXEC_OUTPUT_KMSG, | |
4303 | EXEC_OUTPUT_JOURNAL, | |
4304 | EXEC_OUTPUT_SYSLOG_AND_CONSOLE, | |
4305 | EXEC_OUTPUT_KMSG_AND_CONSOLE, | |
4306 | EXEC_OUTPUT_JOURNAL_AND_CONSOLE) || | |
4307 | IN_SET(c->std_error, | |
4308 | EXEC_OUTPUT_SYSLOG, | |
4309 | EXEC_OUTPUT_KMSG, | |
4310 | EXEC_OUTPUT_JOURNAL, | |
4311 | EXEC_OUTPUT_SYSLOG_AND_CONSOLE, | |
4312 | EXEC_OUTPUT_KMSG_AND_CONSOLE, | |
4313 | EXEC_OUTPUT_JOURNAL_AND_CONSOLE)) { | |
f8b69d1d | 4314 | |
5ce70e5b | 4315 | _cleanup_free_ char *fac_str = NULL, *lvl_str = NULL; |
f8b69d1d | 4316 | |
837df140 YW |
4317 | r = log_facility_unshifted_to_string_alloc(c->syslog_priority >> 3, &fac_str); |
4318 | if (r >= 0) | |
4319 | fprintf(f, "%sSyslogFacility: %s\n", prefix, fac_str); | |
f8b69d1d | 4320 | |
837df140 YW |
4321 | r = log_level_to_string_alloc(LOG_PRI(c->syslog_priority), &lvl_str); |
4322 | if (r >= 0) | |
4323 | fprintf(f, "%sSyslogLevel: %s\n", prefix, lvl_str); | |
f8b69d1d | 4324 | } |
94f04347 | 4325 | |
d3070fbd LP |
4326 | if (c->log_level_max >= 0) { |
4327 | _cleanup_free_ char *t = NULL; | |
4328 | ||
4329 | (void) log_level_to_string_alloc(c->log_level_max, &t); | |
4330 | ||
4331 | fprintf(f, "%sLogLevelMax: %s\n", prefix, strna(t)); | |
4332 | } | |
4333 | ||
90fc172e AZ |
4334 | if (c->log_rate_limit_interval_usec > 0) { |
4335 | char buf_timespan[FORMAT_TIMESPAN_MAX]; | |
4336 | ||
4337 | fprintf(f, | |
4338 | "%sLogRateLimitIntervalSec: %s\n", | |
4339 | prefix, format_timespan(buf_timespan, sizeof(buf_timespan), c->log_rate_limit_interval_usec, USEC_PER_SEC)); | |
4340 | } | |
4341 | ||
4342 | if (c->log_rate_limit_burst > 0) | |
4343 | fprintf(f, "%sLogRateLimitBurst: %u\n", prefix, c->log_rate_limit_burst); | |
4344 | ||
d3070fbd LP |
4345 | if (c->n_log_extra_fields > 0) { |
4346 | size_t j; | |
4347 | ||
4348 | for (j = 0; j < c->n_log_extra_fields; j++) { | |
4349 | fprintf(f, "%sLogExtraFields: ", prefix); | |
4350 | fwrite(c->log_extra_fields[j].iov_base, | |
4351 | 1, c->log_extra_fields[j].iov_len, | |
4352 | f); | |
4353 | fputc('\n', f); | |
4354 | } | |
4355 | } | |
4356 | ||
07d46372 YW |
4357 | if (c->secure_bits) { |
4358 | _cleanup_free_ char *str = NULL; | |
4359 | ||
4360 | r = secure_bits_to_string_alloc(c->secure_bits, &str); | |
4361 | if (r >= 0) | |
4362 | fprintf(f, "%sSecure Bits: %s\n", prefix, str); | |
4363 | } | |
94f04347 | 4364 | |
a103496c | 4365 | if (c->capability_bounding_set != CAP_ALL) { |
dd1f5bd0 | 4366 | _cleanup_free_ char *str = NULL; |
94f04347 | 4367 | |
dd1f5bd0 YW |
4368 | r = capability_set_to_string_alloc(c->capability_bounding_set, &str); |
4369 | if (r >= 0) | |
4370 | fprintf(f, "%sCapabilityBoundingSet: %s\n", prefix, str); | |
755d4b67 IP |
4371 | } |
4372 | ||
4373 | if (c->capability_ambient_set != 0) { | |
dd1f5bd0 | 4374 | _cleanup_free_ char *str = NULL; |
755d4b67 | 4375 | |
dd1f5bd0 YW |
4376 | r = capability_set_to_string_alloc(c->capability_ambient_set, &str); |
4377 | if (r >= 0) | |
4378 | fprintf(f, "%sAmbientCapabilities: %s\n", prefix, str); | |
94f04347 LP |
4379 | } |
4380 | ||
4381 | if (c->user) | |
f2d3769a | 4382 | fprintf(f, "%sUser: %s\n", prefix, c->user); |
94f04347 | 4383 | if (c->group) |
f2d3769a | 4384 | fprintf(f, "%sGroup: %s\n", prefix, c->group); |
94f04347 | 4385 | |
29206d46 LP |
4386 | fprintf(f, "%sDynamicUser: %s\n", prefix, yes_no(c->dynamic_user)); |
4387 | ||
ac6e8be6 | 4388 | if (!strv_isempty(c->supplementary_groups)) { |
94f04347 | 4389 | fprintf(f, "%sSupplementaryGroups:", prefix); |
15ae422b LP |
4390 | strv_fprintf(f, c->supplementary_groups); |
4391 | fputs("\n", f); | |
4392 | } | |
94f04347 | 4393 | |
5b6319dc | 4394 | if (c->pam_name) |
f2d3769a | 4395 | fprintf(f, "%sPAMName: %s\n", prefix, c->pam_name); |
5b6319dc | 4396 | |
58629001 | 4397 | if (!strv_isempty(c->read_write_paths)) { |
2a624c36 AP |
4398 | fprintf(f, "%sReadWritePaths:", prefix); |
4399 | strv_fprintf(f, c->read_write_paths); | |
15ae422b LP |
4400 | fputs("\n", f); |
4401 | } | |
4402 | ||
58629001 | 4403 | if (!strv_isempty(c->read_only_paths)) { |
2a624c36 AP |
4404 | fprintf(f, "%sReadOnlyPaths:", prefix); |
4405 | strv_fprintf(f, c->read_only_paths); | |
15ae422b LP |
4406 | fputs("\n", f); |
4407 | } | |
94f04347 | 4408 | |
58629001 | 4409 | if (!strv_isempty(c->inaccessible_paths)) { |
2a624c36 AP |
4410 | fprintf(f, "%sInaccessiblePaths:", prefix); |
4411 | strv_fprintf(f, c->inaccessible_paths); | |
94f04347 LP |
4412 | fputs("\n", f); |
4413 | } | |
2e22afe9 | 4414 | |
d2d6c096 | 4415 | if (c->n_bind_mounts > 0) |
4ca763a9 YW |
4416 | for (i = 0; i < c->n_bind_mounts; i++) |
4417 | fprintf(f, "%s%s: %s%s:%s:%s\n", prefix, | |
d2d6c096 | 4418 | c->bind_mounts[i].read_only ? "BindReadOnlyPaths" : "BindPaths", |
4ca763a9 | 4419 | c->bind_mounts[i].ignore_enoent ? "-": "", |
d2d6c096 LP |
4420 | c->bind_mounts[i].source, |
4421 | c->bind_mounts[i].destination, | |
4422 | c->bind_mounts[i].recursive ? "rbind" : "norbind"); | |
d2d6c096 | 4423 | |
2abd4e38 YW |
4424 | if (c->n_temporary_filesystems > 0) |
4425 | for (i = 0; i < c->n_temporary_filesystems; i++) { | |
4426 | TemporaryFileSystem *t = c->temporary_filesystems + i; | |
4427 | ||
4428 | fprintf(f, "%sTemporaryFileSystem: %s%s%s\n", prefix, | |
4429 | t->path, | |
4430 | isempty(t->options) ? "" : ":", | |
4431 | strempty(t->options)); | |
4432 | } | |
4433 | ||
169c1bda LP |
4434 | if (c->utmp_id) |
4435 | fprintf(f, | |
4436 | "%sUtmpIdentifier: %s\n", | |
4437 | prefix, c->utmp_id); | |
7b52a628 MS |
4438 | |
4439 | if (c->selinux_context) | |
4440 | fprintf(f, | |
5f8640fb LP |
4441 | "%sSELinuxContext: %s%s\n", |
4442 | prefix, c->selinux_context_ignore ? "-" : "", c->selinux_context); | |
17df7223 | 4443 | |
80c21aea WC |
4444 | if (c->apparmor_profile) |
4445 | fprintf(f, | |
4446 | "%sAppArmorProfile: %s%s\n", | |
4447 | prefix, c->apparmor_profile_ignore ? "-" : "", c->apparmor_profile); | |
4448 | ||
4449 | if (c->smack_process_label) | |
4450 | fprintf(f, | |
4451 | "%sSmackProcessLabel: %s%s\n", | |
4452 | prefix, c->smack_process_label_ignore ? "-" : "", c->smack_process_label); | |
4453 | ||
050f7277 | 4454 | if (c->personality != PERSONALITY_INVALID) |
ac45f971 LP |
4455 | fprintf(f, |
4456 | "%sPersonality: %s\n", | |
4457 | prefix, strna(personality_to_string(c->personality))); | |
4458 | ||
78e864e5 TM |
4459 | fprintf(f, |
4460 | "%sLockPersonality: %s\n", | |
4461 | prefix, yes_no(c->lock_personality)); | |
4462 | ||
17df7223 | 4463 | if (c->syscall_filter) { |
349cc4a5 | 4464 | #if HAVE_SECCOMP |
17df7223 | 4465 | Iterator j; |
8cfa775f | 4466 | void *id, *val; |
17df7223 | 4467 | bool first = true; |
351a19b1 | 4468 | #endif |
17df7223 LP |
4469 | |
4470 | fprintf(f, | |
57183d11 | 4471 | "%sSystemCallFilter: ", |
17df7223 LP |
4472 | prefix); |
4473 | ||
4474 | if (!c->syscall_whitelist) | |
4475 | fputc('~', f); | |
4476 | ||
349cc4a5 | 4477 | #if HAVE_SECCOMP |
8cfa775f | 4478 | HASHMAP_FOREACH_KEY(val, id, c->syscall_filter, j) { |
17df7223 | 4479 | _cleanup_free_ char *name = NULL; |
8cfa775f YW |
4480 | const char *errno_name = NULL; |
4481 | int num = PTR_TO_INT(val); | |
17df7223 LP |
4482 | |
4483 | if (first) | |
4484 | first = false; | |
4485 | else | |
4486 | fputc(' ', f); | |
4487 | ||
57183d11 | 4488 | name = seccomp_syscall_resolve_num_arch(SCMP_ARCH_NATIVE, PTR_TO_INT(id) - 1); |
17df7223 | 4489 | fputs(strna(name), f); |
8cfa775f YW |
4490 | |
4491 | if (num >= 0) { | |
4492 | errno_name = errno_to_name(num); | |
4493 | if (errno_name) | |
4494 | fprintf(f, ":%s", errno_name); | |
4495 | else | |
4496 | fprintf(f, ":%d", num); | |
4497 | } | |
17df7223 | 4498 | } |
351a19b1 | 4499 | #endif |
17df7223 LP |
4500 | |
4501 | fputc('\n', f); | |
4502 | } | |
4503 | ||
57183d11 | 4504 | if (c->syscall_archs) { |
349cc4a5 | 4505 | #if HAVE_SECCOMP |
57183d11 LP |
4506 | Iterator j; |
4507 | void *id; | |
4508 | #endif | |
4509 | ||
4510 | fprintf(f, | |
4511 | "%sSystemCallArchitectures:", | |
4512 | prefix); | |
4513 | ||
349cc4a5 | 4514 | #if HAVE_SECCOMP |
57183d11 LP |
4515 | SET_FOREACH(id, c->syscall_archs, j) |
4516 | fprintf(f, " %s", strna(seccomp_arch_to_string(PTR_TO_UINT32(id) - 1))); | |
4517 | #endif | |
4518 | fputc('\n', f); | |
4519 | } | |
4520 | ||
add00535 LP |
4521 | if (exec_context_restrict_namespaces_set(c)) { |
4522 | _cleanup_free_ char *s = NULL; | |
4523 | ||
86c2a9f1 | 4524 | r = namespace_flags_to_string(c->restrict_namespaces, &s); |
add00535 LP |
4525 | if (r >= 0) |
4526 | fprintf(f, "%sRestrictNamespaces: %s\n", | |
4527 | prefix, s); | |
4528 | } | |
4529 | ||
3df90f24 YW |
4530 | if (c->syscall_errno > 0) { |
4531 | const char *errno_name; | |
4532 | ||
4533 | fprintf(f, "%sSystemCallErrorNumber: ", prefix); | |
4534 | ||
4535 | errno_name = errno_to_name(c->syscall_errno); | |
4536 | if (errno_name) | |
4537 | fprintf(f, "%s\n", errno_name); | |
4538 | else | |
4539 | fprintf(f, "%d\n", c->syscall_errno); | |
4540 | } | |
eef65bf3 MS |
4541 | |
4542 | if (c->apparmor_profile) | |
4543 | fprintf(f, | |
4544 | "%sAppArmorProfile: %s%s\n", | |
4545 | prefix, c->apparmor_profile_ignore ? "-" : "", c->apparmor_profile); | |
5cb5a6ff LP |
4546 | } |
4547 | ||
34cf6c43 | 4548 | bool exec_context_maintains_privileges(const ExecContext *c) { |
a931ad47 LP |
4549 | assert(c); |
4550 | ||
61233823 | 4551 | /* Returns true if the process forked off would run under |
a931ad47 LP |
4552 | * an unchanged UID or as root. */ |
4553 | ||
4554 | if (!c->user) | |
4555 | return true; | |
4556 | ||
4557 | if (streq(c->user, "root") || streq(c->user, "0")) | |
4558 | return true; | |
4559 | ||
4560 | return false; | |
4561 | } | |
4562 | ||
34cf6c43 | 4563 | int exec_context_get_effective_ioprio(const ExecContext *c) { |
7f452159 LP |
4564 | int p; |
4565 | ||
4566 | assert(c); | |
4567 | ||
4568 | if (c->ioprio_set) | |
4569 | return c->ioprio; | |
4570 | ||
4571 | p = ioprio_get(IOPRIO_WHO_PROCESS, 0); | |
4572 | if (p < 0) | |
4573 | return IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 4); | |
4574 | ||
4575 | return p; | |
4576 | } | |
4577 | ||
d3070fbd LP |
4578 | void exec_context_free_log_extra_fields(ExecContext *c) { |
4579 | size_t l; | |
4580 | ||
4581 | assert(c); | |
4582 | ||
4583 | for (l = 0; l < c->n_log_extra_fields; l++) | |
4584 | free(c->log_extra_fields[l].iov_base); | |
4585 | c->log_extra_fields = mfree(c->log_extra_fields); | |
4586 | c->n_log_extra_fields = 0; | |
4587 | } | |
4588 | ||
b58b4116 | 4589 | void exec_status_start(ExecStatus *s, pid_t pid) { |
034c6ed7 | 4590 | assert(s); |
5cb5a6ff | 4591 | |
2ed26ed0 LP |
4592 | *s = (ExecStatus) { |
4593 | .pid = pid, | |
4594 | }; | |
4595 | ||
b58b4116 LP |
4596 | dual_timestamp_get(&s->start_timestamp); |
4597 | } | |
4598 | ||
34cf6c43 | 4599 | void exec_status_exit(ExecStatus *s, const ExecContext *context, pid_t pid, int code, int status) { |
b58b4116 LP |
4600 | assert(s); |
4601 | ||
2ed26ed0 LP |
4602 | if (s->pid != pid) { |
4603 | *s = (ExecStatus) { | |
4604 | .pid = pid, | |
4605 | }; | |
4606 | } | |
b58b4116 | 4607 | |
63983207 | 4608 | dual_timestamp_get(&s->exit_timestamp); |
9fb86720 | 4609 | |
034c6ed7 LP |
4610 | s->code = code; |
4611 | s->status = status; | |
169c1bda | 4612 | |
6ea832a2 LP |
4613 | if (context) { |
4614 | if (context->utmp_id) | |
2ed26ed0 | 4615 | (void) utmp_put_dead_process(context->utmp_id, pid, code, status); |
6ea832a2 | 4616 | |
1e22b5cd | 4617 | exec_context_tty_reset(context, NULL); |
6ea832a2 | 4618 | } |
9fb86720 LP |
4619 | } |
4620 | ||
6a1d4d9f LP |
4621 | void exec_status_reset(ExecStatus *s) { |
4622 | assert(s); | |
4623 | ||
4624 | *s = (ExecStatus) {}; | |
4625 | } | |
4626 | ||
34cf6c43 | 4627 | void exec_status_dump(const ExecStatus *s, FILE *f, const char *prefix) { |
9fb86720 LP |
4628 | char buf[FORMAT_TIMESTAMP_MAX]; |
4629 | ||
4630 | assert(s); | |
4631 | assert(f); | |
4632 | ||
9fb86720 LP |
4633 | if (s->pid <= 0) |
4634 | return; | |
4635 | ||
4c940960 LP |
4636 | prefix = strempty(prefix); |
4637 | ||
9fb86720 | 4638 | fprintf(f, |
ccd06097 ZJS |
4639 | "%sPID: "PID_FMT"\n", |
4640 | prefix, s->pid); | |
9fb86720 | 4641 | |
af9d16e1 | 4642 | if (dual_timestamp_is_set(&s->start_timestamp)) |
9fb86720 LP |
4643 | fprintf(f, |
4644 | "%sStart Timestamp: %s\n", | |
63983207 | 4645 | prefix, format_timestamp(buf, sizeof(buf), s->start_timestamp.realtime)); |
9fb86720 | 4646 | |
af9d16e1 | 4647 | if (dual_timestamp_is_set(&s->exit_timestamp)) |
9fb86720 LP |
4648 | fprintf(f, |
4649 | "%sExit Timestamp: %s\n" | |
4650 | "%sExit Code: %s\n" | |
4651 | "%sExit Status: %i\n", | |
63983207 | 4652 | prefix, format_timestamp(buf, sizeof(buf), s->exit_timestamp.realtime), |
9fb86720 LP |
4653 | prefix, sigchld_code_to_string(s->code), |
4654 | prefix, s->status); | |
5cb5a6ff | 4655 | } |
44d8db9e | 4656 | |
34cf6c43 | 4657 | static char *exec_command_line(char **argv) { |
44d8db9e LP |
4658 | size_t k; |
4659 | char *n, *p, **a; | |
4660 | bool first = true; | |
4661 | ||
9e2f7c11 | 4662 | assert(argv); |
44d8db9e | 4663 | |
9164977d | 4664 | k = 1; |
9e2f7c11 | 4665 | STRV_FOREACH(a, argv) |
44d8db9e LP |
4666 | k += strlen(*a)+3; |
4667 | ||
5cd9cd35 LP |
4668 | n = new(char, k); |
4669 | if (!n) | |
44d8db9e LP |
4670 | return NULL; |
4671 | ||
4672 | p = n; | |
9e2f7c11 | 4673 | STRV_FOREACH(a, argv) { |
44d8db9e LP |
4674 | |
4675 | if (!first) | |
4676 | *(p++) = ' '; | |
4677 | else | |
4678 | first = false; | |
4679 | ||
4680 | if (strpbrk(*a, WHITESPACE)) { | |
4681 | *(p++) = '\''; | |
4682 | p = stpcpy(p, *a); | |
4683 | *(p++) = '\''; | |
4684 | } else | |
4685 | p = stpcpy(p, *a); | |
4686 | ||
4687 | } | |
4688 | ||
9164977d LP |
4689 | *p = 0; |
4690 | ||
44d8db9e LP |
4691 | /* FIXME: this doesn't really handle arguments that have |
4692 | * spaces and ticks in them */ | |
4693 | ||
4694 | return n; | |
4695 | } | |
4696 | ||
34cf6c43 | 4697 | static void exec_command_dump(ExecCommand *c, FILE *f, const char *prefix) { |
e1d75803 | 4698 | _cleanup_free_ char *cmd = NULL; |
4c940960 | 4699 | const char *prefix2; |
44d8db9e LP |
4700 | |
4701 | assert(c); | |
4702 | assert(f); | |
4703 | ||
4c940960 | 4704 | prefix = strempty(prefix); |
63c372cb | 4705 | prefix2 = strjoina(prefix, "\t"); |
44d8db9e | 4706 | |
9e2f7c11 | 4707 | cmd = exec_command_line(c->argv); |
44d8db9e LP |
4708 | fprintf(f, |
4709 | "%sCommand Line: %s\n", | |
4710 | prefix, cmd ? cmd : strerror(ENOMEM)); | |
4711 | ||
9fb86720 | 4712 | exec_status_dump(&c->exec_status, f, prefix2); |
44d8db9e LP |
4713 | } |
4714 | ||
4715 | void exec_command_dump_list(ExecCommand *c, FILE *f, const char *prefix) { | |
4716 | assert(f); | |
4717 | ||
4c940960 | 4718 | prefix = strempty(prefix); |
44d8db9e LP |
4719 | |
4720 | LIST_FOREACH(command, c, c) | |
4721 | exec_command_dump(c, f, prefix); | |
4722 | } | |
94f04347 | 4723 | |
a6a80b4f LP |
4724 | void exec_command_append_list(ExecCommand **l, ExecCommand *e) { |
4725 | ExecCommand *end; | |
4726 | ||
4727 | assert(l); | |
4728 | assert(e); | |
4729 | ||
4730 | if (*l) { | |
35b8ca3a | 4731 | /* It's kind of important, that we keep the order here */ |
71fda00f LP |
4732 | LIST_FIND_TAIL(command, *l, end); |
4733 | LIST_INSERT_AFTER(command, *l, end, e); | |
a6a80b4f LP |
4734 | } else |
4735 | *l = e; | |
4736 | } | |
4737 | ||
26fd040d LP |
4738 | int exec_command_set(ExecCommand *c, const char *path, ...) { |
4739 | va_list ap; | |
4740 | char **l, *p; | |
4741 | ||
4742 | assert(c); | |
4743 | assert(path); | |
4744 | ||
4745 | va_start(ap, path); | |
4746 | l = strv_new_ap(path, ap); | |
4747 | va_end(ap); | |
4748 | ||
4749 | if (!l) | |
4750 | return -ENOMEM; | |
4751 | ||
250a918d LP |
4752 | p = strdup(path); |
4753 | if (!p) { | |
26fd040d LP |
4754 | strv_free(l); |
4755 | return -ENOMEM; | |
4756 | } | |
4757 | ||
6897dfe8 | 4758 | free_and_replace(c->path, p); |
26fd040d | 4759 | |
130d3d22 | 4760 | return strv_free_and_replace(c->argv, l); |
26fd040d LP |
4761 | } |
4762 | ||
86b23b07 | 4763 | int exec_command_append(ExecCommand *c, const char *path, ...) { |
e63ff941 | 4764 | _cleanup_strv_free_ char **l = NULL; |
86b23b07 | 4765 | va_list ap; |
86b23b07 JS |
4766 | int r; |
4767 | ||
4768 | assert(c); | |
4769 | assert(path); | |
4770 | ||
4771 | va_start(ap, path); | |
4772 | l = strv_new_ap(path, ap); | |
4773 | va_end(ap); | |
4774 | ||
4775 | if (!l) | |
4776 | return -ENOMEM; | |
4777 | ||
e287086b | 4778 | r = strv_extend_strv(&c->argv, l, false); |
e63ff941 | 4779 | if (r < 0) |
86b23b07 | 4780 | return r; |
86b23b07 JS |
4781 | |
4782 | return 0; | |
4783 | } | |
4784 | ||
e8a565cb YW |
4785 | static void *remove_tmpdir_thread(void *p) { |
4786 | _cleanup_free_ char *path = p; | |
86b23b07 | 4787 | |
e8a565cb YW |
4788 | (void) rm_rf(path, REMOVE_ROOT|REMOVE_PHYSICAL); |
4789 | return NULL; | |
4790 | } | |
4791 | ||
4792 | static ExecRuntime* exec_runtime_free(ExecRuntime *rt, bool destroy) { | |
4793 | int r; | |
4794 | ||
4795 | if (!rt) | |
4796 | return NULL; | |
4797 | ||
4798 | if (rt->manager) | |
4799 | (void) hashmap_remove(rt->manager->exec_runtime_by_id, rt->id); | |
4800 | ||
4801 | /* When destroy is true, then rm_rf tmp_dir and var_tmp_dir. */ | |
4802 | if (destroy && rt->tmp_dir) { | |
4803 | log_debug("Spawning thread to nuke %s", rt->tmp_dir); | |
4804 | ||
4805 | r = asynchronous_job(remove_tmpdir_thread, rt->tmp_dir); | |
4806 | if (r < 0) { | |
4807 | log_warning_errno(r, "Failed to nuke %s: %m", rt->tmp_dir); | |
4808 | free(rt->tmp_dir); | |
4809 | } | |
4810 | ||
4811 | rt->tmp_dir = NULL; | |
4812 | } | |
613b411c | 4813 | |
e8a565cb YW |
4814 | if (destroy && rt->var_tmp_dir) { |
4815 | log_debug("Spawning thread to nuke %s", rt->var_tmp_dir); | |
4816 | ||
4817 | r = asynchronous_job(remove_tmpdir_thread, rt->var_tmp_dir); | |
4818 | if (r < 0) { | |
4819 | log_warning_errno(r, "Failed to nuke %s: %m", rt->var_tmp_dir); | |
4820 | free(rt->var_tmp_dir); | |
4821 | } | |
4822 | ||
4823 | rt->var_tmp_dir = NULL; | |
4824 | } | |
4825 | ||
4826 | rt->id = mfree(rt->id); | |
4827 | rt->tmp_dir = mfree(rt->tmp_dir); | |
4828 | rt->var_tmp_dir = mfree(rt->var_tmp_dir); | |
4829 | safe_close_pair(rt->netns_storage_socket); | |
4830 | return mfree(rt); | |
4831 | } | |
4832 | ||
4833 | static void exec_runtime_freep(ExecRuntime **rt) { | |
613b411c | 4834 | if (*rt) |
e8a565cb YW |
4835 | (void) exec_runtime_free(*rt, false); |
4836 | } | |
4837 | ||
4838 | static int exec_runtime_allocate(ExecRuntime **rt) { | |
4839 | assert(rt); | |
613b411c LP |
4840 | |
4841 | *rt = new0(ExecRuntime, 1); | |
f146f5e1 | 4842 | if (!*rt) |
613b411c LP |
4843 | return -ENOMEM; |
4844 | ||
613b411c | 4845 | (*rt)->netns_storage_socket[0] = (*rt)->netns_storage_socket[1] = -1; |
613b411c LP |
4846 | return 0; |
4847 | } | |
4848 | ||
e8a565cb YW |
4849 | static int exec_runtime_add( |
4850 | Manager *m, | |
4851 | const char *id, | |
4852 | const char *tmp_dir, | |
4853 | const char *var_tmp_dir, | |
4854 | const int netns_storage_socket[2], | |
4855 | ExecRuntime **ret) { | |
4856 | ||
4857 | _cleanup_(exec_runtime_freep) ExecRuntime *rt = NULL; | |
613b411c LP |
4858 | int r; |
4859 | ||
e8a565cb | 4860 | assert(m); |
613b411c LP |
4861 | assert(id); |
4862 | ||
e8a565cb YW |
4863 | r = hashmap_ensure_allocated(&m->exec_runtime_by_id, &string_hash_ops); |
4864 | if (r < 0) | |
4865 | return r; | |
613b411c | 4866 | |
e8a565cb | 4867 | r = exec_runtime_allocate(&rt); |
613b411c LP |
4868 | if (r < 0) |
4869 | return r; | |
4870 | ||
e8a565cb YW |
4871 | rt->id = strdup(id); |
4872 | if (!rt->id) | |
4873 | return -ENOMEM; | |
4874 | ||
4875 | if (tmp_dir) { | |
4876 | rt->tmp_dir = strdup(tmp_dir); | |
4877 | if (!rt->tmp_dir) | |
4878 | return -ENOMEM; | |
4879 | ||
4880 | /* When tmp_dir is set, then we require var_tmp_dir is also set. */ | |
4881 | assert(var_tmp_dir); | |
4882 | rt->var_tmp_dir = strdup(var_tmp_dir); | |
4883 | if (!rt->var_tmp_dir) | |
4884 | return -ENOMEM; | |
4885 | } | |
4886 | ||
4887 | if (netns_storage_socket) { | |
4888 | rt->netns_storage_socket[0] = netns_storage_socket[0]; | |
4889 | rt->netns_storage_socket[1] = netns_storage_socket[1]; | |
613b411c LP |
4890 | } |
4891 | ||
e8a565cb YW |
4892 | r = hashmap_put(m->exec_runtime_by_id, rt->id, rt); |
4893 | if (r < 0) | |
4894 | return r; | |
4895 | ||
4896 | rt->manager = m; | |
4897 | ||
4898 | if (ret) | |
4899 | *ret = rt; | |
4900 | ||
4901 | /* do not remove created ExecRuntime object when the operation succeeds. */ | |
4902 | rt = NULL; | |
4903 | return 0; | |
4904 | } | |
4905 | ||
4906 | static int exec_runtime_make(Manager *m, const ExecContext *c, const char *id, ExecRuntime **ret) { | |
4907 | _cleanup_free_ char *tmp_dir = NULL, *var_tmp_dir = NULL; | |
4908 | _cleanup_close_pair_ int netns_storage_socket[2] = {-1, -1}; | |
4909 | int r; | |
4910 | ||
4911 | assert(m); | |
4912 | assert(c); | |
4913 | assert(id); | |
4914 | ||
4915 | /* It is not necessary to create ExecRuntime object. */ | |
4916 | if (!c->private_network && !c->private_tmp) | |
4917 | return 0; | |
4918 | ||
4919 | if (c->private_tmp) { | |
4920 | r = setup_tmp_dirs(id, &tmp_dir, &var_tmp_dir); | |
613b411c LP |
4921 | if (r < 0) |
4922 | return r; | |
4923 | } | |
4924 | ||
e8a565cb YW |
4925 | if (c->private_network) { |
4926 | if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, netns_storage_socket) < 0) | |
4927 | return -errno; | |
4928 | } | |
4929 | ||
4930 | r = exec_runtime_add(m, id, tmp_dir, var_tmp_dir, netns_storage_socket, ret); | |
4931 | if (r < 0) | |
4932 | return r; | |
4933 | ||
4934 | /* Avoid cleanup */ | |
4935 | netns_storage_socket[0] = -1; | |
4936 | netns_storage_socket[1] = -1; | |
613b411c LP |
4937 | return 1; |
4938 | } | |
4939 | ||
e8a565cb YW |
4940 | int exec_runtime_acquire(Manager *m, const ExecContext *c, const char *id, bool create, ExecRuntime **ret) { |
4941 | ExecRuntime *rt; | |
4942 | int r; | |
613b411c | 4943 | |
e8a565cb YW |
4944 | assert(m); |
4945 | assert(id); | |
4946 | assert(ret); | |
4947 | ||
4948 | rt = hashmap_get(m->exec_runtime_by_id, id); | |
4949 | if (rt) | |
4950 | /* We already have a ExecRuntime object, let's increase the ref count and reuse it */ | |
4951 | goto ref; | |
4952 | ||
4953 | if (!create) | |
4954 | return 0; | |
4955 | ||
4956 | /* If not found, then create a new object. */ | |
4957 | r = exec_runtime_make(m, c, id, &rt); | |
4958 | if (r <= 0) | |
4959 | /* When r == 0, it is not necessary to create ExecRuntime object. */ | |
4960 | return r; | |
613b411c | 4961 | |
e8a565cb YW |
4962 | ref: |
4963 | /* increment reference counter. */ | |
4964 | rt->n_ref++; | |
4965 | *ret = rt; | |
4966 | return 1; | |
4967 | } | |
613b411c | 4968 | |
e8a565cb YW |
4969 | ExecRuntime *exec_runtime_unref(ExecRuntime *rt, bool destroy) { |
4970 | if (!rt) | |
613b411c LP |
4971 | return NULL; |
4972 | ||
e8a565cb | 4973 | assert(rt->n_ref > 0); |
613b411c | 4974 | |
e8a565cb YW |
4975 | rt->n_ref--; |
4976 | if (rt->n_ref > 0) | |
f2341e0a LP |
4977 | return NULL; |
4978 | ||
e8a565cb | 4979 | return exec_runtime_free(rt, destroy); |
613b411c LP |
4980 | } |
4981 | ||
e8a565cb YW |
4982 | int exec_runtime_serialize(const Manager *m, FILE *f, FDSet *fds) { |
4983 | ExecRuntime *rt; | |
4984 | Iterator i; | |
4985 | ||
4986 | assert(m); | |
613b411c LP |
4987 | assert(f); |
4988 | assert(fds); | |
4989 | ||
e8a565cb YW |
4990 | HASHMAP_FOREACH(rt, m->exec_runtime_by_id, i) { |
4991 | fprintf(f, "exec-runtime=%s", rt->id); | |
613b411c | 4992 | |
e8a565cb YW |
4993 | if (rt->tmp_dir) |
4994 | fprintf(f, " tmp-dir=%s", rt->tmp_dir); | |
613b411c | 4995 | |
e8a565cb YW |
4996 | if (rt->var_tmp_dir) |
4997 | fprintf(f, " var-tmp-dir=%s", rt->var_tmp_dir); | |
613b411c | 4998 | |
e8a565cb YW |
4999 | if (rt->netns_storage_socket[0] >= 0) { |
5000 | int copy; | |
613b411c | 5001 | |
e8a565cb YW |
5002 | copy = fdset_put_dup(fds, rt->netns_storage_socket[0]); |
5003 | if (copy < 0) | |
5004 | return copy; | |
613b411c | 5005 | |
e8a565cb YW |
5006 | fprintf(f, " netns-socket-0=%i", copy); |
5007 | } | |
613b411c | 5008 | |
e8a565cb YW |
5009 | if (rt->netns_storage_socket[1] >= 0) { |
5010 | int copy; | |
613b411c | 5011 | |
e8a565cb YW |
5012 | copy = fdset_put_dup(fds, rt->netns_storage_socket[1]); |
5013 | if (copy < 0) | |
5014 | return copy; | |
613b411c | 5015 | |
e8a565cb YW |
5016 | fprintf(f, " netns-socket-1=%i", copy); |
5017 | } | |
5018 | ||
5019 | fputc('\n', f); | |
613b411c LP |
5020 | } |
5021 | ||
5022 | return 0; | |
5023 | } | |
5024 | ||
e8a565cb YW |
5025 | int exec_runtime_deserialize_compat(Unit *u, const char *key, const char *value, FDSet *fds) { |
5026 | _cleanup_(exec_runtime_freep) ExecRuntime *rt_create = NULL; | |
5027 | ExecRuntime *rt; | |
613b411c LP |
5028 | int r; |
5029 | ||
e8a565cb YW |
5030 | /* This is for the migration from old (v237 or earlier) deserialization text. |
5031 | * Due to the bug #7790, this may not work with the units that use JoinsNamespaceOf=. | |
5032 | * Even if the ExecRuntime object originally created by the other unit, we cannot judge | |
5033 | * so or not from the serialized text, then we always creates a new object owned by this. */ | |
5034 | ||
5035 | assert(u); | |
613b411c LP |
5036 | assert(key); |
5037 | assert(value); | |
5038 | ||
e8a565cb YW |
5039 | /* Manager manages ExecRuntime objects by the unit id. |
5040 | * So, we omit the serialized text when the unit does not have id (yet?)... */ | |
5041 | if (isempty(u->id)) { | |
5042 | log_unit_debug(u, "Invocation ID not found. Dropping runtime parameter."); | |
5043 | return 0; | |
5044 | } | |
613b411c | 5045 | |
e8a565cb YW |
5046 | r = hashmap_ensure_allocated(&u->manager->exec_runtime_by_id, &string_hash_ops); |
5047 | if (r < 0) { | |
5048 | log_unit_debug_errno(u, r, "Failed to allocate storage for runtime parameter: %m"); | |
5049 | return 0; | |
5050 | } | |
5051 | ||
5052 | rt = hashmap_get(u->manager->exec_runtime_by_id, u->id); | |
5053 | if (!rt) { | |
5054 | r = exec_runtime_allocate(&rt_create); | |
613b411c | 5055 | if (r < 0) |
f2341e0a | 5056 | return log_oom(); |
613b411c | 5057 | |
e8a565cb YW |
5058 | rt_create->id = strdup(u->id); |
5059 | if (!rt_create->id) | |
5060 | return log_oom(); | |
5061 | ||
5062 | rt = rt_create; | |
5063 | } | |
5064 | ||
5065 | if (streq(key, "tmp-dir")) { | |
5066 | char *copy; | |
5067 | ||
613b411c LP |
5068 | copy = strdup(value); |
5069 | if (!copy) | |
5070 | return log_oom(); | |
5071 | ||
e8a565cb | 5072 | free_and_replace(rt->tmp_dir, copy); |
613b411c LP |
5073 | |
5074 | } else if (streq(key, "var-tmp-dir")) { | |
5075 | char *copy; | |
5076 | ||
613b411c LP |
5077 | copy = strdup(value); |
5078 | if (!copy) | |
5079 | return log_oom(); | |
5080 | ||
e8a565cb | 5081 | free_and_replace(rt->var_tmp_dir, copy); |
613b411c LP |
5082 | |
5083 | } else if (streq(key, "netns-socket-0")) { | |
5084 | int fd; | |
5085 | ||
e8a565cb | 5086 | if (safe_atoi(value, &fd) < 0 || !fdset_contains(fds, fd)) { |
f2341e0a | 5087 | log_unit_debug(u, "Failed to parse netns socket value: %s", value); |
e8a565cb | 5088 | return 0; |
613b411c | 5089 | } |
e8a565cb YW |
5090 | |
5091 | safe_close(rt->netns_storage_socket[0]); | |
5092 | rt->netns_storage_socket[0] = fdset_remove(fds, fd); | |
5093 | ||
613b411c LP |
5094 | } else if (streq(key, "netns-socket-1")) { |
5095 | int fd; | |
5096 | ||
e8a565cb | 5097 | if (safe_atoi(value, &fd) < 0 || !fdset_contains(fds, fd)) { |
f2341e0a | 5098 | log_unit_debug(u, "Failed to parse netns socket value: %s", value); |
e8a565cb | 5099 | return 0; |
613b411c | 5100 | } |
e8a565cb YW |
5101 | |
5102 | safe_close(rt->netns_storage_socket[1]); | |
5103 | rt->netns_storage_socket[1] = fdset_remove(fds, fd); | |
613b411c LP |
5104 | } else |
5105 | return 0; | |
5106 | ||
e8a565cb YW |
5107 | /* If the object is newly created, then put it to the hashmap which manages ExecRuntime objects. */ |
5108 | if (rt_create) { | |
5109 | r = hashmap_put(u->manager->exec_runtime_by_id, rt_create->id, rt_create); | |
5110 | if (r < 0) { | |
3fe91079 | 5111 | log_unit_debug_errno(u, r, "Failed to put runtime parameter to manager's storage: %m"); |
e8a565cb YW |
5112 | return 0; |
5113 | } | |
613b411c | 5114 | |
e8a565cb | 5115 | rt_create->manager = u->manager; |
613b411c | 5116 | |
e8a565cb YW |
5117 | /* Avoid cleanup */ |
5118 | rt_create = NULL; | |
5119 | } | |
98b47d54 | 5120 | |
e8a565cb YW |
5121 | return 1; |
5122 | } | |
613b411c | 5123 | |
e8a565cb YW |
5124 | void exec_runtime_deserialize_one(Manager *m, const char *value, FDSet *fds) { |
5125 | char *id = NULL, *tmp_dir = NULL, *var_tmp_dir = NULL; | |
5126 | int r, fd0 = -1, fd1 = -1; | |
5127 | const char *p, *v = value; | |
5128 | size_t n; | |
613b411c | 5129 | |
e8a565cb YW |
5130 | assert(m); |
5131 | assert(value); | |
5132 | assert(fds); | |
98b47d54 | 5133 | |
e8a565cb YW |
5134 | n = strcspn(v, " "); |
5135 | id = strndupa(v, n); | |
5136 | if (v[n] != ' ') | |
5137 | goto finalize; | |
5138 | p = v + n + 1; | |
5139 | ||
5140 | v = startswith(p, "tmp-dir="); | |
5141 | if (v) { | |
5142 | n = strcspn(v, " "); | |
5143 | tmp_dir = strndupa(v, n); | |
5144 | if (v[n] != ' ') | |
5145 | goto finalize; | |
5146 | p = v + n + 1; | |
5147 | } | |
5148 | ||
5149 | v = startswith(p, "var-tmp-dir="); | |
5150 | if (v) { | |
5151 | n = strcspn(v, " "); | |
5152 | var_tmp_dir = strndupa(v, n); | |
5153 | if (v[n] != ' ') | |
5154 | goto finalize; | |
5155 | p = v + n + 1; | |
5156 | } | |
5157 | ||
5158 | v = startswith(p, "netns-socket-0="); | |
5159 | if (v) { | |
5160 | char *buf; | |
5161 | ||
5162 | n = strcspn(v, " "); | |
5163 | buf = strndupa(v, n); | |
5164 | if (safe_atoi(buf, &fd0) < 0 || !fdset_contains(fds, fd0)) { | |
5165 | log_debug("Unable to process exec-runtime netns fd specification."); | |
5166 | return; | |
98b47d54 | 5167 | } |
e8a565cb YW |
5168 | fd0 = fdset_remove(fds, fd0); |
5169 | if (v[n] != ' ') | |
5170 | goto finalize; | |
5171 | p = v + n + 1; | |
613b411c LP |
5172 | } |
5173 | ||
e8a565cb YW |
5174 | v = startswith(p, "netns-socket-1="); |
5175 | if (v) { | |
5176 | char *buf; | |
98b47d54 | 5177 | |
e8a565cb YW |
5178 | n = strcspn(v, " "); |
5179 | buf = strndupa(v, n); | |
5180 | if (safe_atoi(buf, &fd1) < 0 || !fdset_contains(fds, fd1)) { | |
5181 | log_debug("Unable to process exec-runtime netns fd specification."); | |
5182 | return; | |
98b47d54 | 5183 | } |
e8a565cb YW |
5184 | fd1 = fdset_remove(fds, fd1); |
5185 | } | |
98b47d54 | 5186 | |
e8a565cb YW |
5187 | finalize: |
5188 | ||
5189 | r = exec_runtime_add(m, id, tmp_dir, var_tmp_dir, (int[]) { fd0, fd1 }, NULL); | |
7d853ca6 | 5190 | if (r < 0) |
e8a565cb | 5191 | log_debug_errno(r, "Failed to add exec-runtime: %m"); |
e8a565cb | 5192 | } |
613b411c | 5193 | |
e8a565cb YW |
5194 | void exec_runtime_vacuum(Manager *m) { |
5195 | ExecRuntime *rt; | |
5196 | Iterator i; | |
5197 | ||
5198 | assert(m); | |
5199 | ||
5200 | /* Free unreferenced ExecRuntime objects. This is used after manager deserialization process. */ | |
5201 | ||
5202 | HASHMAP_FOREACH(rt, m->exec_runtime_by_id, i) { | |
5203 | if (rt->n_ref > 0) | |
5204 | continue; | |
5205 | ||
5206 | (void) exec_runtime_free(rt, false); | |
5207 | } | |
613b411c LP |
5208 | } |
5209 | ||
b9c04eaf YW |
5210 | void exec_params_clear(ExecParameters *p) { |
5211 | if (!p) | |
5212 | return; | |
5213 | ||
5214 | strv_free(p->environment); | |
5215 | } | |
5216 | ||
80876c20 LP |
5217 | static const char* const exec_input_table[_EXEC_INPUT_MAX] = { |
5218 | [EXEC_INPUT_NULL] = "null", | |
5219 | [EXEC_INPUT_TTY] = "tty", | |
5220 | [EXEC_INPUT_TTY_FORCE] = "tty-force", | |
4f2d528d | 5221 | [EXEC_INPUT_TTY_FAIL] = "tty-fail", |
52c239d7 LB |
5222 | [EXEC_INPUT_SOCKET] = "socket", |
5223 | [EXEC_INPUT_NAMED_FD] = "fd", | |
08f3be7a | 5224 | [EXEC_INPUT_DATA] = "data", |
2038c3f5 | 5225 | [EXEC_INPUT_FILE] = "file", |
80876c20 LP |
5226 | }; |
5227 | ||
8a0867d6 LP |
5228 | DEFINE_STRING_TABLE_LOOKUP(exec_input, ExecInput); |
5229 | ||
94f04347 | 5230 | static const char* const exec_output_table[_EXEC_OUTPUT_MAX] = { |
80876c20 | 5231 | [EXEC_OUTPUT_INHERIT] = "inherit", |
94f04347 | 5232 | [EXEC_OUTPUT_NULL] = "null", |
80876c20 | 5233 | [EXEC_OUTPUT_TTY] = "tty", |
94f04347 | 5234 | [EXEC_OUTPUT_SYSLOG] = "syslog", |
28dbc1e8 | 5235 | [EXEC_OUTPUT_SYSLOG_AND_CONSOLE] = "syslog+console", |
9a6bca7a | 5236 | [EXEC_OUTPUT_KMSG] = "kmsg", |
28dbc1e8 | 5237 | [EXEC_OUTPUT_KMSG_AND_CONSOLE] = "kmsg+console", |
706343f4 LP |
5238 | [EXEC_OUTPUT_JOURNAL] = "journal", |
5239 | [EXEC_OUTPUT_JOURNAL_AND_CONSOLE] = "journal+console", | |
52c239d7 LB |
5240 | [EXEC_OUTPUT_SOCKET] = "socket", |
5241 | [EXEC_OUTPUT_NAMED_FD] = "fd", | |
2038c3f5 | 5242 | [EXEC_OUTPUT_FILE] = "file", |
566b7d23 | 5243 | [EXEC_OUTPUT_FILE_APPEND] = "append", |
94f04347 LP |
5244 | }; |
5245 | ||
5246 | DEFINE_STRING_TABLE_LOOKUP(exec_output, ExecOutput); | |
023a4f67 LP |
5247 | |
5248 | static const char* const exec_utmp_mode_table[_EXEC_UTMP_MODE_MAX] = { | |
5249 | [EXEC_UTMP_INIT] = "init", | |
5250 | [EXEC_UTMP_LOGIN] = "login", | |
5251 | [EXEC_UTMP_USER] = "user", | |
5252 | }; | |
5253 | ||
5254 | DEFINE_STRING_TABLE_LOOKUP(exec_utmp_mode, ExecUtmpMode); | |
53f47dfc YW |
5255 | |
5256 | static const char* const exec_preserve_mode_table[_EXEC_PRESERVE_MODE_MAX] = { | |
5257 | [EXEC_PRESERVE_NO] = "no", | |
5258 | [EXEC_PRESERVE_YES] = "yes", | |
5259 | [EXEC_PRESERVE_RESTART] = "restart", | |
5260 | }; | |
5261 | ||
5262 | DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(exec_preserve_mode, ExecPreserveMode, EXEC_PRESERVE_YES); | |
3536f49e | 5263 | |
72fd1768 | 5264 | static const char* const exec_directory_type_table[_EXEC_DIRECTORY_TYPE_MAX] = { |
3536f49e YW |
5265 | [EXEC_DIRECTORY_RUNTIME] = "RuntimeDirectory", |
5266 | [EXEC_DIRECTORY_STATE] = "StateDirectory", | |
5267 | [EXEC_DIRECTORY_CACHE] = "CacheDirectory", | |
5268 | [EXEC_DIRECTORY_LOGS] = "LogsDirectory", | |
5269 | [EXEC_DIRECTORY_CONFIGURATION] = "ConfigurationDirectory", | |
5270 | }; | |
5271 | ||
5272 | DEFINE_STRING_TABLE_LOOKUP(exec_directory_type, ExecDirectoryType); | |
b1edf445 | 5273 | |
fb2042dd YW |
5274 | static const char* const exec_directory_env_name_table[_EXEC_DIRECTORY_TYPE_MAX] = { |
5275 | [EXEC_DIRECTORY_RUNTIME] = "RUNTIME_DIRECTORY", | |
5276 | [EXEC_DIRECTORY_STATE] = "STATE_DIRECTORY", | |
5277 | [EXEC_DIRECTORY_CACHE] = "CACHE_DIRECTORY", | |
5278 | [EXEC_DIRECTORY_LOGS] = "LOGS_DIRECTORY", | |
5279 | [EXEC_DIRECTORY_CONFIGURATION] = "CONFIGURATION_DIRECTORY", | |
5280 | }; | |
5281 | ||
5282 | DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(exec_directory_env_name, ExecDirectoryType); | |
5283 | ||
b1edf445 LP |
5284 | static const char* const exec_keyring_mode_table[_EXEC_KEYRING_MODE_MAX] = { |
5285 | [EXEC_KEYRING_INHERIT] = "inherit", | |
5286 | [EXEC_KEYRING_PRIVATE] = "private", | |
5287 | [EXEC_KEYRING_SHARED] = "shared", | |
5288 | }; | |
5289 | ||
5290 | DEFINE_STRING_TABLE_LOOKUP(exec_keyring_mode, ExecKeyringMode); |