]>
Commit | Line | Data |
---|---|---|
db9ecf05 | 1 | /* SPDX-License-Identifier: LGPL-2.1-or-later */ |
a7334b09 | 2 | |
034c6ed7 LP |
3 | #include <errno.h> |
4 | #include <fcntl.h> | |
8dd4c05b | 5 | #include <poll.h> |
d251207d | 6 | #include <sys/eventfd.h> |
f5947a5e | 7 | #include <sys/ioctl.h> |
f3e43635 | 8 | #include <sys/mman.h> |
bb0c0d6f | 9 | #include <sys/mount.h> |
8dd4c05b | 10 | #include <sys/personality.h> |
94f04347 | 11 | #include <sys/prctl.h> |
d2ffa389 | 12 | #include <sys/shm.h> |
d2ffa389 | 13 | #include <sys/types.h> |
8dd4c05b LP |
14 | #include <sys/un.h> |
15 | #include <unistd.h> | |
023a4f67 | 16 | #include <utmpx.h> |
5cb5a6ff | 17 | |
349cc4a5 | 18 | #if HAVE_PAM |
5b6319dc LP |
19 | #include <security/pam_appl.h> |
20 | #endif | |
21 | ||
349cc4a5 | 22 | #if HAVE_SELINUX |
7b52a628 MS |
23 | #include <selinux/selinux.h> |
24 | #endif | |
25 | ||
349cc4a5 | 26 | #if HAVE_SECCOMP |
17df7223 LP |
27 | #include <seccomp.h> |
28 | #endif | |
29 | ||
349cc4a5 | 30 | #if HAVE_APPARMOR |
eef65bf3 MS |
31 | #include <sys/apparmor.h> |
32 | #endif | |
33 | ||
24882e06 | 34 | #include "sd-messages.h" |
8dd4c05b | 35 | |
bb0c0d6f | 36 | #include "acl-util.h" |
8dd4c05b | 37 | #include "af-list.h" |
b5efdb8a | 38 | #include "alloc-util.h" |
349cc4a5 | 39 | #if HAVE_APPARMOR |
3ffd4af2 LP |
40 | #include "apparmor-util.h" |
41 | #endif | |
8dd4c05b LP |
42 | #include "async.h" |
43 | #include "barrier.h" | |
8dd4c05b | 44 | #include "cap-list.h" |
430f0182 | 45 | #include "capability-util.h" |
fdb3deca | 46 | #include "cgroup-setup.h" |
bb0c0d6f | 47 | #include "chown-recursive.h" |
da681e1b | 48 | #include "cpu-set-util.h" |
f6a6225e | 49 | #include "def.h" |
686d13b9 | 50 | #include "env-file.h" |
4d1a6904 | 51 | #include "env-util.h" |
17df7223 | 52 | #include "errno-list.h" |
3ffd4af2 | 53 | #include "execute.h" |
8dd4c05b | 54 | #include "exit-status.h" |
3ffd4af2 | 55 | #include "fd-util.h" |
bb0c0d6f | 56 | #include "fileio.h" |
f97b34a6 | 57 | #include "format-util.h" |
f4f15635 | 58 | #include "fs-util.h" |
7d50b32a | 59 | #include "glob-util.h" |
0389f4fa | 60 | #include "hexdecoct.h" |
c004493c | 61 | #include "io-util.h" |
8dd4c05b | 62 | #include "ioprio.h" |
a1164ae3 | 63 | #include "label.h" |
8dd4c05b LP |
64 | #include "log.h" |
65 | #include "macro.h" | |
e8a565cb | 66 | #include "manager.h" |
0a970718 | 67 | #include "memory-util.h" |
f5947a5e | 68 | #include "missing_fs.h" |
8dd4c05b | 69 | #include "mkdir.h" |
21935150 | 70 | #include "mount-util.h" |
bb0c0d6f | 71 | #include "mountpoint-util.h" |
8dd4c05b | 72 | #include "namespace.h" |
6bedfcbb | 73 | #include "parse-util.h" |
8dd4c05b | 74 | #include "path-util.h" |
0b452006 | 75 | #include "process-util.h" |
d3dcf4e3 | 76 | #include "random-util.h" |
78f22b97 | 77 | #include "rlimit-util.h" |
8dd4c05b | 78 | #include "rm-rf.h" |
349cc4a5 | 79 | #if HAVE_SECCOMP |
3ffd4af2 LP |
80 | #include "seccomp-util.h" |
81 | #endif | |
07d46372 | 82 | #include "securebits-util.h" |
8dd4c05b | 83 | #include "selinux-util.h" |
24882e06 | 84 | #include "signal-util.h" |
8dd4c05b | 85 | #include "smack-util.h" |
57b7a260 | 86 | #include "socket-util.h" |
fd63e712 | 87 | #include "special.h" |
949befd3 | 88 | #include "stat-util.h" |
8b43440b | 89 | #include "string-table.h" |
07630cea | 90 | #include "string-util.h" |
8dd4c05b | 91 | #include "strv.h" |
7ccbd1ae | 92 | #include "syslog-util.h" |
8dd4c05b | 93 | #include "terminal-util.h" |
bb0c0d6f | 94 | #include "tmpfile-util.h" |
566b7d23 | 95 | #include "umask-util.h" |
2d3b784d | 96 | #include "unit-serialize.h" |
b1d4f8e1 | 97 | #include "user-util.h" |
8dd4c05b | 98 | #include "utmp-wtmp.h" |
5cb5a6ff | 99 | |
e056b01d | 100 | #define IDLE_TIMEOUT_USEC (5*USEC_PER_SEC) |
31a7eb86 | 101 | #define IDLE_TIMEOUT2_USEC (1*USEC_PER_SEC) |
e6a26745 | 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 | if (n_fds <= 0) |
107 | return 0; | |
108 | ||
a0d40ac5 LP |
109 | /* Modifies the fds array! (sorts it) */ |
110 | ||
034c6ed7 LP |
111 | assert(fds); |
112 | ||
5b10116e ZJS |
113 | for (int start = 0;;) { |
114 | int restart_from = -1; | |
034c6ed7 | 115 | |
5b10116e | 116 | for (int i = start; i < (int) n_fds; i++) { |
034c6ed7 LP |
117 | int nfd; |
118 | ||
119 | /* Already at right index? */ | |
120 | if (fds[i] == i+3) | |
121 | continue; | |
122 | ||
3cc2aff1 LP |
123 | nfd = fcntl(fds[i], F_DUPFD, i + 3); |
124 | if (nfd < 0) | |
034c6ed7 LP |
125 | return -errno; |
126 | ||
03e334a1 | 127 | safe_close(fds[i]); |
034c6ed7 LP |
128 | fds[i] = nfd; |
129 | ||
130 | /* Hmm, the fd we wanted isn't free? Then | |
ee33e53a | 131 | * let's remember that and try again from here */ |
034c6ed7 LP |
132 | if (nfd != i+3 && restart_from < 0) |
133 | restart_from = i; | |
134 | } | |
135 | ||
136 | if (restart_from < 0) | |
137 | break; | |
138 | ||
139 | start = restart_from; | |
140 | } | |
141 | ||
142 | return 0; | |
143 | } | |
144 | ||
25b583d7 | 145 | static int flags_fds(const int fds[], size_t n_socket_fds, size_t n_storage_fds, bool nonblock) { |
5b10116e | 146 | size_t n_fds; |
e2c76839 | 147 | int r; |
47a71eed | 148 | |
25b583d7 | 149 | n_fds = n_socket_fds + n_storage_fds; |
47a71eed LP |
150 | if (n_fds <= 0) |
151 | return 0; | |
152 | ||
153 | assert(fds); | |
154 | ||
9b141911 FB |
155 | /* Drops/Sets O_NONBLOCK and FD_CLOEXEC from the file flags. |
156 | * O_NONBLOCK only applies to socket activation though. */ | |
47a71eed | 157 | |
5b10116e | 158 | for (size_t i = 0; i < n_fds; i++) { |
47a71eed | 159 | |
9b141911 FB |
160 | if (i < n_socket_fds) { |
161 | r = fd_nonblock(fds[i], nonblock); | |
162 | if (r < 0) | |
163 | return r; | |
164 | } | |
47a71eed | 165 | |
451a074f LP |
166 | /* We unconditionally drop FD_CLOEXEC from the fds, |
167 | * since after all we want to pass these fds to our | |
168 | * children */ | |
47a71eed | 169 | |
3cc2aff1 LP |
170 | r = fd_cloexec(fds[i], false); |
171 | if (r < 0) | |
e2c76839 | 172 | return r; |
47a71eed LP |
173 | } |
174 | ||
175 | return 0; | |
176 | } | |
177 | ||
1e22b5cd | 178 | static const char *exec_context_tty_path(const ExecContext *context) { |
80876c20 LP |
179 | assert(context); |
180 | ||
1e22b5cd LP |
181 | if (context->stdio_as_fds) |
182 | return NULL; | |
183 | ||
80876c20 LP |
184 | if (context->tty_path) |
185 | return context->tty_path; | |
186 | ||
187 | return "/dev/console"; | |
188 | } | |
189 | ||
1e22b5cd LP |
190 | static void exec_context_tty_reset(const ExecContext *context, const ExecParameters *p) { |
191 | const char *path; | |
192 | ||
6ea832a2 LP |
193 | assert(context); |
194 | ||
1e22b5cd | 195 | path = exec_context_tty_path(context); |
6ea832a2 | 196 | |
1e22b5cd LP |
197 | if (context->tty_vhangup) { |
198 | if (p && p->stdin_fd >= 0) | |
199 | (void) terminal_vhangup_fd(p->stdin_fd); | |
200 | else if (path) | |
201 | (void) terminal_vhangup(path); | |
202 | } | |
6ea832a2 | 203 | |
1e22b5cd LP |
204 | if (context->tty_reset) { |
205 | if (p && p->stdin_fd >= 0) | |
206 | (void) reset_terminal_fd(p->stdin_fd, true); | |
207 | else if (path) | |
208 | (void) reset_terminal(path); | |
209 | } | |
210 | ||
211 | if (context->tty_vt_disallocate && path) | |
212 | (void) vt_disallocate(path); | |
6ea832a2 LP |
213 | } |
214 | ||
6af760f3 LP |
215 | static bool is_terminal_input(ExecInput i) { |
216 | return IN_SET(i, | |
217 | EXEC_INPUT_TTY, | |
218 | EXEC_INPUT_TTY_FORCE, | |
219 | EXEC_INPUT_TTY_FAIL); | |
220 | } | |
221 | ||
3a1286b6 | 222 | static bool is_terminal_output(ExecOutput o) { |
6af760f3 LP |
223 | return IN_SET(o, |
224 | EXEC_OUTPUT_TTY, | |
6af760f3 LP |
225 | EXEC_OUTPUT_KMSG_AND_CONSOLE, |
226 | EXEC_OUTPUT_JOURNAL_AND_CONSOLE); | |
227 | } | |
228 | ||
aac8c0c3 LP |
229 | static bool is_kmsg_output(ExecOutput o) { |
230 | return IN_SET(o, | |
231 | EXEC_OUTPUT_KMSG, | |
232 | EXEC_OUTPUT_KMSG_AND_CONSOLE); | |
233 | } | |
234 | ||
6af760f3 LP |
235 | static bool exec_context_needs_term(const ExecContext *c) { |
236 | assert(c); | |
237 | ||
238 | /* Return true if the execution context suggests we should set $TERM to something useful. */ | |
239 | ||
240 | if (is_terminal_input(c->std_input)) | |
241 | return true; | |
242 | ||
243 | if (is_terminal_output(c->std_output)) | |
244 | return true; | |
245 | ||
246 | if (is_terminal_output(c->std_error)) | |
247 | return true; | |
248 | ||
249 | return !!c->tty_path; | |
3a1286b6 MS |
250 | } |
251 | ||
80876c20 | 252 | static int open_null_as(int flags, int nfd) { |
046a82c1 | 253 | int fd; |
071830ff | 254 | |
80876c20 | 255 | assert(nfd >= 0); |
071830ff | 256 | |
613b411c LP |
257 | fd = open("/dev/null", flags|O_NOCTTY); |
258 | if (fd < 0) | |
071830ff LP |
259 | return -errno; |
260 | ||
046a82c1 | 261 | return move_fd(fd, nfd, false); |
071830ff LP |
262 | } |
263 | ||
91dd5f7c LP |
264 | static int connect_journal_socket( |
265 | int fd, | |
266 | const char *log_namespace, | |
267 | uid_t uid, | |
268 | gid_t gid) { | |
269 | ||
f36a9d59 ZJS |
270 | union sockaddr_union sa; |
271 | socklen_t sa_len; | |
524daa8c ZJS |
272 | uid_t olduid = UID_INVALID; |
273 | gid_t oldgid = GID_INVALID; | |
91dd5f7c | 274 | const char *j; |
524daa8c ZJS |
275 | int r; |
276 | ||
91dd5f7c LP |
277 | j = log_namespace ? |
278 | strjoina("/run/systemd/journal.", log_namespace, "/stdout") : | |
279 | "/run/systemd/journal/stdout"; | |
280 | r = sockaddr_un_set_path(&sa.un, j); | |
281 | if (r < 0) | |
282 | return r; | |
f36a9d59 | 283 | sa_len = r; |
91dd5f7c | 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 | ||
f36a9d59 | 301 | r = connect(fd, &sa.sa, sa_len) < 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 | |
91dd5f7c | 339 | r = connect_journal_socket(fd, context->log_namespace, uid, gid); |
524daa8c ZJS |
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, | |
f3dc6af2 | 360 | false, |
aac8c0c3 | 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) { |
86fca584 ZJS |
382 | union sockaddr_union sa; |
383 | socklen_t sa_len; | |
15a3e96f | 384 | _cleanup_close_ int fd = -1; |
86fca584 | 385 | int r; |
071830ff | 386 | |
80876c20 | 387 | assert(path); |
071830ff | 388 | |
2038c3f5 LP |
389 | if (IN_SET(flags & O_ACCMODE, O_WRONLY, O_RDWR)) |
390 | flags |= O_CREAT; | |
391 | ||
392 | fd = open(path, flags|O_NOCTTY, mode); | |
393 | if (fd >= 0) | |
15a3e96f | 394 | return TAKE_FD(fd); |
071830ff | 395 | |
2038c3f5 LP |
396 | if (errno != ENXIO) /* ENXIO is returned when we try to open() an AF_UNIX file system socket on Linux */ |
397 | return -errno; | |
2038c3f5 LP |
398 | |
399 | /* So, it appears the specified path could be an AF_UNIX socket. Let's see if we can connect to it. */ | |
400 | ||
86fca584 ZJS |
401 | r = sockaddr_un_set_path(&sa.un, path); |
402 | if (r < 0) | |
403 | return r == -EINVAL ? -ENXIO : r; | |
404 | sa_len = r; | |
405 | ||
2038c3f5 LP |
406 | fd = socket(AF_UNIX, SOCK_STREAM, 0); |
407 | if (fd < 0) | |
408 | return -errno; | |
409 | ||
86fca584 | 410 | if (connect(fd, &sa.sa, sa_len) < 0) |
2038c3f5 | 411 | return errno == EINVAL ? -ENXIO : -errno; /* Propagate initial error if we get EINVAL, i.e. we have |
e8607daf | 412 | * indication that this 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 | |
86fca584 | 419 | r = 0; |
15a3e96f | 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 | ||
7966a916 | 449 | static int fixup_output(ExecOutput output, int socket_fd) { |
4f2d528d | 450 | |
7966a916 | 451 | if (output == EXEC_OUTPUT_SOCKET && socket_fd < 0) |
4f2d528d LP |
452 | return EXEC_OUTPUT_INHERIT; |
453 | ||
7966a916 | 454 | return output; |
4f2d528d LP |
455 | } |
456 | ||
a34ceba6 LP |
457 | static int setup_input( |
458 | const ExecContext *context, | |
459 | const ExecParameters *params, | |
52c239d7 | 460 | int socket_fd, |
2caa38e9 | 461 | const int named_iofds[static 3]) { |
a34ceba6 | 462 | |
4f2d528d LP |
463 | ExecInput i; |
464 | ||
465 | assert(context); | |
a34ceba6 | 466 | assert(params); |
2caa38e9 | 467 | assert(named_iofds); |
a34ceba6 LP |
468 | |
469 | if (params->stdin_fd >= 0) { | |
470 | if (dup2(params->stdin_fd, STDIN_FILENO) < 0) | |
471 | return -errno; | |
472 | ||
473 | /* Try to make this the controlling tty, if it is a tty, and reset it */ | |
1fb0682e LP |
474 | if (isatty(STDIN_FILENO)) { |
475 | (void) ioctl(STDIN_FILENO, TIOCSCTTY, context->std_input == EXEC_INPUT_TTY_FORCE); | |
476 | (void) reset_terminal_fd(STDIN_FILENO, true); | |
477 | } | |
a34ceba6 LP |
478 | |
479 | return STDIN_FILENO; | |
480 | } | |
4f2d528d | 481 | |
08f3be7a | 482 | i = fixup_input(context, socket_fd, params->flags & EXEC_APPLY_TTY_STDIN); |
4f2d528d LP |
483 | |
484 | switch (i) { | |
071830ff | 485 | |
80876c20 LP |
486 | case EXEC_INPUT_NULL: |
487 | return open_null_as(O_RDONLY, STDIN_FILENO); | |
488 | ||
489 | case EXEC_INPUT_TTY: | |
490 | case EXEC_INPUT_TTY_FORCE: | |
491 | case EXEC_INPUT_TTY_FAIL: { | |
046a82c1 | 492 | int fd; |
071830ff | 493 | |
1e22b5cd | 494 | fd = acquire_terminal(exec_context_tty_path(context), |
8854d795 LP |
495 | i == EXEC_INPUT_TTY_FAIL ? ACQUIRE_TERMINAL_TRY : |
496 | i == EXEC_INPUT_TTY_FORCE ? ACQUIRE_TERMINAL_FORCE : | |
497 | ACQUIRE_TERMINAL_WAIT, | |
3a43da28 | 498 | USEC_INFINITY); |
970edce6 | 499 | if (fd < 0) |
80876c20 LP |
500 | return fd; |
501 | ||
046a82c1 | 502 | return move_fd(fd, STDIN_FILENO, false); |
80876c20 LP |
503 | } |
504 | ||
4f2d528d | 505 | case EXEC_INPUT_SOCKET: |
e75a9ed1 LP |
506 | assert(socket_fd >= 0); |
507 | ||
4f2d528d LP |
508 | return dup2(socket_fd, STDIN_FILENO) < 0 ? -errno : STDIN_FILENO; |
509 | ||
52c239d7 | 510 | case EXEC_INPUT_NAMED_FD: |
e75a9ed1 LP |
511 | assert(named_iofds[STDIN_FILENO] >= 0); |
512 | ||
52c239d7 LB |
513 | (void) fd_nonblock(named_iofds[STDIN_FILENO], false); |
514 | return dup2(named_iofds[STDIN_FILENO], STDIN_FILENO) < 0 ? -errno : STDIN_FILENO; | |
515 | ||
08f3be7a LP |
516 | case EXEC_INPUT_DATA: { |
517 | int fd; | |
518 | ||
519 | fd = acquire_data_fd(context->stdin_data, context->stdin_data_size, 0); | |
520 | if (fd < 0) | |
521 | return fd; | |
522 | ||
523 | return move_fd(fd, STDIN_FILENO, false); | |
524 | } | |
525 | ||
2038c3f5 LP |
526 | case EXEC_INPUT_FILE: { |
527 | bool rw; | |
528 | int fd; | |
529 | ||
530 | assert(context->stdio_file[STDIN_FILENO]); | |
531 | ||
532 | rw = (context->std_output == EXEC_OUTPUT_FILE && streq_ptr(context->stdio_file[STDIN_FILENO], context->stdio_file[STDOUT_FILENO])) || | |
533 | (context->std_error == EXEC_OUTPUT_FILE && streq_ptr(context->stdio_file[STDIN_FILENO], context->stdio_file[STDERR_FILENO])); | |
534 | ||
535 | fd = acquire_path(context->stdio_file[STDIN_FILENO], rw ? O_RDWR : O_RDONLY, 0666 & ~context->umask); | |
536 | if (fd < 0) | |
537 | return fd; | |
538 | ||
539 | return move_fd(fd, STDIN_FILENO, false); | |
540 | } | |
541 | ||
80876c20 LP |
542 | default: |
543 | assert_not_reached("Unknown input type"); | |
544 | } | |
545 | } | |
546 | ||
41fc585a LP |
547 | static bool can_inherit_stderr_from_stdout( |
548 | const ExecContext *context, | |
549 | ExecOutput o, | |
550 | ExecOutput e) { | |
551 | ||
552 | assert(context); | |
553 | ||
554 | /* Returns true, if given the specified STDERR and STDOUT output we can directly dup() the stdout fd to the | |
555 | * stderr fd */ | |
556 | ||
557 | if (e == EXEC_OUTPUT_INHERIT) | |
558 | return true; | |
559 | if (e != o) | |
560 | return false; | |
561 | ||
562 | if (e == EXEC_OUTPUT_NAMED_FD) | |
563 | return streq_ptr(context->stdio_fdname[STDOUT_FILENO], context->stdio_fdname[STDERR_FILENO]); | |
564 | ||
8d7dab1f | 565 | if (IN_SET(e, EXEC_OUTPUT_FILE, EXEC_OUTPUT_FILE_APPEND, EXEC_OUTPUT_FILE_TRUNCATE)) |
41fc585a LP |
566 | return streq_ptr(context->stdio_file[STDOUT_FILENO], context->stdio_file[STDERR_FILENO]); |
567 | ||
568 | return true; | |
569 | } | |
570 | ||
a34ceba6 | 571 | static int setup_output( |
34cf6c43 | 572 | const Unit *unit, |
a34ceba6 LP |
573 | const ExecContext *context, |
574 | const ExecParameters *params, | |
575 | int fileno, | |
576 | int socket_fd, | |
2caa38e9 | 577 | const int named_iofds[static 3], |
a34ceba6 | 578 | const char *ident, |
7bce046b LP |
579 | uid_t uid, |
580 | gid_t gid, | |
581 | dev_t *journal_stream_dev, | |
582 | ino_t *journal_stream_ino) { | |
a34ceba6 | 583 | |
4f2d528d LP |
584 | ExecOutput o; |
585 | ExecInput i; | |
47c1d80d | 586 | int r; |
4f2d528d | 587 | |
f2341e0a | 588 | assert(unit); |
80876c20 | 589 | assert(context); |
a34ceba6 | 590 | assert(params); |
80876c20 | 591 | assert(ident); |
7bce046b LP |
592 | assert(journal_stream_dev); |
593 | assert(journal_stream_ino); | |
80876c20 | 594 | |
a34ceba6 LP |
595 | if (fileno == STDOUT_FILENO && params->stdout_fd >= 0) { |
596 | ||
597 | if (dup2(params->stdout_fd, STDOUT_FILENO) < 0) | |
598 | return -errno; | |
599 | ||
600 | return STDOUT_FILENO; | |
601 | } | |
602 | ||
603 | if (fileno == STDERR_FILENO && params->stderr_fd >= 0) { | |
604 | if (dup2(params->stderr_fd, STDERR_FILENO) < 0) | |
605 | return -errno; | |
606 | ||
607 | return STDERR_FILENO; | |
608 | } | |
609 | ||
08f3be7a | 610 | i = fixup_input(context, socket_fd, params->flags & EXEC_APPLY_TTY_STDIN); |
03fd9c49 | 611 | o = fixup_output(context->std_output, socket_fd); |
4f2d528d | 612 | |
eb17e935 MS |
613 | if (fileno == STDERR_FILENO) { |
614 | ExecOutput e; | |
615 | e = fixup_output(context->std_error, socket_fd); | |
80876c20 | 616 | |
eb17e935 MS |
617 | /* This expects the input and output are already set up */ |
618 | ||
619 | /* Don't change the stderr file descriptor if we inherit all | |
620 | * the way and are not on a tty */ | |
621 | if (e == EXEC_OUTPUT_INHERIT && | |
622 | o == EXEC_OUTPUT_INHERIT && | |
623 | i == EXEC_INPUT_NULL && | |
624 | !is_terminal_input(context->std_input) && | |
7966a916 | 625 | getppid() != 1) |
eb17e935 MS |
626 | return fileno; |
627 | ||
628 | /* Duplicate from stdout if possible */ | |
41fc585a | 629 | if (can_inherit_stderr_from_stdout(context, o, e)) |
eb17e935 | 630 | return dup2(STDOUT_FILENO, fileno) < 0 ? -errno : fileno; |
071830ff | 631 | |
eb17e935 | 632 | o = e; |
80876c20 | 633 | |
eb17e935 | 634 | } else if (o == EXEC_OUTPUT_INHERIT) { |
21d21ea4 LP |
635 | /* If input got downgraded, inherit the original value */ |
636 | if (i == EXEC_INPUT_NULL && is_terminal_input(context->std_input)) | |
1e22b5cd | 637 | return open_terminal_as(exec_context_tty_path(context), O_WRONLY, fileno); |
21d21ea4 | 638 | |
08f3be7a LP |
639 | /* If the input is connected to anything that's not a /dev/null or a data fd, inherit that... */ |
640 | if (!IN_SET(i, EXEC_INPUT_NULL, EXEC_INPUT_DATA)) | |
eb17e935 | 641 | return dup2(STDIN_FILENO, fileno) < 0 ? -errno : fileno; |
071830ff | 642 | |
acb591e4 LP |
643 | /* If we are not started from PID 1 we just inherit STDOUT from our parent process. */ |
644 | if (getppid() != 1) | |
eb17e935 | 645 | return fileno; |
94f04347 | 646 | |
eb17e935 MS |
647 | /* We need to open /dev/null here anew, to get the right access mode. */ |
648 | return open_null_as(O_WRONLY, fileno); | |
071830ff | 649 | } |
94f04347 | 650 | |
eb17e935 | 651 | switch (o) { |
80876c20 LP |
652 | |
653 | case EXEC_OUTPUT_NULL: | |
eb17e935 | 654 | return open_null_as(O_WRONLY, fileno); |
80876c20 LP |
655 | |
656 | case EXEC_OUTPUT_TTY: | |
4f2d528d | 657 | if (is_terminal_input(i)) |
eb17e935 | 658 | return dup2(STDIN_FILENO, fileno) < 0 ? -errno : fileno; |
80876c20 LP |
659 | |
660 | /* We don't reset the terminal if this is just about output */ | |
1e22b5cd | 661 | return open_terminal_as(exec_context_tty_path(context), O_WRONLY, fileno); |
80876c20 | 662 | |
9a6bca7a | 663 | case EXEC_OUTPUT_KMSG: |
28dbc1e8 | 664 | case EXEC_OUTPUT_KMSG_AND_CONSOLE: |
706343f4 LP |
665 | case EXEC_OUTPUT_JOURNAL: |
666 | case EXEC_OUTPUT_JOURNAL_AND_CONSOLE: | |
af635cf3 | 667 | r = connect_logger_as(unit, context, params, o, ident, fileno, uid, gid); |
47c1d80d | 668 | if (r < 0) { |
7966a916 ZJS |
669 | log_unit_warning_errno(unit, r, "Failed to connect %s to the journal socket, ignoring: %m", |
670 | 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 | 701 | case EXEC_OUTPUT_FILE: |
8d7dab1f LW |
702 | case EXEC_OUTPUT_FILE_APPEND: |
703 | case EXEC_OUTPUT_FILE_TRUNCATE: { | |
2038c3f5 | 704 | bool rw; |
566b7d23 | 705 | int fd, flags; |
2038c3f5 LP |
706 | |
707 | assert(context->stdio_file[fileno]); | |
708 | ||
709 | rw = context->std_input == EXEC_INPUT_FILE && | |
710 | streq_ptr(context->stdio_file[fileno], context->stdio_file[STDIN_FILENO]); | |
711 | ||
712 | if (rw) | |
713 | return dup2(STDIN_FILENO, fileno) < 0 ? -errno : fileno; | |
714 | ||
566b7d23 ZD |
715 | flags = O_WRONLY; |
716 | if (o == EXEC_OUTPUT_FILE_APPEND) | |
717 | flags |= O_APPEND; | |
8d7dab1f LW |
718 | else if (o == EXEC_OUTPUT_FILE_TRUNCATE) |
719 | flags |= O_TRUNC; | |
566b7d23 ZD |
720 | |
721 | fd = acquire_path(context->stdio_file[fileno], flags, 0666 & ~context->umask); | |
2038c3f5 LP |
722 | if (fd < 0) |
723 | return fd; | |
724 | ||
566b7d23 | 725 | return move_fd(fd, fileno, 0); |
2038c3f5 LP |
726 | } |
727 | ||
94f04347 | 728 | default: |
80876c20 | 729 | assert_not_reached("Unknown error type"); |
94f04347 | 730 | } |
071830ff LP |
731 | } |
732 | ||
02a51aba | 733 | static int chown_terminal(int fd, uid_t uid) { |
4b3b5bc7 | 734 | int r; |
02a51aba LP |
735 | |
736 | assert(fd >= 0); | |
02a51aba | 737 | |
1ff74fb6 | 738 | /* Before we chown/chmod the TTY, let's ensure this is actually a tty */ |
4b3b5bc7 LP |
739 | if (isatty(fd) < 1) { |
740 | if (IN_SET(errno, EINVAL, ENOTTY)) | |
741 | return 0; /* not a tty */ | |
1ff74fb6 | 742 | |
02a51aba | 743 | return -errno; |
4b3b5bc7 | 744 | } |
02a51aba | 745 | |
4b3b5bc7 | 746 | /* This might fail. What matters are the results. */ |
f2df231f | 747 | r = fchmod_and_chown(fd, TTY_MODE, uid, GID_INVALID); |
4b3b5bc7 LP |
748 | if (r < 0) |
749 | return r; | |
02a51aba | 750 | |
4b3b5bc7 | 751 | return 1; |
02a51aba LP |
752 | } |
753 | ||
7d5ceb64 | 754 | static int setup_confirm_stdio(const char *vc, int *_saved_stdin, int *_saved_stdout) { |
3d18b167 LP |
755 | _cleanup_close_ int fd = -1, saved_stdin = -1, saved_stdout = -1; |
756 | int r; | |
80876c20 | 757 | |
80876c20 LP |
758 | assert(_saved_stdin); |
759 | assert(_saved_stdout); | |
760 | ||
af6da548 LP |
761 | saved_stdin = fcntl(STDIN_FILENO, F_DUPFD, 3); |
762 | if (saved_stdin < 0) | |
763 | return -errno; | |
80876c20 | 764 | |
af6da548 | 765 | saved_stdout = fcntl(STDOUT_FILENO, F_DUPFD, 3); |
3d18b167 LP |
766 | if (saved_stdout < 0) |
767 | return -errno; | |
80876c20 | 768 | |
8854d795 | 769 | fd = acquire_terminal(vc, ACQUIRE_TERMINAL_WAIT, DEFAULT_CONFIRM_USEC); |
3d18b167 LP |
770 | if (fd < 0) |
771 | return fd; | |
80876c20 | 772 | |
af6da548 LP |
773 | r = chown_terminal(fd, getuid()); |
774 | if (r < 0) | |
3d18b167 | 775 | return r; |
02a51aba | 776 | |
3d18b167 LP |
777 | r = reset_terminal_fd(fd, true); |
778 | if (r < 0) | |
779 | return r; | |
80876c20 | 780 | |
2b33ab09 | 781 | r = rearrange_stdio(fd, fd, STDERR_FILENO); |
3d18b167 | 782 | fd = -1; |
2b33ab09 LP |
783 | if (r < 0) |
784 | return r; | |
80876c20 LP |
785 | |
786 | *_saved_stdin = saved_stdin; | |
787 | *_saved_stdout = saved_stdout; | |
788 | ||
3d18b167 | 789 | saved_stdin = saved_stdout = -1; |
80876c20 | 790 | |
3d18b167 | 791 | return 0; |
80876c20 LP |
792 | } |
793 | ||
63d77c92 | 794 | static void write_confirm_error_fd(int err, int fd, const Unit *u) { |
3b20f877 FB |
795 | assert(err < 0); |
796 | ||
797 | if (err == -ETIMEDOUT) | |
63d77c92 | 798 | dprintf(fd, "Confirmation question timed out for %s, assuming positive response.\n", u->id); |
3b20f877 FB |
799 | else { |
800 | errno = -err; | |
63d77c92 | 801 | dprintf(fd, "Couldn't ask confirmation for %s: %m, assuming positive response.\n", u->id); |
3b20f877 FB |
802 | } |
803 | } | |
804 | ||
63d77c92 | 805 | static void write_confirm_error(int err, const char *vc, const Unit *u) { |
03e334a1 | 806 | _cleanup_close_ int fd = -1; |
80876c20 | 807 | |
3b20f877 | 808 | assert(vc); |
80876c20 | 809 | |
7d5ceb64 | 810 | fd = open_terminal(vc, O_WRONLY|O_NOCTTY|O_CLOEXEC); |
af6da548 | 811 | if (fd < 0) |
3b20f877 | 812 | return; |
80876c20 | 813 | |
63d77c92 | 814 | write_confirm_error_fd(err, fd, u); |
af6da548 | 815 | } |
80876c20 | 816 | |
3d18b167 | 817 | static int restore_confirm_stdio(int *saved_stdin, int *saved_stdout) { |
af6da548 | 818 | int r = 0; |
80876c20 | 819 | |
af6da548 LP |
820 | assert(saved_stdin); |
821 | assert(saved_stdout); | |
822 | ||
823 | release_terminal(); | |
824 | ||
825 | if (*saved_stdin >= 0) | |
80876c20 | 826 | if (dup2(*saved_stdin, STDIN_FILENO) < 0) |
af6da548 | 827 | r = -errno; |
80876c20 | 828 | |
af6da548 | 829 | if (*saved_stdout >= 0) |
80876c20 | 830 | if (dup2(*saved_stdout, STDOUT_FILENO) < 0) |
af6da548 | 831 | r = -errno; |
80876c20 | 832 | |
3d18b167 LP |
833 | *saved_stdin = safe_close(*saved_stdin); |
834 | *saved_stdout = safe_close(*saved_stdout); | |
af6da548 LP |
835 | |
836 | return r; | |
837 | } | |
838 | ||
3b20f877 FB |
839 | enum { |
840 | CONFIRM_PRETEND_FAILURE = -1, | |
841 | CONFIRM_PRETEND_SUCCESS = 0, | |
842 | CONFIRM_EXECUTE = 1, | |
843 | }; | |
844 | ||
eedf223a | 845 | static int ask_for_confirmation(const char *vc, Unit *u, const char *cmdline) { |
af6da548 | 846 | int saved_stdout = -1, saved_stdin = -1, r; |
2bcd3c26 | 847 | _cleanup_free_ char *e = NULL; |
3b20f877 | 848 | char c; |
af6da548 | 849 | |
3b20f877 | 850 | /* For any internal errors, assume a positive response. */ |
7d5ceb64 | 851 | r = setup_confirm_stdio(vc, &saved_stdin, &saved_stdout); |
3b20f877 | 852 | if (r < 0) { |
63d77c92 | 853 | write_confirm_error(r, vc, u); |
3b20f877 FB |
854 | return CONFIRM_EXECUTE; |
855 | } | |
af6da548 | 856 | |
b0eb2944 FB |
857 | /* confirm_spawn might have been disabled while we were sleeping. */ |
858 | if (manager_is_confirm_spawn_disabled(u->manager)) { | |
859 | r = 1; | |
860 | goto restore_stdio; | |
861 | } | |
af6da548 | 862 | |
2bcd3c26 FB |
863 | e = ellipsize(cmdline, 60, 100); |
864 | if (!e) { | |
865 | log_oom(); | |
866 | r = CONFIRM_EXECUTE; | |
867 | goto restore_stdio; | |
868 | } | |
af6da548 | 869 | |
d172b175 | 870 | for (;;) { |
539622bd | 871 | r = ask_char(&c, "yfshiDjcn", "Execute %s? [y, f, s – h for help] ", e); |
d172b175 | 872 | if (r < 0) { |
63d77c92 | 873 | write_confirm_error_fd(r, STDOUT_FILENO, u); |
d172b175 FB |
874 | r = CONFIRM_EXECUTE; |
875 | goto restore_stdio; | |
876 | } | |
af6da548 | 877 | |
d172b175 | 878 | switch (c) { |
b0eb2944 FB |
879 | case 'c': |
880 | printf("Resuming normal execution.\n"); | |
881 | manager_disable_confirm_spawn(); | |
882 | r = 1; | |
883 | break; | |
dd6f9ac0 FB |
884 | case 'D': |
885 | unit_dump(u, stdout, " "); | |
886 | continue; /* ask again */ | |
d172b175 FB |
887 | case 'f': |
888 | printf("Failing execution.\n"); | |
889 | r = CONFIRM_PRETEND_FAILURE; | |
890 | break; | |
891 | case 'h': | |
b0eb2944 FB |
892 | printf(" c - continue, proceed without asking anymore\n" |
893 | " D - dump, show the state of the unit\n" | |
dd6f9ac0 | 894 | " f - fail, don't execute the command and pretend it failed\n" |
d172b175 | 895 | " h - help\n" |
eedf223a | 896 | " i - info, show a short summary of the unit\n" |
56fde33a | 897 | " j - jobs, show jobs that are in progress\n" |
d172b175 FB |
898 | " s - skip, don't execute the command and pretend it succeeded\n" |
899 | " y - yes, execute the command\n"); | |
dd6f9ac0 | 900 | continue; /* ask again */ |
eedf223a FB |
901 | case 'i': |
902 | printf(" Description: %s\n" | |
903 | " Unit: %s\n" | |
904 | " Command: %s\n", | |
905 | u->id, u->description, cmdline); | |
906 | continue; /* ask again */ | |
56fde33a FB |
907 | case 'j': |
908 | manager_dump_jobs(u->manager, stdout, " "); | |
909 | continue; /* ask again */ | |
539622bd FB |
910 | case 'n': |
911 | /* 'n' was removed in favor of 'f'. */ | |
912 | printf("Didn't understand 'n', did you mean 'f'?\n"); | |
913 | continue; /* ask again */ | |
d172b175 FB |
914 | case 's': |
915 | printf("Skipping execution.\n"); | |
916 | r = CONFIRM_PRETEND_SUCCESS; | |
917 | break; | |
918 | case 'y': | |
919 | r = CONFIRM_EXECUTE; | |
920 | break; | |
921 | default: | |
922 | assert_not_reached("Unhandled choice"); | |
923 | } | |
3b20f877 | 924 | break; |
3b20f877 | 925 | } |
af6da548 | 926 | |
3b20f877 | 927 | restore_stdio: |
af6da548 | 928 | restore_confirm_stdio(&saved_stdin, &saved_stdout); |
af6da548 | 929 | return r; |
80876c20 LP |
930 | } |
931 | ||
4d885bd3 DH |
932 | static int get_fixed_user(const ExecContext *c, const char **user, |
933 | uid_t *uid, gid_t *gid, | |
934 | const char **home, const char **shell) { | |
81a2b7ce | 935 | int r; |
4d885bd3 | 936 | const char *name; |
81a2b7ce | 937 | |
4d885bd3 | 938 | assert(c); |
81a2b7ce | 939 | |
23deef88 LP |
940 | if (!c->user) |
941 | return 0; | |
942 | ||
4d885bd3 DH |
943 | /* Note that we don't set $HOME or $SHELL if they are not particularly enlightening anyway |
944 | * (i.e. are "/" or "/bin/nologin"). */ | |
81a2b7ce | 945 | |
23deef88 | 946 | name = c->user; |
fafff8f1 | 947 | r = get_user_creds(&name, uid, gid, home, shell, USER_CREDS_CLEAN); |
4d885bd3 DH |
948 | if (r < 0) |
949 | return r; | |
81a2b7ce | 950 | |
4d885bd3 DH |
951 | *user = name; |
952 | return 0; | |
953 | } | |
954 | ||
955 | static int get_fixed_group(const ExecContext *c, const char **group, gid_t *gid) { | |
956 | int r; | |
957 | const char *name; | |
958 | ||
959 | assert(c); | |
960 | ||
961 | if (!c->group) | |
962 | return 0; | |
963 | ||
964 | name = c->group; | |
fafff8f1 | 965 | r = get_group_creds(&name, gid, 0); |
4d885bd3 DH |
966 | if (r < 0) |
967 | return r; | |
968 | ||
969 | *group = name; | |
970 | return 0; | |
971 | } | |
972 | ||
cdc5d5c5 DH |
973 | static int get_supplementary_groups(const ExecContext *c, const char *user, |
974 | const char *group, gid_t gid, | |
975 | gid_t **supplementary_gids, int *ngids) { | |
4d885bd3 DH |
976 | char **i; |
977 | int r, k = 0; | |
978 | int ngroups_max; | |
979 | bool keep_groups = false; | |
980 | gid_t *groups = NULL; | |
981 | _cleanup_free_ gid_t *l_gids = NULL; | |
982 | ||
983 | assert(c); | |
984 | ||
bbeea271 DH |
985 | /* |
986 | * If user is given, then lookup GID and supplementary groups list. | |
987 | * We avoid NSS lookups for gid=0. Also we have to initialize groups | |
cdc5d5c5 DH |
988 | * here and as early as possible so we keep the list of supplementary |
989 | * groups of the caller. | |
bbeea271 DH |
990 | */ |
991 | if (user && gid_is_valid(gid) && gid != 0) { | |
992 | /* First step, initialize groups from /etc/groups */ | |
993 | if (initgroups(user, gid) < 0) | |
994 | return -errno; | |
995 | ||
996 | keep_groups = true; | |
997 | } | |
998 | ||
ac6e8be6 | 999 | if (strv_isempty(c->supplementary_groups)) |
4d885bd3 DH |
1000 | return 0; |
1001 | ||
366ddd25 DH |
1002 | /* |
1003 | * If SupplementaryGroups= was passed then NGROUPS_MAX has to | |
1004 | * be positive, otherwise fail. | |
1005 | */ | |
1006 | errno = 0; | |
1007 | ngroups_max = (int) sysconf(_SC_NGROUPS_MAX); | |
66855de7 LP |
1008 | if (ngroups_max <= 0) |
1009 | return errno_or_else(EOPNOTSUPP); | |
366ddd25 | 1010 | |
4d885bd3 DH |
1011 | l_gids = new(gid_t, ngroups_max); |
1012 | if (!l_gids) | |
1013 | return -ENOMEM; | |
81a2b7ce | 1014 | |
4d885bd3 DH |
1015 | if (keep_groups) { |
1016 | /* | |
1017 | * Lookup the list of groups that the user belongs to, we | |
1018 | * avoid NSS lookups here too for gid=0. | |
1019 | */ | |
1020 | k = ngroups_max; | |
1021 | if (getgrouplist(user, gid, l_gids, &k) < 0) | |
1022 | return -EINVAL; | |
1023 | } else | |
1024 | k = 0; | |
81a2b7ce | 1025 | |
4d885bd3 DH |
1026 | STRV_FOREACH(i, c->supplementary_groups) { |
1027 | const char *g; | |
81a2b7ce | 1028 | |
4d885bd3 DH |
1029 | if (k >= ngroups_max) |
1030 | return -E2BIG; | |
81a2b7ce | 1031 | |
4d885bd3 | 1032 | g = *i; |
fafff8f1 | 1033 | r = get_group_creds(&g, l_gids+k, 0); |
4d885bd3 DH |
1034 | if (r < 0) |
1035 | return r; | |
81a2b7ce | 1036 | |
4d885bd3 DH |
1037 | k++; |
1038 | } | |
81a2b7ce | 1039 | |
4d885bd3 DH |
1040 | /* |
1041 | * Sets ngids to zero to drop all supplementary groups, happens | |
1042 | * when we are under root and SupplementaryGroups= is empty. | |
1043 | */ | |
1044 | if (k == 0) { | |
1045 | *ngids = 0; | |
1046 | return 0; | |
1047 | } | |
81a2b7ce | 1048 | |
4d885bd3 DH |
1049 | /* Otherwise get the final list of supplementary groups */ |
1050 | groups = memdup(l_gids, sizeof(gid_t) * k); | |
1051 | if (!groups) | |
1052 | return -ENOMEM; | |
1053 | ||
1054 | *supplementary_gids = groups; | |
1055 | *ngids = k; | |
1056 | ||
1057 | groups = NULL; | |
1058 | ||
1059 | return 0; | |
1060 | } | |
1061 | ||
34cf6c43 | 1062 | static int enforce_groups(gid_t gid, const gid_t *supplementary_gids, int ngids) { |
4d885bd3 DH |
1063 | int r; |
1064 | ||
709dbeac YW |
1065 | /* Handle SupplementaryGroups= if it is not empty */ |
1066 | if (ngids > 0) { | |
4d885bd3 DH |
1067 | r = maybe_setgroups(ngids, supplementary_gids); |
1068 | if (r < 0) | |
97f0e76f | 1069 | return r; |
4d885bd3 | 1070 | } |
81a2b7ce | 1071 | |
4d885bd3 DH |
1072 | if (gid_is_valid(gid)) { |
1073 | /* Then set our gids */ | |
1074 | if (setresgid(gid, gid, gid) < 0) | |
1075 | return -errno; | |
81a2b7ce LP |
1076 | } |
1077 | ||
1078 | return 0; | |
1079 | } | |
1080 | ||
dbdc4098 TK |
1081 | static int set_securebits(int bits, int mask) { |
1082 | int current, applied; | |
1083 | current = prctl(PR_GET_SECUREBITS); | |
1084 | if (current < 0) | |
1085 | return -errno; | |
1086 | /* Clear all securebits defined in mask and set bits */ | |
1087 | applied = (current & ~mask) | bits; | |
1088 | if (current == applied) | |
1089 | return 0; | |
1090 | if (prctl(PR_SET_SECUREBITS, applied) < 0) | |
1091 | return -errno; | |
1092 | return 1; | |
1093 | } | |
1094 | ||
81a2b7ce | 1095 | static int enforce_user(const ExecContext *context, uid_t uid) { |
81a2b7ce | 1096 | assert(context); |
dbdc4098 | 1097 | int r; |
81a2b7ce | 1098 | |
4d885bd3 DH |
1099 | if (!uid_is_valid(uid)) |
1100 | return 0; | |
1101 | ||
479050b3 | 1102 | /* Sets (but doesn't look up) the uid and make sure we keep the |
dbdc4098 TK |
1103 | * capabilities while doing so. For setting secure bits the capability CAP_SETPCAP is |
1104 | * required, so we also need keep-caps in this case. | |
1105 | */ | |
81a2b7ce | 1106 | |
dbdc4098 | 1107 | if (context->capability_ambient_set != 0 || context->secure_bits != 0) { |
81a2b7ce LP |
1108 | |
1109 | /* First step: If we need to keep capabilities but | |
1110 | * drop privileges we need to make sure we keep our | |
cbb21cca | 1111 | * caps, while we drop privileges. */ |
693ced48 | 1112 | if (uid != 0) { |
dbdc4098 TK |
1113 | /* Add KEEP_CAPS to the securebits */ |
1114 | r = set_securebits(1<<SECURE_KEEP_CAPS, 0); | |
1115 | if (r < 0) | |
1116 | return r; | |
693ced48 | 1117 | } |
81a2b7ce LP |
1118 | } |
1119 | ||
479050b3 | 1120 | /* Second step: actually set the uids */ |
81a2b7ce LP |
1121 | if (setresuid(uid, uid, uid) < 0) |
1122 | return -errno; | |
1123 | ||
1124 | /* At this point we should have all necessary capabilities but | |
1125 | are otherwise a normal user. However, the caps might got | |
1126 | corrupted due to the setresuid() so we need clean them up | |
1127 | later. This is done outside of this call. */ | |
1128 | ||
1129 | return 0; | |
1130 | } | |
1131 | ||
349cc4a5 | 1132 | #if HAVE_PAM |
5b6319dc LP |
1133 | |
1134 | static int null_conv( | |
1135 | int num_msg, | |
1136 | const struct pam_message **msg, | |
1137 | struct pam_response **resp, | |
1138 | void *appdata_ptr) { | |
1139 | ||
1140 | /* We don't support conversations */ | |
1141 | ||
1142 | return PAM_CONV_ERR; | |
1143 | } | |
1144 | ||
cefc33ae LP |
1145 | #endif |
1146 | ||
5b6319dc LP |
1147 | static int setup_pam( |
1148 | const char *name, | |
1149 | const char *user, | |
940c5210 | 1150 | uid_t uid, |
2d6fce8d | 1151 | gid_t gid, |
5b6319dc | 1152 | const char *tty, |
2065ca69 | 1153 | char ***env, |
5b8d1f6b | 1154 | const int fds[], size_t n_fds) { |
5b6319dc | 1155 | |
349cc4a5 | 1156 | #if HAVE_PAM |
cefc33ae | 1157 | |
5b6319dc LP |
1158 | static const struct pam_conv conv = { |
1159 | .conv = null_conv, | |
1160 | .appdata_ptr = NULL | |
1161 | }; | |
1162 | ||
2d7c6aa2 | 1163 | _cleanup_(barrier_destroy) Barrier barrier = BARRIER_NULL; |
5b6319dc | 1164 | pam_handle_t *handle = NULL; |
d6e5f3ad | 1165 | sigset_t old_ss; |
7bb70b6e | 1166 | int pam_code = PAM_SUCCESS, r; |
84eada2f | 1167 | char **nv, **e = NULL; |
5b6319dc LP |
1168 | bool close_session = false; |
1169 | pid_t pam_pid = 0, parent_pid; | |
970edce6 | 1170 | int flags = 0; |
5b6319dc LP |
1171 | |
1172 | assert(name); | |
1173 | assert(user); | |
2065ca69 | 1174 | assert(env); |
5b6319dc LP |
1175 | |
1176 | /* We set up PAM in the parent process, then fork. The child | |
35b8ca3a | 1177 | * will then stay around until killed via PR_GET_PDEATHSIG or |
5b6319dc LP |
1178 | * systemd via the cgroup logic. It will then remove the PAM |
1179 | * session again. The parent process will exec() the actual | |
1180 | * daemon. We do things this way to ensure that the main PID | |
1181 | * of the daemon is the one we initially fork()ed. */ | |
1182 | ||
7bb70b6e LP |
1183 | r = barrier_create(&barrier); |
1184 | if (r < 0) | |
2d7c6aa2 DH |
1185 | goto fail; |
1186 | ||
553d2243 | 1187 | if (log_get_max_level() < LOG_DEBUG) |
970edce6 ZJS |
1188 | flags |= PAM_SILENT; |
1189 | ||
f546241b ZJS |
1190 | pam_code = pam_start(name, user, &conv, &handle); |
1191 | if (pam_code != PAM_SUCCESS) { | |
5b6319dc LP |
1192 | handle = NULL; |
1193 | goto fail; | |
1194 | } | |
1195 | ||
3cd24c1a LP |
1196 | if (!tty) { |
1197 | _cleanup_free_ char *q = NULL; | |
1198 | ||
1199 | /* Hmm, so no TTY was explicitly passed, but an fd passed to us directly might be a TTY. Let's figure | |
1200 | * out if that's the case, and read the TTY off it. */ | |
1201 | ||
1202 | if (getttyname_malloc(STDIN_FILENO, &q) >= 0) | |
1203 | tty = strjoina("/dev/", q); | |
1204 | } | |
1205 | ||
f546241b ZJS |
1206 | if (tty) { |
1207 | pam_code = pam_set_item(handle, PAM_TTY, tty); | |
1208 | if (pam_code != PAM_SUCCESS) | |
5b6319dc | 1209 | goto fail; |
f546241b | 1210 | } |
5b6319dc | 1211 | |
84eada2f JW |
1212 | STRV_FOREACH(nv, *env) { |
1213 | pam_code = pam_putenv(handle, *nv); | |
2065ca69 JW |
1214 | if (pam_code != PAM_SUCCESS) |
1215 | goto fail; | |
1216 | } | |
1217 | ||
970edce6 | 1218 | pam_code = pam_acct_mgmt(handle, flags); |
f546241b | 1219 | if (pam_code != PAM_SUCCESS) |
5b6319dc LP |
1220 | goto fail; |
1221 | ||
3bb39ea9 DG |
1222 | pam_code = pam_setcred(handle, PAM_ESTABLISH_CRED | flags); |
1223 | if (pam_code != PAM_SUCCESS) | |
46d7c6af | 1224 | log_debug("pam_setcred() failed, ignoring: %s", pam_strerror(handle, pam_code)); |
3bb39ea9 | 1225 | |
970edce6 | 1226 | pam_code = pam_open_session(handle, flags); |
f546241b | 1227 | if (pam_code != PAM_SUCCESS) |
5b6319dc LP |
1228 | goto fail; |
1229 | ||
1230 | close_session = true; | |
1231 | ||
f546241b ZJS |
1232 | e = pam_getenvlist(handle); |
1233 | if (!e) { | |
5b6319dc LP |
1234 | pam_code = PAM_BUF_ERR; |
1235 | goto fail; | |
1236 | } | |
1237 | ||
1238 | /* Block SIGTERM, so that we know that it won't get lost in | |
1239 | * the child */ | |
ce30c8dc | 1240 | |
72c0a2c2 | 1241 | assert_se(sigprocmask_many(SIG_BLOCK, &old_ss, SIGTERM, -1) >= 0); |
5b6319dc | 1242 | |
df0ff127 | 1243 | parent_pid = getpid_cached(); |
5b6319dc | 1244 | |
4c253ed1 LP |
1245 | r = safe_fork("(sd-pam)", 0, &pam_pid); |
1246 | if (r < 0) | |
5b6319dc | 1247 | goto fail; |
4c253ed1 | 1248 | if (r == 0) { |
7bb70b6e | 1249 | int sig, ret = EXIT_PAM; |
5b6319dc LP |
1250 | |
1251 | /* The child's job is to reset the PAM session on | |
1252 | * termination */ | |
2d7c6aa2 | 1253 | barrier_set_role(&barrier, BARRIER_CHILD); |
5b6319dc | 1254 | |
1da37e58 ZJS |
1255 | /* Make sure we don't keep open the passed fds in this child. We assume that otherwise only |
1256 | * those fds are open here that have been opened by PAM. */ | |
4c253ed1 | 1257 | (void) close_many(fds, n_fds); |
5b6319dc | 1258 | |
940c5210 AK |
1259 | /* Drop privileges - we don't need any to pam_close_session |
1260 | * and this will make PR_SET_PDEATHSIG work in most cases. | |
1261 | * If this fails, ignore the error - but expect sd-pam threads | |
1262 | * to fail to exit normally */ | |
2d6fce8d | 1263 | |
97f0e76f LP |
1264 | r = maybe_setgroups(0, NULL); |
1265 | if (r < 0) | |
1266 | log_warning_errno(r, "Failed to setgroups() in sd-pam: %m"); | |
2d6fce8d LP |
1267 | if (setresgid(gid, gid, gid) < 0) |
1268 | log_warning_errno(errno, "Failed to setresgid() in sd-pam: %m"); | |
940c5210 | 1269 | if (setresuid(uid, uid, uid) < 0) |
2d6fce8d | 1270 | log_warning_errno(errno, "Failed to setresuid() in sd-pam: %m"); |
940c5210 | 1271 | |
9c274488 | 1272 | (void) ignore_signals(SIGPIPE); |
ce30c8dc | 1273 | |
940c5210 AK |
1274 | /* Wait until our parent died. This will only work if |
1275 | * the above setresuid() succeeds, otherwise the kernel | |
1276 | * will not allow unprivileged parents kill their privileged | |
1277 | * children this way. We rely on the control groups kill logic | |
5b6319dc LP |
1278 | * to do the rest for us. */ |
1279 | if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0) | |
1280 | goto child_finish; | |
1281 | ||
2d7c6aa2 DH |
1282 | /* Tell the parent that our setup is done. This is especially |
1283 | * important regarding dropping privileges. Otherwise, unit | |
643f4706 ZJS |
1284 | * setup might race against our setresuid(2) call. |
1285 | * | |
1286 | * If the parent aborted, we'll detect this below, hence ignore | |
1287 | * return failure here. */ | |
1288 | (void) barrier_place(&barrier); | |
2d7c6aa2 | 1289 | |
643f4706 | 1290 | /* Check if our parent process might already have died? */ |
5b6319dc | 1291 | if (getppid() == parent_pid) { |
d6e5f3ad DM |
1292 | sigset_t ss; |
1293 | ||
1294 | assert_se(sigemptyset(&ss) >= 0); | |
1295 | assert_se(sigaddset(&ss, SIGTERM) >= 0); | |
1296 | ||
3dead8d9 LP |
1297 | for (;;) { |
1298 | if (sigwait(&ss, &sig) < 0) { | |
1299 | if (errno == EINTR) | |
1300 | continue; | |
1301 | ||
1302 | goto child_finish; | |
1303 | } | |
5b6319dc | 1304 | |
3dead8d9 LP |
1305 | assert(sig == SIGTERM); |
1306 | break; | |
1307 | } | |
5b6319dc LP |
1308 | } |
1309 | ||
3bb39ea9 DG |
1310 | pam_code = pam_setcred(handle, PAM_DELETE_CRED | flags); |
1311 | if (pam_code != PAM_SUCCESS) | |
1312 | goto child_finish; | |
1313 | ||
3dead8d9 | 1314 | /* If our parent died we'll end the session */ |
f546241b | 1315 | if (getppid() != parent_pid) { |
970edce6 | 1316 | pam_code = pam_close_session(handle, flags); |
f546241b | 1317 | if (pam_code != PAM_SUCCESS) |
5b6319dc | 1318 | goto child_finish; |
f546241b | 1319 | } |
5b6319dc | 1320 | |
7bb70b6e | 1321 | ret = 0; |
5b6319dc LP |
1322 | |
1323 | child_finish: | |
970edce6 | 1324 | pam_end(handle, pam_code | flags); |
7bb70b6e | 1325 | _exit(ret); |
5b6319dc LP |
1326 | } |
1327 | ||
2d7c6aa2 DH |
1328 | barrier_set_role(&barrier, BARRIER_PARENT); |
1329 | ||
5b6319dc LP |
1330 | /* If the child was forked off successfully it will do all the |
1331 | * cleanups, so forget about the handle here. */ | |
1332 | handle = NULL; | |
1333 | ||
3b8bddde | 1334 | /* Unblock SIGTERM again in the parent */ |
72c0a2c2 | 1335 | assert_se(sigprocmask(SIG_SETMASK, &old_ss, NULL) >= 0); |
5b6319dc LP |
1336 | |
1337 | /* We close the log explicitly here, since the PAM modules | |
1338 | * might have opened it, but we don't want this fd around. */ | |
1339 | closelog(); | |
1340 | ||
2d7c6aa2 DH |
1341 | /* Synchronously wait for the child to initialize. We don't care for |
1342 | * errors as we cannot recover. However, warn loudly if it happens. */ | |
1343 | if (!barrier_place_and_sync(&barrier)) | |
1344 | log_error("PAM initialization failed"); | |
1345 | ||
130d3d22 | 1346 | return strv_free_and_replace(*env, e); |
5b6319dc LP |
1347 | |
1348 | fail: | |
970edce6 ZJS |
1349 | if (pam_code != PAM_SUCCESS) { |
1350 | log_error("PAM failed: %s", pam_strerror(handle, pam_code)); | |
7bb70b6e LP |
1351 | r = -EPERM; /* PAM errors do not map to errno */ |
1352 | } else | |
1353 | log_error_errno(r, "PAM failed: %m"); | |
9ba35398 | 1354 | |
5b6319dc LP |
1355 | if (handle) { |
1356 | if (close_session) | |
970edce6 | 1357 | pam_code = pam_close_session(handle, flags); |
5b6319dc | 1358 | |
970edce6 | 1359 | pam_end(handle, pam_code | flags); |
5b6319dc LP |
1360 | } |
1361 | ||
1362 | strv_free(e); | |
5b6319dc LP |
1363 | closelog(); |
1364 | ||
7bb70b6e | 1365 | return r; |
cefc33ae LP |
1366 | #else |
1367 | return 0; | |
5b6319dc | 1368 | #endif |
cefc33ae | 1369 | } |
5b6319dc | 1370 | |
5d6b1584 LP |
1371 | static void rename_process_from_path(const char *path) { |
1372 | char process_name[11]; | |
1373 | const char *p; | |
1374 | size_t l; | |
1375 | ||
1376 | /* This resulting string must fit in 10 chars (i.e. the length | |
1377 | * of "/sbin/init") to look pretty in /bin/ps */ | |
1378 | ||
2b6bf07d | 1379 | p = basename(path); |
5d6b1584 LP |
1380 | if (isempty(p)) { |
1381 | rename_process("(...)"); | |
1382 | return; | |
1383 | } | |
1384 | ||
1385 | l = strlen(p); | |
1386 | if (l > 8) { | |
1387 | /* The end of the process name is usually more | |
1388 | * interesting, since the first bit might just be | |
1389 | * "systemd-" */ | |
1390 | p = p + l - 8; | |
1391 | l = 8; | |
1392 | } | |
1393 | ||
1394 | process_name[0] = '('; | |
1395 | memcpy(process_name+1, p, l); | |
1396 | process_name[1+l] = ')'; | |
1397 | process_name[1+l+1] = 0; | |
1398 | ||
1399 | rename_process(process_name); | |
1400 | } | |
1401 | ||
469830d1 LP |
1402 | static bool context_has_address_families(const ExecContext *c) { |
1403 | assert(c); | |
1404 | ||
6b000af4 | 1405 | return c->address_families_allow_list || |
469830d1 LP |
1406 | !set_isempty(c->address_families); |
1407 | } | |
1408 | ||
1409 | static bool context_has_syscall_filters(const ExecContext *c) { | |
1410 | assert(c); | |
1411 | ||
6b000af4 | 1412 | return c->syscall_allow_list || |
8cfa775f | 1413 | !hashmap_isempty(c->syscall_filter); |
469830d1 LP |
1414 | } |
1415 | ||
9df2cdd8 TM |
1416 | static bool context_has_syscall_logs(const ExecContext *c) { |
1417 | assert(c); | |
1418 | ||
1419 | return c->syscall_log_allow_list || | |
1420 | !hashmap_isempty(c->syscall_log); | |
1421 | } | |
1422 | ||
469830d1 LP |
1423 | static bool context_has_no_new_privileges(const ExecContext *c) { |
1424 | assert(c); | |
1425 | ||
1426 | if (c->no_new_privileges) | |
1427 | return true; | |
1428 | ||
1429 | if (have_effective_cap(CAP_SYS_ADMIN)) /* if we are privileged, we don't need NNP */ | |
1430 | return false; | |
1431 | ||
1432 | /* We need NNP if we have any form of seccomp and are unprivileged */ | |
0538d2a8 | 1433 | return c->lock_personality || |
469830d1 | 1434 | c->memory_deny_write_execute || |
0538d2a8 | 1435 | c->private_devices || |
fc64760d | 1436 | c->protect_clock || |
0538d2a8 | 1437 | c->protect_hostname || |
469830d1 LP |
1438 | c->protect_kernel_tunables || |
1439 | c->protect_kernel_modules || | |
84703040 | 1440 | c->protect_kernel_logs || |
0538d2a8 YW |
1441 | context_has_address_families(c) || |
1442 | exec_context_restrict_namespaces_set(c) || | |
1443 | c->restrict_realtime || | |
1444 | c->restrict_suid_sgid || | |
78e864e5 | 1445 | !set_isempty(c->syscall_archs) || |
0538d2a8 YW |
1446 | context_has_syscall_filters(c) || |
1447 | context_has_syscall_logs(c); | |
469830d1 LP |
1448 | } |
1449 | ||
bb0c0d6f LP |
1450 | static bool exec_context_has_credentials(const ExecContext *context) { |
1451 | ||
1452 | assert(context); | |
1453 | ||
1454 | return !hashmap_isempty(context->set_credentials) || | |
1455 | context->load_credentials; | |
1456 | } | |
1457 | ||
349cc4a5 | 1458 | #if HAVE_SECCOMP |
17df7223 | 1459 | |
83f12b27 | 1460 | static bool skip_seccomp_unavailable(const Unit* u, const char* msg) { |
f673b62d LP |
1461 | |
1462 | if (is_seccomp_available()) | |
1463 | return false; | |
1464 | ||
f673b62d | 1465 | log_unit_debug(u, "SECCOMP features not detected in the kernel, skipping %s", msg); |
f673b62d | 1466 | return true; |
83f12b27 FS |
1467 | } |
1468 | ||
165a31c0 | 1469 | static int apply_syscall_filter(const Unit* u, const ExecContext *c, bool needs_ambient_hack) { |
469830d1 | 1470 | uint32_t negative_action, default_action, action; |
165a31c0 | 1471 | int r; |
8351ceae | 1472 | |
469830d1 | 1473 | assert(u); |
c0467cf3 | 1474 | assert(c); |
8351ceae | 1475 | |
469830d1 | 1476 | if (!context_has_syscall_filters(c)) |
83f12b27 FS |
1477 | return 0; |
1478 | ||
469830d1 LP |
1479 | if (skip_seccomp_unavailable(u, "SystemCallFilter=")) |
1480 | return 0; | |
e9642be2 | 1481 | |
005bfaf1 | 1482 | negative_action = c->syscall_errno == SECCOMP_ERROR_NUMBER_KILL ? scmp_act_kill_process() : SCMP_ACT_ERRNO(c->syscall_errno); |
e9642be2 | 1483 | |
6b000af4 | 1484 | if (c->syscall_allow_list) { |
469830d1 LP |
1485 | default_action = negative_action; |
1486 | action = SCMP_ACT_ALLOW; | |
7c66bae2 | 1487 | } else { |
469830d1 LP |
1488 | default_action = SCMP_ACT_ALLOW; |
1489 | action = negative_action; | |
57183d11 | 1490 | } |
8351ceae | 1491 | |
165a31c0 | 1492 | if (needs_ambient_hack) { |
6b000af4 | 1493 | r = seccomp_filter_set_add(c->syscall_filter, c->syscall_allow_list, syscall_filter_sets + SYSCALL_FILTER_SET_SETUID); |
165a31c0 LP |
1494 | if (r < 0) |
1495 | return r; | |
1496 | } | |
1497 | ||
b54f36c6 | 1498 | return seccomp_load_syscall_filter_set_raw(default_action, c->syscall_filter, action, false); |
4298d0b5 LP |
1499 | } |
1500 | ||
9df2cdd8 TM |
1501 | static int apply_syscall_log(const Unit* u, const ExecContext *c) { |
1502 | #ifdef SCMP_ACT_LOG | |
1503 | uint32_t default_action, action; | |
1504 | #endif | |
1505 | ||
1506 | assert(u); | |
1507 | assert(c); | |
1508 | ||
1509 | if (!context_has_syscall_logs(c)) | |
1510 | return 0; | |
1511 | ||
1512 | #ifdef SCMP_ACT_LOG | |
1513 | if (skip_seccomp_unavailable(u, "SystemCallLog=")) | |
1514 | return 0; | |
1515 | ||
1516 | if (c->syscall_log_allow_list) { | |
1517 | /* Log nothing but the ones listed */ | |
1518 | default_action = SCMP_ACT_ALLOW; | |
1519 | action = SCMP_ACT_LOG; | |
1520 | } else { | |
1521 | /* Log everything but the ones listed */ | |
1522 | default_action = SCMP_ACT_LOG; | |
1523 | action = SCMP_ACT_ALLOW; | |
1524 | } | |
1525 | ||
1526 | return seccomp_load_syscall_filter_set_raw(default_action, c->syscall_log, action, false); | |
1527 | #else | |
1528 | /* old libseccomp */ | |
1529 | log_unit_debug(u, "SECCOMP feature SCMP_ACT_LOG not available, skipping SystemCallLog="); | |
1530 | return 0; | |
1531 | #endif | |
1532 | } | |
1533 | ||
469830d1 LP |
1534 | static int apply_syscall_archs(const Unit *u, const ExecContext *c) { |
1535 | assert(u); | |
4298d0b5 LP |
1536 | assert(c); |
1537 | ||
469830d1 | 1538 | if (set_isempty(c->syscall_archs)) |
83f12b27 FS |
1539 | return 0; |
1540 | ||
469830d1 LP |
1541 | if (skip_seccomp_unavailable(u, "SystemCallArchitectures=")) |
1542 | return 0; | |
4298d0b5 | 1543 | |
469830d1 LP |
1544 | return seccomp_restrict_archs(c->syscall_archs); |
1545 | } | |
4298d0b5 | 1546 | |
469830d1 LP |
1547 | static int apply_address_families(const Unit* u, const ExecContext *c) { |
1548 | assert(u); | |
1549 | assert(c); | |
4298d0b5 | 1550 | |
469830d1 LP |
1551 | if (!context_has_address_families(c)) |
1552 | return 0; | |
4298d0b5 | 1553 | |
469830d1 LP |
1554 | if (skip_seccomp_unavailable(u, "RestrictAddressFamilies=")) |
1555 | return 0; | |
4298d0b5 | 1556 | |
6b000af4 | 1557 | return seccomp_restrict_address_families(c->address_families, c->address_families_allow_list); |
8351ceae | 1558 | } |
4298d0b5 | 1559 | |
83f12b27 | 1560 | static int apply_memory_deny_write_execute(const Unit* u, const ExecContext *c) { |
469830d1 | 1561 | assert(u); |
f3e43635 TM |
1562 | assert(c); |
1563 | ||
469830d1 | 1564 | if (!c->memory_deny_write_execute) |
83f12b27 FS |
1565 | return 0; |
1566 | ||
469830d1 LP |
1567 | if (skip_seccomp_unavailable(u, "MemoryDenyWriteExecute=")) |
1568 | return 0; | |
f3e43635 | 1569 | |
469830d1 | 1570 | return seccomp_memory_deny_write_execute(); |
f3e43635 TM |
1571 | } |
1572 | ||
83f12b27 | 1573 | static int apply_restrict_realtime(const Unit* u, const ExecContext *c) { |
469830d1 | 1574 | assert(u); |
f4170c67 LP |
1575 | assert(c); |
1576 | ||
469830d1 | 1577 | if (!c->restrict_realtime) |
83f12b27 FS |
1578 | return 0; |
1579 | ||
469830d1 LP |
1580 | if (skip_seccomp_unavailable(u, "RestrictRealtime=")) |
1581 | return 0; | |
f4170c67 | 1582 | |
469830d1 | 1583 | return seccomp_restrict_realtime(); |
f4170c67 LP |
1584 | } |
1585 | ||
f69567cb LP |
1586 | static int apply_restrict_suid_sgid(const Unit* u, const ExecContext *c) { |
1587 | assert(u); | |
1588 | assert(c); | |
1589 | ||
1590 | if (!c->restrict_suid_sgid) | |
1591 | return 0; | |
1592 | ||
1593 | if (skip_seccomp_unavailable(u, "RestrictSUIDSGID=")) | |
1594 | return 0; | |
1595 | ||
1596 | return seccomp_restrict_suid_sgid(); | |
1597 | } | |
1598 | ||
59e856c7 | 1599 | static int apply_protect_sysctl(const Unit *u, const ExecContext *c) { |
469830d1 | 1600 | assert(u); |
59eeb84b LP |
1601 | assert(c); |
1602 | ||
1603 | /* Turn off the legacy sysctl() system call. Many distributions turn this off while building the kernel, but | |
1604 | * let's protect even those systems where this is left on in the kernel. */ | |
1605 | ||
469830d1 | 1606 | if (!c->protect_kernel_tunables) |
59eeb84b LP |
1607 | return 0; |
1608 | ||
469830d1 LP |
1609 | if (skip_seccomp_unavailable(u, "ProtectKernelTunables=")) |
1610 | return 0; | |
59eeb84b | 1611 | |
469830d1 | 1612 | return seccomp_protect_sysctl(); |
59eeb84b LP |
1613 | } |
1614 | ||
59e856c7 | 1615 | static int apply_protect_kernel_modules(const Unit *u, const ExecContext *c) { |
469830d1 | 1616 | assert(u); |
502d704e DH |
1617 | assert(c); |
1618 | ||
25a8d8a0 | 1619 | /* Turn off module syscalls on ProtectKernelModules=yes */ |
502d704e | 1620 | |
469830d1 LP |
1621 | if (!c->protect_kernel_modules) |
1622 | return 0; | |
1623 | ||
502d704e DH |
1624 | if (skip_seccomp_unavailable(u, "ProtectKernelModules=")) |
1625 | return 0; | |
1626 | ||
b54f36c6 | 1627 | return seccomp_load_syscall_filter_set(SCMP_ACT_ALLOW, syscall_filter_sets + SYSCALL_FILTER_SET_MODULE, SCMP_ACT_ERRNO(EPERM), false); |
502d704e DH |
1628 | } |
1629 | ||
84703040 KK |
1630 | static int apply_protect_kernel_logs(const Unit *u, const ExecContext *c) { |
1631 | assert(u); | |
1632 | assert(c); | |
1633 | ||
1634 | if (!c->protect_kernel_logs) | |
1635 | return 0; | |
1636 | ||
1637 | if (skip_seccomp_unavailable(u, "ProtectKernelLogs=")) | |
1638 | return 0; | |
1639 | ||
1640 | return seccomp_protect_syslog(); | |
1641 | } | |
1642 | ||
daf8f72b | 1643 | static int apply_protect_clock(const Unit *u, const ExecContext *c) { |
fc64760d KK |
1644 | assert(u); |
1645 | assert(c); | |
1646 | ||
1647 | if (!c->protect_clock) | |
1648 | return 0; | |
1649 | ||
1650 | if (skip_seccomp_unavailable(u, "ProtectClock=")) | |
1651 | return 0; | |
1652 | ||
1653 | return seccomp_load_syscall_filter_set(SCMP_ACT_ALLOW, syscall_filter_sets + SYSCALL_FILTER_SET_CLOCK, SCMP_ACT_ERRNO(EPERM), false); | |
1654 | } | |
1655 | ||
59e856c7 | 1656 | static int apply_private_devices(const Unit *u, const ExecContext *c) { |
469830d1 | 1657 | assert(u); |
ba128bb8 LP |
1658 | assert(c); |
1659 | ||
8f81a5f6 | 1660 | /* If PrivateDevices= is set, also turn off iopl and all @raw-io syscalls. */ |
ba128bb8 | 1661 | |
469830d1 LP |
1662 | if (!c->private_devices) |
1663 | return 0; | |
1664 | ||
ba128bb8 LP |
1665 | if (skip_seccomp_unavailable(u, "PrivateDevices=")) |
1666 | return 0; | |
1667 | ||
b54f36c6 | 1668 | return seccomp_load_syscall_filter_set(SCMP_ACT_ALLOW, syscall_filter_sets + SYSCALL_FILTER_SET_RAW_IO, SCMP_ACT_ERRNO(EPERM), false); |
ba128bb8 LP |
1669 | } |
1670 | ||
34cf6c43 | 1671 | static int apply_restrict_namespaces(const Unit *u, const ExecContext *c) { |
469830d1 | 1672 | assert(u); |
add00535 LP |
1673 | assert(c); |
1674 | ||
1675 | if (!exec_context_restrict_namespaces_set(c)) | |
1676 | return 0; | |
1677 | ||
1678 | if (skip_seccomp_unavailable(u, "RestrictNamespaces=")) | |
1679 | return 0; | |
1680 | ||
1681 | return seccomp_restrict_namespaces(c->restrict_namespaces); | |
1682 | } | |
1683 | ||
78e864e5 | 1684 | static int apply_lock_personality(const Unit* u, const ExecContext *c) { |
e8132d63 LP |
1685 | unsigned long personality; |
1686 | int r; | |
78e864e5 TM |
1687 | |
1688 | assert(u); | |
1689 | assert(c); | |
1690 | ||
1691 | if (!c->lock_personality) | |
1692 | return 0; | |
1693 | ||
1694 | if (skip_seccomp_unavailable(u, "LockPersonality=")) | |
1695 | return 0; | |
1696 | ||
e8132d63 LP |
1697 | personality = c->personality; |
1698 | ||
1699 | /* If personality is not specified, use either PER_LINUX or PER_LINUX32 depending on what is currently set. */ | |
1700 | if (personality == PERSONALITY_INVALID) { | |
1701 | ||
1702 | r = opinionated_personality(&personality); | |
1703 | if (r < 0) | |
1704 | return r; | |
1705 | } | |
78e864e5 TM |
1706 | |
1707 | return seccomp_lock_personality(personality); | |
1708 | } | |
1709 | ||
c0467cf3 | 1710 | #endif |
8351ceae | 1711 | |
daf8f72b | 1712 | static int apply_protect_hostname(const Unit *u, const ExecContext *c, int *ret_exit_status) { |
daf8f72b LP |
1713 | assert(u); |
1714 | assert(c); | |
1715 | ||
1716 | if (!c->protect_hostname) | |
1717 | return 0; | |
1718 | ||
1719 | if (ns_type_supported(NAMESPACE_UTS)) { | |
1720 | if (unshare(CLONE_NEWUTS) < 0) { | |
1721 | if (!ERRNO_IS_NOT_SUPPORTED(errno) && !ERRNO_IS_PRIVILEGE(errno)) { | |
1722 | *ret_exit_status = EXIT_NAMESPACE; | |
1723 | return log_unit_error_errno(u, errno, "Failed to set up UTS namespacing: %m"); | |
1724 | } | |
1725 | ||
1726 | log_unit_warning(u, "ProtectHostname=yes is configured, but UTS namespace setup is prohibited (container manager?), ignoring namespace setup."); | |
1727 | } | |
1728 | } else | |
1729 | log_unit_warning(u, "ProtectHostname=yes is configured, but the kernel does not support UTS namespaces, ignoring namespace setup."); | |
1730 | ||
1731 | #if HAVE_SECCOMP | |
8f3e342f ZJS |
1732 | int r; |
1733 | ||
daf8f72b LP |
1734 | if (skip_seccomp_unavailable(u, "ProtectHostname=")) |
1735 | return 0; | |
1736 | ||
1737 | r = seccomp_protect_hostname(); | |
1738 | if (r < 0) { | |
1739 | *ret_exit_status = EXIT_SECCOMP; | |
1740 | return log_unit_error_errno(u, r, "Failed to apply hostname restrictions: %m"); | |
1741 | } | |
1742 | #endif | |
1743 | ||
1744 | return 0; | |
1745 | } | |
1746 | ||
3042bbeb | 1747 | static void do_idle_pipe_dance(int idle_pipe[static 4]) { |
31a7eb86 ZJS |
1748 | assert(idle_pipe); |
1749 | ||
54eb2300 LP |
1750 | idle_pipe[1] = safe_close(idle_pipe[1]); |
1751 | idle_pipe[2] = safe_close(idle_pipe[2]); | |
31a7eb86 ZJS |
1752 | |
1753 | if (idle_pipe[0] >= 0) { | |
1754 | int r; | |
1755 | ||
1756 | r = fd_wait_for_event(idle_pipe[0], POLLHUP, IDLE_TIMEOUT_USEC); | |
1757 | ||
1758 | if (idle_pipe[3] >= 0 && r == 0 /* timeout */) { | |
c7cc737f LP |
1759 | ssize_t n; |
1760 | ||
31a7eb86 | 1761 | /* Signal systemd that we are bored and want to continue. */ |
c7cc737f LP |
1762 | n = write(idle_pipe[3], "x", 1); |
1763 | if (n > 0) | |
cd972d69 | 1764 | /* Wait for systemd to react to the signal above. */ |
54756dce | 1765 | (void) fd_wait_for_event(idle_pipe[0], POLLHUP, IDLE_TIMEOUT2_USEC); |
31a7eb86 ZJS |
1766 | } |
1767 | ||
54eb2300 | 1768 | idle_pipe[0] = safe_close(idle_pipe[0]); |
31a7eb86 ZJS |
1769 | |
1770 | } | |
1771 | ||
54eb2300 | 1772 | idle_pipe[3] = safe_close(idle_pipe[3]); |
31a7eb86 ZJS |
1773 | } |
1774 | ||
fb2042dd YW |
1775 | static const char *exec_directory_env_name_to_string(ExecDirectoryType t); |
1776 | ||
7cae38c4 | 1777 | static int build_environment( |
34cf6c43 | 1778 | const Unit *u, |
9fa95f85 | 1779 | const ExecContext *c, |
1e22b5cd | 1780 | const ExecParameters *p, |
da6053d0 | 1781 | size_t n_fds, |
7cae38c4 LP |
1782 | const char *home, |
1783 | const char *username, | |
1784 | const char *shell, | |
7bce046b LP |
1785 | dev_t journal_stream_dev, |
1786 | ino_t journal_stream_ino, | |
7cae38c4 LP |
1787 | char ***ret) { |
1788 | ||
1789 | _cleanup_strv_free_ char **our_env = NULL; | |
da6053d0 | 1790 | size_t n_env = 0; |
7cae38c4 LP |
1791 | char *x; |
1792 | ||
4b58153d | 1793 | assert(u); |
7cae38c4 | 1794 | assert(c); |
7c1cb6f1 | 1795 | assert(p); |
7cae38c4 LP |
1796 | assert(ret); |
1797 | ||
dc4e2940 | 1798 | #define N_ENV_VARS 17 |
8d5bb13d | 1799 | our_env = new0(char*, N_ENV_VARS + _EXEC_DIRECTORY_TYPE_MAX); |
7cae38c4 LP |
1800 | if (!our_env) |
1801 | return -ENOMEM; | |
1802 | ||
1803 | if (n_fds > 0) { | |
8dd4c05b LP |
1804 | _cleanup_free_ char *joined = NULL; |
1805 | ||
df0ff127 | 1806 | if (asprintf(&x, "LISTEN_PID="PID_FMT, getpid_cached()) < 0) |
7cae38c4 LP |
1807 | return -ENOMEM; |
1808 | our_env[n_env++] = x; | |
1809 | ||
da6053d0 | 1810 | if (asprintf(&x, "LISTEN_FDS=%zu", n_fds) < 0) |
7cae38c4 LP |
1811 | return -ENOMEM; |
1812 | our_env[n_env++] = x; | |
8dd4c05b | 1813 | |
1e22b5cd | 1814 | joined = strv_join(p->fd_names, ":"); |
8dd4c05b LP |
1815 | if (!joined) |
1816 | return -ENOMEM; | |
1817 | ||
605405c6 | 1818 | x = strjoin("LISTEN_FDNAMES=", joined); |
8dd4c05b LP |
1819 | if (!x) |
1820 | return -ENOMEM; | |
1821 | our_env[n_env++] = x; | |
7cae38c4 LP |
1822 | } |
1823 | ||
b08af3b1 | 1824 | if ((p->flags & EXEC_SET_WATCHDOG) && p->watchdog_usec > 0) { |
df0ff127 | 1825 | if (asprintf(&x, "WATCHDOG_PID="PID_FMT, getpid_cached()) < 0) |
09812eb7 LP |
1826 | return -ENOMEM; |
1827 | our_env[n_env++] = x; | |
1828 | ||
1e22b5cd | 1829 | if (asprintf(&x, "WATCHDOG_USEC="USEC_FMT, p->watchdog_usec) < 0) |
09812eb7 LP |
1830 | return -ENOMEM; |
1831 | our_env[n_env++] = x; | |
1832 | } | |
1833 | ||
fd63e712 LP |
1834 | /* If this is D-Bus, tell the nss-systemd module, since it relies on being able to use D-Bus look up dynamic |
1835 | * users via PID 1, possibly dead-locking the dbus daemon. This way it will not use D-Bus to resolve names, but | |
1836 | * check the database directly. */ | |
ac647978 | 1837 | if (p->flags & EXEC_NSS_BYPASS_BUS) { |
fd63e712 LP |
1838 | x = strdup("SYSTEMD_NSS_BYPASS_BUS=1"); |
1839 | if (!x) | |
1840 | return -ENOMEM; | |
1841 | our_env[n_env++] = x; | |
1842 | } | |
1843 | ||
7cae38c4 | 1844 | if (home) { |
b910cc72 | 1845 | x = strjoin("HOME=", home); |
7cae38c4 LP |
1846 | if (!x) |
1847 | return -ENOMEM; | |
7bbead1d | 1848 | |
4ff361cc | 1849 | path_simplify(x + 5); |
7cae38c4 LP |
1850 | our_env[n_env++] = x; |
1851 | } | |
1852 | ||
1853 | if (username) { | |
b910cc72 | 1854 | x = strjoin("LOGNAME=", username); |
7cae38c4 LP |
1855 | if (!x) |
1856 | return -ENOMEM; | |
1857 | our_env[n_env++] = x; | |
1858 | ||
b910cc72 | 1859 | x = strjoin("USER=", username); |
7cae38c4 LP |
1860 | if (!x) |
1861 | return -ENOMEM; | |
1862 | our_env[n_env++] = x; | |
1863 | } | |
1864 | ||
1865 | if (shell) { | |
b910cc72 | 1866 | x = strjoin("SHELL=", shell); |
7cae38c4 LP |
1867 | if (!x) |
1868 | return -ENOMEM; | |
7bbead1d | 1869 | |
4ff361cc | 1870 | path_simplify(x + 6); |
7cae38c4 LP |
1871 | our_env[n_env++] = x; |
1872 | } | |
1873 | ||
4b58153d LP |
1874 | if (!sd_id128_is_null(u->invocation_id)) { |
1875 | if (asprintf(&x, "INVOCATION_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(u->invocation_id)) < 0) | |
1876 | return -ENOMEM; | |
1877 | ||
1878 | our_env[n_env++] = x; | |
1879 | } | |
1880 | ||
6af760f3 LP |
1881 | if (exec_context_needs_term(c)) { |
1882 | const char *tty_path, *term = NULL; | |
1883 | ||
1884 | tty_path = exec_context_tty_path(c); | |
1885 | ||
e8cf09b2 LP |
1886 | /* If we are forked off PID 1 and we are supposed to operate on /dev/console, then let's try |
1887 | * to inherit the $TERM set for PID 1. This is useful for containers so that the $TERM the | |
1888 | * container manager passes to PID 1 ends up all the way in the console login shown. */ | |
6af760f3 | 1889 | |
e8cf09b2 | 1890 | if (path_equal_ptr(tty_path, "/dev/console") && getppid() == 1) |
6af760f3 | 1891 | term = getenv("TERM"); |
e8cf09b2 | 1892 | |
6af760f3 LP |
1893 | if (!term) |
1894 | term = default_term_for_tty(tty_path); | |
7cae38c4 | 1895 | |
b910cc72 | 1896 | x = strjoin("TERM=", term); |
7cae38c4 LP |
1897 | if (!x) |
1898 | return -ENOMEM; | |
1899 | our_env[n_env++] = x; | |
1900 | } | |
1901 | ||
7bce046b LP |
1902 | if (journal_stream_dev != 0 && journal_stream_ino != 0) { |
1903 | if (asprintf(&x, "JOURNAL_STREAM=" DEV_FMT ":" INO_FMT, journal_stream_dev, journal_stream_ino) < 0) | |
1904 | return -ENOMEM; | |
1905 | ||
1906 | our_env[n_env++] = x; | |
1907 | } | |
1908 | ||
91dd5f7c LP |
1909 | if (c->log_namespace) { |
1910 | x = strjoin("LOG_NAMESPACE=", c->log_namespace); | |
1911 | if (!x) | |
1912 | return -ENOMEM; | |
1913 | ||
1914 | our_env[n_env++] = x; | |
1915 | } | |
1916 | ||
5b10116e | 1917 | for (ExecDirectoryType t = 0; t < _EXEC_DIRECTORY_TYPE_MAX; t++) { |
fb2042dd YW |
1918 | _cleanup_free_ char *pre = NULL, *joined = NULL; |
1919 | const char *n; | |
1920 | ||
1921 | if (!p->prefix[t]) | |
1922 | continue; | |
1923 | ||
1924 | if (strv_isempty(c->directories[t].paths)) | |
1925 | continue; | |
1926 | ||
1927 | n = exec_directory_env_name_to_string(t); | |
1928 | if (!n) | |
1929 | continue; | |
1930 | ||
1931 | pre = strjoin(p->prefix[t], "/"); | |
1932 | if (!pre) | |
1933 | return -ENOMEM; | |
1934 | ||
48904c8b | 1935 | joined = strv_join_full(c->directories[t].paths, ":", pre, true); |
fb2042dd YW |
1936 | if (!joined) |
1937 | return -ENOMEM; | |
1938 | ||
1939 | x = strjoin(n, "=", joined); | |
1940 | if (!x) | |
1941 | return -ENOMEM; | |
1942 | ||
1943 | our_env[n_env++] = x; | |
1944 | } | |
1945 | ||
bb0c0d6f LP |
1946 | if (exec_context_has_credentials(c) && p->prefix[EXEC_DIRECTORY_RUNTIME]) { |
1947 | x = strjoin("CREDENTIALS_DIRECTORY=", p->prefix[EXEC_DIRECTORY_RUNTIME], "/credentials/", u->id); | |
1948 | if (!x) | |
1949 | return -ENOMEM; | |
1950 | ||
1951 | our_env[n_env++] = x; | |
1952 | } | |
1953 | ||
dc4e2940 YW |
1954 | if (asprintf(&x, "SYSTEMD_EXEC_PID=" PID_FMT, getpid_cached()) < 0) |
1955 | return -ENOMEM; | |
1956 | ||
1957 | our_env[n_env++] = x; | |
1958 | ||
7cae38c4 | 1959 | our_env[n_env++] = NULL; |
8d5bb13d LP |
1960 | assert(n_env <= N_ENV_VARS + _EXEC_DIRECTORY_TYPE_MAX); |
1961 | #undef N_ENV_VARS | |
7cae38c4 | 1962 | |
ae2a15bc | 1963 | *ret = TAKE_PTR(our_env); |
7cae38c4 LP |
1964 | |
1965 | return 0; | |
1966 | } | |
1967 | ||
b4c14404 FB |
1968 | static int build_pass_environment(const ExecContext *c, char ***ret) { |
1969 | _cleanup_strv_free_ char **pass_env = NULL; | |
319a4f4b | 1970 | size_t n_env = 0; |
b4c14404 FB |
1971 | char **i; |
1972 | ||
1973 | STRV_FOREACH(i, c->pass_environment) { | |
1974 | _cleanup_free_ char *x = NULL; | |
1975 | char *v; | |
1976 | ||
1977 | v = getenv(*i); | |
1978 | if (!v) | |
1979 | continue; | |
605405c6 | 1980 | x = strjoin(*i, "=", v); |
b4c14404 FB |
1981 | if (!x) |
1982 | return -ENOMEM; | |
00819cc1 | 1983 | |
319a4f4b | 1984 | if (!GREEDY_REALLOC(pass_env, n_env + 2)) |
b4c14404 | 1985 | return -ENOMEM; |
00819cc1 | 1986 | |
1cc6c93a | 1987 | pass_env[n_env++] = TAKE_PTR(x); |
b4c14404 | 1988 | pass_env[n_env] = NULL; |
b4c14404 FB |
1989 | } |
1990 | ||
ae2a15bc | 1991 | *ret = TAKE_PTR(pass_env); |
b4c14404 FB |
1992 | |
1993 | return 0; | |
1994 | } | |
1995 | ||
5e8deb94 | 1996 | bool exec_needs_mount_namespace( |
8b44a3d2 LP |
1997 | const ExecContext *context, |
1998 | const ExecParameters *params, | |
4657abb5 | 1999 | const ExecRuntime *runtime) { |
8b44a3d2 LP |
2000 | |
2001 | assert(context); | |
8b44a3d2 | 2002 | |
915e6d16 LP |
2003 | if (context->root_image) |
2004 | return true; | |
2005 | ||
2a624c36 AP |
2006 | if (!strv_isempty(context->read_write_paths) || |
2007 | !strv_isempty(context->read_only_paths) || | |
ddc155b2 TM |
2008 | !strv_isempty(context->inaccessible_paths) || |
2009 | !strv_isempty(context->exec_paths) || | |
2010 | !strv_isempty(context->no_exec_paths)) | |
8b44a3d2 LP |
2011 | return true; |
2012 | ||
42b1d8e0 | 2013 | if (context->n_bind_mounts > 0) |
d2d6c096 LP |
2014 | return true; |
2015 | ||
2abd4e38 YW |
2016 | if (context->n_temporary_filesystems > 0) |
2017 | return true; | |
2018 | ||
b3d13314 LB |
2019 | if (context->n_mount_images > 0) |
2020 | return true; | |
2021 | ||
93f59701 LB |
2022 | if (context->n_extension_images > 0) |
2023 | return true; | |
2024 | ||
37ed15d7 | 2025 | if (!IN_SET(context->mount_flags, 0, MS_SHARED)) |
8b44a3d2 LP |
2026 | return true; |
2027 | ||
2028 | if (context->private_tmp && runtime && (runtime->tmp_dir || runtime->var_tmp_dir)) | |
2029 | return true; | |
2030 | ||
8b44a3d2 | 2031 | if (context->private_devices || |
228af36f | 2032 | context->private_mounts || |
8b44a3d2 | 2033 | context->protect_system != PROTECT_SYSTEM_NO || |
59eeb84b LP |
2034 | context->protect_home != PROTECT_HOME_NO || |
2035 | context->protect_kernel_tunables || | |
c575770b | 2036 | context->protect_kernel_modules || |
94a7b275 | 2037 | context->protect_kernel_logs || |
4e399953 LP |
2038 | context->protect_control_groups || |
2039 | context->protect_proc != PROTECT_PROC_DEFAULT || | |
80271a44 XR |
2040 | context->proc_subset != PROC_SUBSET_ALL || |
2041 | context->private_ipc || | |
2042 | context->ipc_namespace_path) | |
8b44a3d2 LP |
2043 | return true; |
2044 | ||
37c56f89 | 2045 | if (context->root_directory) { |
5e98086d | 2046 | if (exec_context_get_effective_mount_apivfs(context)) |
37c56f89 YW |
2047 | return true; |
2048 | ||
5b10116e | 2049 | for (ExecDirectoryType t = 0; t < _EXEC_DIRECTORY_TYPE_MAX; t++) { |
5e8deb94 | 2050 | if (params && !params->prefix[t]) |
37c56f89 YW |
2051 | continue; |
2052 | ||
2053 | if (!strv_isempty(context->directories[t].paths)) | |
2054 | return true; | |
2055 | } | |
2056 | } | |
5d997827 | 2057 | |
42b1d8e0 | 2058 | if (context->dynamic_user && |
b43ee82f | 2059 | (!strv_isempty(context->directories[EXEC_DIRECTORY_STATE].paths) || |
42b1d8e0 YW |
2060 | !strv_isempty(context->directories[EXEC_DIRECTORY_CACHE].paths) || |
2061 | !strv_isempty(context->directories[EXEC_DIRECTORY_LOGS].paths))) | |
2062 | return true; | |
2063 | ||
91dd5f7c LP |
2064 | if (context->log_namespace) |
2065 | return true; | |
2066 | ||
8b44a3d2 LP |
2067 | return false; |
2068 | } | |
2069 | ||
5749f855 | 2070 | static int setup_private_users(uid_t ouid, gid_t ogid, uid_t uid, gid_t gid) { |
d251207d LP |
2071 | _cleanup_free_ char *uid_map = NULL, *gid_map = NULL; |
2072 | _cleanup_close_pair_ int errno_pipe[2] = { -1, -1 }; | |
2073 | _cleanup_close_ int unshare_ready_fd = -1; | |
2074 | _cleanup_(sigkill_waitp) pid_t pid = 0; | |
2075 | uint64_t c = 1; | |
d251207d LP |
2076 | ssize_t n; |
2077 | int r; | |
2078 | ||
5749f855 AZ |
2079 | /* Set up a user namespace and map the original UID/GID (IDs from before any user or group changes, i.e. |
2080 | * the IDs from the user or system manager(s)) to itself, the selected UID/GID to itself, and everything else to | |
d251207d LP |
2081 | * nobody. In order to be able to write this mapping we need CAP_SETUID in the original user namespace, which |
2082 | * we however lack after opening the user namespace. To work around this we fork() a temporary child process, | |
2083 | * which waits for the parent to create the new user namespace while staying in the original namespace. The | |
2084 | * child then writes the UID mapping, under full privileges. The parent waits for the child to finish and | |
5749f855 AZ |
2085 | * continues execution normally. |
2086 | * For unprivileged users (i.e. without capabilities), the root to root mapping is excluded. As such, it | |
2087 | * does not need CAP_SETUID to write the single line mapping to itself. */ | |
d251207d | 2088 | |
5749f855 AZ |
2089 | /* Can only set up multiple mappings with CAP_SETUID. */ |
2090 | if (have_effective_cap(CAP_SETUID) && uid != ouid && uid_is_valid(uid)) | |
587ab01b | 2091 | r = asprintf(&uid_map, |
5749f855 | 2092 | UID_FMT " " UID_FMT " 1\n" /* Map $OUID → $OUID */ |
587ab01b | 2093 | UID_FMT " " UID_FMT " 1\n", /* Map $UID → $UID */ |
5749f855 AZ |
2094 | ouid, ouid, uid, uid); |
2095 | else | |
2096 | r = asprintf(&uid_map, | |
2097 | UID_FMT " " UID_FMT " 1\n", /* Map $OUID → $OUID */ | |
2098 | ouid, ouid); | |
d251207d | 2099 | |
5749f855 AZ |
2100 | if (r < 0) |
2101 | return -ENOMEM; | |
2102 | ||
2103 | /* Can only set up multiple mappings with CAP_SETGID. */ | |
2104 | if (have_effective_cap(CAP_SETGID) && gid != ogid && gid_is_valid(gid)) | |
587ab01b | 2105 | r = asprintf(&gid_map, |
5749f855 | 2106 | GID_FMT " " GID_FMT " 1\n" /* Map $OGID → $OGID */ |
587ab01b | 2107 | GID_FMT " " GID_FMT " 1\n", /* Map $GID → $GID */ |
5749f855 AZ |
2108 | ogid, ogid, gid, gid); |
2109 | else | |
2110 | r = asprintf(&gid_map, | |
2111 | GID_FMT " " GID_FMT " 1\n", /* Map $OGID -> $OGID */ | |
2112 | ogid, ogid); | |
2113 | ||
2114 | if (r < 0) | |
2115 | return -ENOMEM; | |
d251207d LP |
2116 | |
2117 | /* Create a communication channel so that the parent can tell the child when it finished creating the user | |
2118 | * namespace. */ | |
2119 | unshare_ready_fd = eventfd(0, EFD_CLOEXEC); | |
2120 | if (unshare_ready_fd < 0) | |
2121 | return -errno; | |
2122 | ||
2123 | /* Create a communication channel so that the child can tell the parent a proper error code in case it | |
2124 | * failed. */ | |
2125 | if (pipe2(errno_pipe, O_CLOEXEC) < 0) | |
2126 | return -errno; | |
2127 | ||
4c253ed1 LP |
2128 | r = safe_fork("(sd-userns)", FORK_RESET_SIGNALS|FORK_DEATHSIG, &pid); |
2129 | if (r < 0) | |
2130 | return r; | |
2131 | if (r == 0) { | |
d251207d LP |
2132 | _cleanup_close_ int fd = -1; |
2133 | const char *a; | |
2134 | pid_t ppid; | |
2135 | ||
2136 | /* Child process, running in the original user namespace. Let's update the parent's UID/GID map from | |
2137 | * here, after the parent opened its own user namespace. */ | |
2138 | ||
2139 | ppid = getppid(); | |
2140 | errno_pipe[0] = safe_close(errno_pipe[0]); | |
2141 | ||
2142 | /* Wait until the parent unshared the user namespace */ | |
2143 | if (read(unshare_ready_fd, &c, sizeof(c)) < 0) { | |
2144 | r = -errno; | |
2145 | goto child_fail; | |
2146 | } | |
2147 | ||
2148 | /* Disable the setgroups() system call in the child user namespace, for good. */ | |
2149 | a = procfs_file_alloca(ppid, "setgroups"); | |
2150 | fd = open(a, O_WRONLY|O_CLOEXEC); | |
2151 | if (fd < 0) { | |
2152 | if (errno != ENOENT) { | |
2153 | r = -errno; | |
2154 | goto child_fail; | |
2155 | } | |
2156 | ||
2157 | /* If the file is missing the kernel is too old, let's continue anyway. */ | |
2158 | } else { | |
2159 | if (write(fd, "deny\n", 5) < 0) { | |
2160 | r = -errno; | |
2161 | goto child_fail; | |
2162 | } | |
2163 | ||
2164 | fd = safe_close(fd); | |
2165 | } | |
2166 | ||
2167 | /* First write the GID map */ | |
2168 | a = procfs_file_alloca(ppid, "gid_map"); | |
2169 | fd = open(a, O_WRONLY|O_CLOEXEC); | |
2170 | if (fd < 0) { | |
2171 | r = -errno; | |
2172 | goto child_fail; | |
2173 | } | |
2174 | if (write(fd, gid_map, strlen(gid_map)) < 0) { | |
2175 | r = -errno; | |
2176 | goto child_fail; | |
2177 | } | |
2178 | fd = safe_close(fd); | |
2179 | ||
2180 | /* The write the UID map */ | |
2181 | a = procfs_file_alloca(ppid, "uid_map"); | |
2182 | fd = open(a, O_WRONLY|O_CLOEXEC); | |
2183 | if (fd < 0) { | |
2184 | r = -errno; | |
2185 | goto child_fail; | |
2186 | } | |
2187 | if (write(fd, uid_map, strlen(uid_map)) < 0) { | |
2188 | r = -errno; | |
2189 | goto child_fail; | |
2190 | } | |
2191 | ||
2192 | _exit(EXIT_SUCCESS); | |
2193 | ||
2194 | child_fail: | |
2195 | (void) write(errno_pipe[1], &r, sizeof(r)); | |
2196 | _exit(EXIT_FAILURE); | |
2197 | } | |
2198 | ||
2199 | errno_pipe[1] = safe_close(errno_pipe[1]); | |
2200 | ||
2201 | if (unshare(CLONE_NEWUSER) < 0) | |
2202 | return -errno; | |
2203 | ||
2204 | /* Let the child know that the namespace is ready now */ | |
2205 | if (write(unshare_ready_fd, &c, sizeof(c)) < 0) | |
2206 | return -errno; | |
2207 | ||
2208 | /* Try to read an error code from the child */ | |
2209 | n = read(errno_pipe[0], &r, sizeof(r)); | |
2210 | if (n < 0) | |
2211 | return -errno; | |
2212 | if (n == sizeof(r)) { /* an error code was sent to us */ | |
2213 | if (r < 0) | |
2214 | return r; | |
2215 | return -EIO; | |
2216 | } | |
2217 | if (n != 0) /* on success we should have read 0 bytes */ | |
2218 | return -EIO; | |
2219 | ||
2e87a1fd LP |
2220 | r = wait_for_terminate_and_check("(sd-userns)", pid, 0); |
2221 | pid = 0; | |
d251207d LP |
2222 | if (r < 0) |
2223 | return r; | |
2e87a1fd | 2224 | if (r != EXIT_SUCCESS) /* If something strange happened with the child, let's consider this fatal, too */ |
d251207d LP |
2225 | return -EIO; |
2226 | ||
2227 | return 0; | |
2228 | } | |
2229 | ||
494d0247 YW |
2230 | static bool exec_directory_is_private(const ExecContext *context, ExecDirectoryType type) { |
2231 | if (!context->dynamic_user) | |
2232 | return false; | |
2233 | ||
2234 | if (type == EXEC_DIRECTORY_CONFIGURATION) | |
2235 | return false; | |
2236 | ||
2237 | if (type == EXEC_DIRECTORY_RUNTIME && context->runtime_directory_preserve_mode == EXEC_PRESERVE_NO) | |
2238 | return false; | |
2239 | ||
2240 | return true; | |
2241 | } | |
2242 | ||
3536f49e | 2243 | static int setup_exec_directory( |
07689d5d LP |
2244 | const ExecContext *context, |
2245 | const ExecParameters *params, | |
2246 | uid_t uid, | |
3536f49e | 2247 | gid_t gid, |
3536f49e YW |
2248 | ExecDirectoryType type, |
2249 | int *exit_status) { | |
07689d5d | 2250 | |
72fd1768 | 2251 | static const int exit_status_table[_EXEC_DIRECTORY_TYPE_MAX] = { |
3536f49e YW |
2252 | [EXEC_DIRECTORY_RUNTIME] = EXIT_RUNTIME_DIRECTORY, |
2253 | [EXEC_DIRECTORY_STATE] = EXIT_STATE_DIRECTORY, | |
2254 | [EXEC_DIRECTORY_CACHE] = EXIT_CACHE_DIRECTORY, | |
2255 | [EXEC_DIRECTORY_LOGS] = EXIT_LOGS_DIRECTORY, | |
2256 | [EXEC_DIRECTORY_CONFIGURATION] = EXIT_CONFIGURATION_DIRECTORY, | |
2257 | }; | |
07689d5d LP |
2258 | char **rt; |
2259 | int r; | |
2260 | ||
2261 | assert(context); | |
2262 | assert(params); | |
72fd1768 | 2263 | assert(type >= 0 && type < _EXEC_DIRECTORY_TYPE_MAX); |
3536f49e | 2264 | assert(exit_status); |
07689d5d | 2265 | |
3536f49e YW |
2266 | if (!params->prefix[type]) |
2267 | return 0; | |
2268 | ||
8679efde | 2269 | if (params->flags & EXEC_CHOWN_DIRECTORIES) { |
3536f49e YW |
2270 | if (!uid_is_valid(uid)) |
2271 | uid = 0; | |
2272 | if (!gid_is_valid(gid)) | |
2273 | gid = 0; | |
2274 | } | |
2275 | ||
2276 | STRV_FOREACH(rt, context->directories[type].paths) { | |
6c47cd7d | 2277 | _cleanup_free_ char *p = NULL, *pp = NULL; |
07689d5d | 2278 | |
edbfeb12 | 2279 | p = path_join(params->prefix[type], *rt); |
3536f49e YW |
2280 | if (!p) { |
2281 | r = -ENOMEM; | |
2282 | goto fail; | |
2283 | } | |
07689d5d | 2284 | |
23a7448e YW |
2285 | r = mkdir_parents_label(p, 0755); |
2286 | if (r < 0) | |
3536f49e | 2287 | goto fail; |
23a7448e | 2288 | |
494d0247 | 2289 | if (exec_directory_is_private(context, type)) { |
3f5b1508 LP |
2290 | /* So, here's one extra complication when dealing with DynamicUser=1 units. In that |
2291 | * case we want to avoid leaving a directory around fully accessible that is owned by | |
2292 | * a dynamic user whose UID is later on reused. To lock this down we use the same | |
2293 | * trick used by container managers to prohibit host users to get access to files of | |
2294 | * the same UID in containers: we place everything inside a directory that has an | |
2295 | * access mode of 0700 and is owned root:root, so that it acts as security boundary | |
2296 | * for unprivileged host code. We then use fs namespacing to make this directory | |
2297 | * permeable for the service itself. | |
6c47cd7d | 2298 | * |
3f5b1508 LP |
2299 | * Specifically: for a service which wants a special directory "foo/" we first create |
2300 | * a directory "private/" with access mode 0700 owned by root:root. Then we place | |
2301 | * "foo" inside of that directory (i.e. "private/foo/"), and make "foo" a symlink to | |
2302 | * "private/foo". This way, privileged host users can access "foo/" as usual, but | |
2303 | * unprivileged host users can't look into it. Inside of the namespace of the unit | |
2304 | * "private/" is replaced by a more liberally accessible tmpfs, into which the host's | |
2305 | * "private/foo/" is mounted under the same name, thus disabling the access boundary | |
2306 | * for the service and making sure it only gets access to the dirs it needs but no | |
2307 | * others. Tricky? Yes, absolutely, but it works! | |
6c47cd7d | 2308 | * |
3f5b1508 LP |
2309 | * Note that we don't do this for EXEC_DIRECTORY_CONFIGURATION as that's assumed not |
2310 | * to be owned by the service itself. | |
2311 | * | |
2312 | * Also, note that we don't do this for EXEC_DIRECTORY_RUNTIME as that's often used | |
2313 | * for sharing files or sockets with other services. */ | |
6c47cd7d | 2314 | |
4ede9802 LP |
2315 | pp = path_join(params->prefix[type], "private"); |
2316 | if (!pp) { | |
6c47cd7d LP |
2317 | r = -ENOMEM; |
2318 | goto fail; | |
2319 | } | |
2320 | ||
2321 | /* First set up private root if it doesn't exist yet, with access mode 0700 and owned by root:root */ | |
4ede9802 | 2322 | r = mkdir_safe_label(pp, 0700, 0, 0, MKDIR_WARN_MODE); |
6c47cd7d LP |
2323 | if (r < 0) |
2324 | goto fail; | |
2325 | ||
4ede9802 | 2326 | if (!path_extend(&pp, *rt)) { |
6c47cd7d LP |
2327 | r = -ENOMEM; |
2328 | goto fail; | |
2329 | } | |
2330 | ||
2331 | /* Create all directories between the configured directory and this private root, and mark them 0755 */ | |
2332 | r = mkdir_parents_label(pp, 0755); | |
2333 | if (r < 0) | |
2334 | goto fail; | |
2335 | ||
949befd3 LP |
2336 | if (is_dir(p, false) > 0 && |
2337 | (laccess(pp, F_OK) < 0 && errno == ENOENT)) { | |
2338 | ||
2339 | /* Hmm, the private directory doesn't exist yet, but the normal one exists? If so, move | |
2340 | * it over. Most likely the service has been upgraded from one that didn't use | |
2341 | * DynamicUser=1, to one that does. */ | |
2342 | ||
cf52c45d LP |
2343 | log_info("Found pre-existing public %s= directory %s, migrating to %s.\n" |
2344 | "Apparently, service previously had DynamicUser= turned off, and has now turned it on.", | |
2345 | exec_directory_type_to_string(type), p, pp); | |
2346 | ||
949befd3 LP |
2347 | if (rename(p, pp) < 0) { |
2348 | r = -errno; | |
2349 | goto fail; | |
2350 | } | |
2351 | } else { | |
2352 | /* Otherwise, create the actual directory for the service */ | |
2353 | ||
2354 | r = mkdir_label(pp, context->directories[type].mode); | |
2355 | if (r < 0 && r != -EEXIST) | |
2356 | goto fail; | |
2357 | } | |
6c47cd7d | 2358 | |
6c47cd7d | 2359 | /* And link it up from the original place */ |
6c9c51e5 | 2360 | r = symlink_idempotent(pp, p, true); |
6c47cd7d LP |
2361 | if (r < 0) |
2362 | goto fail; | |
2363 | ||
6c47cd7d | 2364 | } else { |
5c6d40d1 LP |
2365 | _cleanup_free_ char *target = NULL; |
2366 | ||
2367 | if (type != EXEC_DIRECTORY_CONFIGURATION && | |
2368 | readlink_and_make_absolute(p, &target) >= 0) { | |
578dc69f | 2369 | _cleanup_free_ char *q = NULL, *q_resolved = NULL, *target_resolved = NULL; |
5c6d40d1 LP |
2370 | |
2371 | /* This already exists and is a symlink? Interesting. Maybe it's one created | |
2193f17c LP |
2372 | * by DynamicUser=1 (see above)? |
2373 | * | |
2374 | * We do this for all directory types except for ConfigurationDirectory=, | |
2375 | * since they all support the private/ symlink logic at least in some | |
2376 | * configurations, see above. */ | |
5c6d40d1 | 2377 | |
578dc69f YW |
2378 | r = chase_symlinks(target, NULL, 0, &target_resolved, NULL); |
2379 | if (r < 0) | |
2380 | goto fail; | |
2381 | ||
5c6d40d1 LP |
2382 | q = path_join(params->prefix[type], "private", *rt); |
2383 | if (!q) { | |
2384 | r = -ENOMEM; | |
2385 | goto fail; | |
2386 | } | |
2387 | ||
578dc69f YW |
2388 | /* /var/lib or friends may be symlinks. So, let's chase them also. */ |
2389 | r = chase_symlinks(q, NULL, CHASE_NONEXISTENT, &q_resolved, NULL); | |
2390 | if (r < 0) | |
2391 | goto fail; | |
2392 | ||
2393 | if (path_equal(q_resolved, target_resolved)) { | |
5c6d40d1 LP |
2394 | |
2395 | /* Hmm, apparently DynamicUser= was once turned on for this service, | |
2396 | * but is no longer. Let's move the directory back up. */ | |
2397 | ||
cf52c45d LP |
2398 | log_info("Found pre-existing private %s= directory %s, migrating to %s.\n" |
2399 | "Apparently, service previously had DynamicUser= turned on, and has now turned it off.", | |
2400 | exec_directory_type_to_string(type), q, p); | |
2401 | ||
5c6d40d1 LP |
2402 | if (unlink(p) < 0) { |
2403 | r = -errno; | |
2404 | goto fail; | |
2405 | } | |
2406 | ||
2407 | if (rename(q, p) < 0) { | |
2408 | r = -errno; | |
2409 | goto fail; | |
2410 | } | |
2411 | } | |
2412 | } | |
2413 | ||
6c47cd7d | 2414 | r = mkdir_label(p, context->directories[type].mode); |
d484580c | 2415 | if (r < 0) { |
d484580c LP |
2416 | if (r != -EEXIST) |
2417 | goto fail; | |
2418 | ||
206e9864 LP |
2419 | if (type == EXEC_DIRECTORY_CONFIGURATION) { |
2420 | struct stat st; | |
2421 | ||
2422 | /* Don't change the owner/access mode of the configuration directory, | |
2423 | * as in the common case it is not written to by a service, and shall | |
2424 | * not be writable. */ | |
2425 | ||
2426 | if (stat(p, &st) < 0) { | |
2427 | r = -errno; | |
2428 | goto fail; | |
2429 | } | |
2430 | ||
2431 | /* Still complain if the access mode doesn't match */ | |
2432 | if (((st.st_mode ^ context->directories[type].mode) & 07777) != 0) | |
2433 | log_warning("%s \'%s\' already exists but the mode is different. " | |
2434 | "(File system: %o %sMode: %o)", | |
2435 | exec_directory_type_to_string(type), *rt, | |
2436 | st.st_mode & 07777, exec_directory_type_to_string(type), context->directories[type].mode & 07777); | |
2437 | ||
6cff72eb | 2438 | continue; |
206e9864 | 2439 | } |
6cff72eb | 2440 | } |
a1164ae3 | 2441 | } |
07689d5d | 2442 | |
206e9864 | 2443 | /* Lock down the access mode (we use chmod_and_chown() to make this idempotent. We don't |
5238e957 | 2444 | * specify UID/GID here, so that path_chown_recursive() can optimize things depending on the |
206e9864 LP |
2445 | * current UID/GID ownership.) */ |
2446 | r = chmod_and_chown(pp ?: p, context->directories[type].mode, UID_INVALID, GID_INVALID); | |
2447 | if (r < 0) | |
2448 | goto fail; | |
c71b2eb7 | 2449 | |
607b358e LP |
2450 | /* Then, change the ownership of the whole tree, if necessary. When dynamic users are used we |
2451 | * drop the suid/sgid bits, since we really don't want SUID/SGID files for dynamic UID/GID | |
2452 | * assignments to exist.*/ | |
2453 | r = path_chown_recursive(pp ?: p, uid, gid, context->dynamic_user ? 01777 : 07777); | |
07689d5d | 2454 | if (r < 0) |
3536f49e | 2455 | goto fail; |
07689d5d LP |
2456 | } |
2457 | ||
2458 | return 0; | |
3536f49e YW |
2459 | |
2460 | fail: | |
2461 | *exit_status = exit_status_table[type]; | |
3536f49e | 2462 | return r; |
07689d5d LP |
2463 | } |
2464 | ||
bb0c0d6f LP |
2465 | static int write_credential( |
2466 | int dfd, | |
2467 | const char *id, | |
2468 | const void *data, | |
2469 | size_t size, | |
2470 | uid_t uid, | |
2471 | bool ownership_ok) { | |
2472 | ||
2473 | _cleanup_(unlink_and_freep) char *tmp = NULL; | |
2474 | _cleanup_close_ int fd = -1; | |
2475 | int r; | |
2476 | ||
2477 | r = tempfn_random_child("", "cred", &tmp); | |
2478 | if (r < 0) | |
2479 | return r; | |
2480 | ||
2481 | fd = openat(dfd, tmp, O_CREAT|O_RDWR|O_CLOEXEC|O_EXCL|O_NOFOLLOW|O_NOCTTY, 0600); | |
2482 | if (fd < 0) { | |
2483 | tmp = mfree(tmp); | |
2484 | return -errno; | |
2485 | } | |
2486 | ||
2487 | r = loop_write(fd, data, size, /* do_pool = */ false); | |
2488 | if (r < 0) | |
2489 | return r; | |
2490 | ||
2491 | if (fchmod(fd, 0400) < 0) /* Take away "w" bit */ | |
2492 | return -errno; | |
2493 | ||
2494 | if (uid_is_valid(uid) && uid != getuid()) { | |
567aeb58 | 2495 | r = fd_add_uid_acl_permission(fd, uid, ACL_READ); |
bb0c0d6f LP |
2496 | if (r < 0) { |
2497 | if (!ERRNO_IS_NOT_SUPPORTED(r) && !ERRNO_IS_PRIVILEGE(r)) | |
2498 | return r; | |
2499 | ||
2500 | if (!ownership_ok) /* Ideally we use ACLs, since we can neatly express what we want | |
2501 | * to express: that the user gets read access and nothing | |
2502 | * else. But if the backing fs can't support that (e.g. ramfs) | |
2503 | * then we can use file ownership instead. But that's only safe if | |
2504 | * we can then re-mount the whole thing read-only, so that the | |
2505 | * user can no longer chmod() the file to gain write access. */ | |
2506 | return r; | |
2507 | ||
f5fbe71d | 2508 | if (fchown(fd, uid, GID_INVALID) < 0) |
bb0c0d6f LP |
2509 | return -errno; |
2510 | } | |
2511 | } | |
2512 | ||
2513 | if (renameat(dfd, tmp, dfd, id) < 0) | |
2514 | return -errno; | |
2515 | ||
2516 | tmp = mfree(tmp); | |
2517 | return 0; | |
2518 | } | |
2519 | ||
2520 | #define CREDENTIALS_BYTES_MAX (1024LU * 1024LU) /* Refuse to pass more than 1M, after all this is unswappable memory */ | |
2521 | ||
2522 | static int acquire_credentials( | |
2523 | const ExecContext *context, | |
2524 | const ExecParameters *params, | |
d3dcf4e3 | 2525 | const char *unit, |
bb0c0d6f LP |
2526 | const char *p, |
2527 | uid_t uid, | |
2528 | bool ownership_ok) { | |
2529 | ||
2530 | uint64_t left = CREDENTIALS_BYTES_MAX; | |
2531 | _cleanup_close_ int dfd = -1; | |
2532 | ExecSetCredential *sc; | |
2533 | char **id, **fn; | |
bb0c0d6f LP |
2534 | int r; |
2535 | ||
2536 | assert(context); | |
2537 | assert(p); | |
2538 | ||
2539 | dfd = open(p, O_DIRECTORY|O_CLOEXEC); | |
2540 | if (dfd < 0) | |
2541 | return -errno; | |
2542 | ||
69e3234d | 2543 | /* First we use the literally specified credentials. Note that they might be overridden again below, |
bb0c0d6f | 2544 | * and thus act as a "default" if the same credential is specified multiple times */ |
90e74a66 | 2545 | HASHMAP_FOREACH(sc, context->set_credentials) { |
bb0c0d6f LP |
2546 | size_t add; |
2547 | ||
2548 | add = strlen(sc->id) + sc->size; | |
2549 | if (add > left) | |
2550 | return -E2BIG; | |
2551 | ||
2552 | r = write_credential(dfd, sc->id, sc->data, sc->size, uid, ownership_ok); | |
2553 | if (r < 0) | |
2554 | return r; | |
2555 | ||
2556 | left -= add; | |
2557 | } | |
2558 | ||
2559 | /* Then, load credential off disk (or acquire via AF_UNIX socket) */ | |
2560 | STRV_FOREACH_PAIR(id, fn, context->load_credentials) { | |
2561 | ReadFullFileFlags flags = READ_FULL_FILE_SECURE; | |
2562 | _cleanup_(erase_and_freep) char *data = NULL; | |
d3dcf4e3 | 2563 | _cleanup_free_ char *j = NULL, *bindname = NULL; |
fc682be2 | 2564 | bool missing_ok = true; |
bb0c0d6f LP |
2565 | const char *source; |
2566 | size_t size, add; | |
2567 | ||
2568 | if (path_is_absolute(*fn)) { | |
2569 | /* If this is an absolute path, read the data directly from it, and support AF_UNIX sockets */ | |
2570 | source = *fn; | |
2571 | flags |= READ_FULL_FILE_CONNECT_SOCKET; | |
d3dcf4e3 LP |
2572 | |
2573 | /* Pass some minimal info about the unit and the credential name we are looking to acquire | |
2574 | * via the source socket address in case we read off an AF_UNIX socket. */ | |
2575 | if (asprintf(&bindname, "@%" PRIx64"/unit/%s/%s", random_u64(), unit, *id) < 0) | |
2576 | return -ENOMEM; | |
2577 | ||
fc682be2 LP |
2578 | missing_ok = false; |
2579 | ||
bb0c0d6f LP |
2580 | } else if (params->received_credentials) { |
2581 | /* If this is a relative path, take it relative to the credentials we received | |
2582 | * ourselves. We don't support the AF_UNIX stuff in this mode, since we are operating | |
2583 | * on a credential store, i.e. this is guaranteed to be regular files. */ | |
2584 | j = path_join(params->received_credentials, *fn); | |
2585 | if (!j) | |
2586 | return -ENOMEM; | |
2587 | ||
2588 | source = j; | |
2589 | } else | |
2590 | source = NULL; | |
2591 | ||
2592 | if (source) | |
986311c2 | 2593 | r = read_full_file_full(AT_FDCWD, source, UINT64_MAX, SIZE_MAX, flags, bindname, &data, &size); |
bb0c0d6f LP |
2594 | else |
2595 | r = -ENOENT; | |
fc682be2 LP |
2596 | if (r == -ENOENT && (missing_ok || faccessat(dfd, *id, F_OK, AT_SYMLINK_NOFOLLOW) >= 0)) { |
2597 | /* Make a missing inherited credential non-fatal, let's just continue. After all apps | |
2598 | * will get clear errors if we don't pass such a missing credential on as they | |
2599 | * themselves will get ENOENT when trying to read them, which should not be much | |
2600 | * worse than when we handle the error here and make it fatal. | |
2601 | * | |
2602 | * Also, if the source file doesn't exist, but we already acquired the key otherwise, | |
2603 | * then don't fail either. */ | |
2604 | log_debug_errno(r, "Couldn't read inherited credential '%s', skipping: %m", *fn); | |
bb0c0d6f | 2605 | continue; |
fc682be2 | 2606 | } |
bb0c0d6f | 2607 | if (r < 0) |
fc682be2 | 2608 | return log_debug_errno(r, "Failed to read credential '%s': %m", *fn); |
bb0c0d6f LP |
2609 | |
2610 | add = strlen(*id) + size; | |
2611 | if (add > left) | |
2612 | return -E2BIG; | |
2613 | ||
2614 | r = write_credential(dfd, *id, data, size, uid, ownership_ok); | |
2615 | if (r < 0) | |
2616 | return r; | |
2617 | ||
2618 | left -= add; | |
2619 | } | |
2620 | ||
2621 | if (fchmod(dfd, 0500) < 0) /* Now take away the "w" bit */ | |
2622 | return -errno; | |
2623 | ||
2624 | /* After we created all keys with the right perms, also make sure the credential store as a whole is | |
2625 | * accessible */ | |
2626 | ||
2627 | if (uid_is_valid(uid) && uid != getuid()) { | |
567aeb58 | 2628 | r = fd_add_uid_acl_permission(dfd, uid, ACL_READ | ACL_EXECUTE); |
bb0c0d6f LP |
2629 | if (r < 0) { |
2630 | if (!ERRNO_IS_NOT_SUPPORTED(r) && !ERRNO_IS_PRIVILEGE(r)) | |
2631 | return r; | |
2632 | ||
2633 | if (!ownership_ok) | |
2634 | return r; | |
2635 | ||
f5fbe71d | 2636 | if (fchown(dfd, uid, GID_INVALID) < 0) |
bb0c0d6f LP |
2637 | return -errno; |
2638 | } | |
2639 | } | |
2640 | ||
2641 | return 0; | |
2642 | } | |
2643 | ||
2644 | static int setup_credentials_internal( | |
2645 | const ExecContext *context, | |
2646 | const ExecParameters *params, | |
d3dcf4e3 | 2647 | const char *unit, |
bb0c0d6f LP |
2648 | const char *final, /* This is where the credential store shall eventually end up at */ |
2649 | const char *workspace, /* This is where we can prepare it before moving it to the final place */ | |
2650 | bool reuse_workspace, /* Whether to reuse any existing workspace mount if it already is a mount */ | |
2651 | bool must_mount, /* Whether to require that we mount something, it's not OK to use the plain directory fall back */ | |
2652 | uid_t uid) { | |
2653 | ||
2654 | int r, workspace_mounted; /* negative if we don't know yet whether we have/can mount something; true | |
2655 | * if we mounted something; false if we definitely can't mount anything */ | |
2656 | bool final_mounted; | |
2657 | const char *where; | |
2658 | ||
2659 | assert(context); | |
2660 | assert(final); | |
2661 | assert(workspace); | |
2662 | ||
2663 | if (reuse_workspace) { | |
2664 | r = path_is_mount_point(workspace, NULL, 0); | |
2665 | if (r < 0) | |
2666 | return r; | |
2667 | if (r > 0) | |
2668 | workspace_mounted = true; /* If this is already a mount, and we are supposed to reuse it, let's keep this in mind */ | |
2669 | else | |
2670 | workspace_mounted = -1; /* We need to figure out if we can mount something to the workspace */ | |
2671 | } else | |
2672 | workspace_mounted = -1; /* ditto */ | |
2673 | ||
2674 | r = path_is_mount_point(final, NULL, 0); | |
2675 | if (r < 0) | |
2676 | return r; | |
2677 | if (r > 0) { | |
2678 | /* If the final place already has something mounted, we use that. If the workspace also has | |
2679 | * something mounted we assume it's actually the same mount (but with MS_RDONLY | |
2680 | * different). */ | |
2681 | final_mounted = true; | |
2682 | ||
2683 | if (workspace_mounted < 0) { | |
2684 | /* If the final place is mounted, but the workspace we isn't, then let's bind mount | |
2685 | * the final version to the workspace, and make it writable, so that we can make | |
2686 | * changes */ | |
2687 | ||
21935150 LP |
2688 | r = mount_nofollow_verbose(LOG_DEBUG, final, workspace, NULL, MS_BIND|MS_REC, NULL); |
2689 | if (r < 0) | |
2690 | return r; | |
bb0c0d6f | 2691 | |
21935150 LP |
2692 | r = mount_nofollow_verbose(LOG_DEBUG, NULL, workspace, NULL, MS_BIND|MS_REMOUNT|MS_NODEV|MS_NOEXEC|MS_NOSUID, NULL); |
2693 | if (r < 0) | |
2694 | return r; | |
bb0c0d6f LP |
2695 | |
2696 | workspace_mounted = true; | |
2697 | } | |
2698 | } else | |
2699 | final_mounted = false; | |
2700 | ||
2701 | if (workspace_mounted < 0) { | |
2702 | /* Nothing is mounted on the workspace yet, let's try to mount something now */ | |
2703 | for (int try = 0;; try++) { | |
2704 | ||
2705 | if (try == 0) { | |
2706 | /* Try "ramfs" first, since it's not swap backed */ | |
21935150 LP |
2707 | r = mount_nofollow_verbose(LOG_DEBUG, "ramfs", workspace, "ramfs", MS_NODEV|MS_NOEXEC|MS_NOSUID, "mode=0700"); |
2708 | if (r >= 0) { | |
bb0c0d6f LP |
2709 | workspace_mounted = true; |
2710 | break; | |
2711 | } | |
2712 | ||
2713 | } else if (try == 1) { | |
2714 | _cleanup_free_ char *opts = NULL; | |
2715 | ||
2716 | if (asprintf(&opts, "mode=0700,nr_inodes=1024,size=%lu", CREDENTIALS_BYTES_MAX) < 0) | |
2717 | return -ENOMEM; | |
2718 | ||
2719 | /* Fall back to "tmpfs" otherwise */ | |
21935150 LP |
2720 | r = mount_nofollow_verbose(LOG_DEBUG, "tmpfs", workspace, "tmpfs", MS_NODEV|MS_NOEXEC|MS_NOSUID, opts); |
2721 | if (r >= 0) { | |
bb0c0d6f LP |
2722 | workspace_mounted = true; |
2723 | break; | |
2724 | } | |
2725 | ||
2726 | } else { | |
2727 | /* If that didn't work, try to make a bind mount from the final to the workspace, so that we can make it writable there. */ | |
21935150 LP |
2728 | r = mount_nofollow_verbose(LOG_DEBUG, final, workspace, NULL, MS_BIND|MS_REC, NULL); |
2729 | if (r < 0) { | |
2730 | if (!ERRNO_IS_PRIVILEGE(r)) /* Propagate anything that isn't a permission problem */ | |
2731 | return r; | |
bb0c0d6f LP |
2732 | |
2733 | if (must_mount) /* If we it's not OK to use the plain directory | |
2734 | * fallback, propagate all errors too */ | |
21935150 | 2735 | return r; |
bb0c0d6f LP |
2736 | |
2737 | /* If we lack privileges to bind mount stuff, then let's gracefully | |
2738 | * proceed for compat with container envs, and just use the final dir | |
2739 | * as is. */ | |
2740 | ||
2741 | workspace_mounted = false; | |
2742 | break; | |
2743 | } | |
2744 | ||
2745 | /* Make the new bind mount writable (i.e. drop MS_RDONLY) */ | |
21935150 LP |
2746 | r = mount_nofollow_verbose(LOG_DEBUG, NULL, workspace, NULL, MS_BIND|MS_REMOUNT|MS_NODEV|MS_NOEXEC|MS_NOSUID, NULL); |
2747 | if (r < 0) | |
2748 | return r; | |
bb0c0d6f LP |
2749 | |
2750 | workspace_mounted = true; | |
2751 | break; | |
2752 | } | |
2753 | } | |
2754 | } | |
2755 | ||
2756 | assert(!must_mount || workspace_mounted > 0); | |
2757 | where = workspace_mounted ? workspace : final; | |
2758 | ||
d3dcf4e3 | 2759 | r = acquire_credentials(context, params, unit, where, uid, workspace_mounted); |
bb0c0d6f LP |
2760 | if (r < 0) |
2761 | return r; | |
2762 | ||
2763 | if (workspace_mounted) { | |
2764 | /* Make workspace read-only now, so that any bind mount we make from it defaults to read-only too */ | |
21935150 LP |
2765 | r = mount_nofollow_verbose(LOG_DEBUG, NULL, workspace, NULL, MS_BIND|MS_REMOUNT|MS_RDONLY|MS_NODEV|MS_NOEXEC|MS_NOSUID, NULL); |
2766 | if (r < 0) | |
2767 | return r; | |
bb0c0d6f LP |
2768 | |
2769 | /* And mount it to the final place, read-only */ | |
21935150 LP |
2770 | if (final_mounted) |
2771 | r = umount_verbose(LOG_DEBUG, workspace, MNT_DETACH|UMOUNT_NOFOLLOW); | |
2772 | else | |
2773 | r = mount_nofollow_verbose(LOG_DEBUG, workspace, final, NULL, MS_MOVE, NULL); | |
2774 | if (r < 0) | |
2775 | return r; | |
bb0c0d6f LP |
2776 | } else { |
2777 | _cleanup_free_ char *parent = NULL; | |
2778 | ||
2779 | /* If we do not have our own mount put used the plain directory fallback, then we need to | |
2780 | * open access to the top-level credential directory and the per-service directory now */ | |
2781 | ||
2782 | parent = dirname_malloc(final); | |
2783 | if (!parent) | |
2784 | return -ENOMEM; | |
2785 | if (chmod(parent, 0755) < 0) | |
2786 | return -errno; | |
2787 | } | |
2788 | ||
2789 | return 0; | |
2790 | } | |
2791 | ||
2792 | static int setup_credentials( | |
2793 | const ExecContext *context, | |
2794 | const ExecParameters *params, | |
2795 | const char *unit, | |
2796 | uid_t uid) { | |
2797 | ||
2798 | _cleanup_free_ char *p = NULL, *q = NULL; | |
2799 | const char *i; | |
2800 | int r; | |
2801 | ||
2802 | assert(context); | |
2803 | assert(params); | |
2804 | ||
2805 | if (!exec_context_has_credentials(context)) | |
2806 | return 0; | |
2807 | ||
2808 | if (!params->prefix[EXEC_DIRECTORY_RUNTIME]) | |
2809 | return -EINVAL; | |
2810 | ||
2811 | /* This where we'll place stuff when we are done; this main credentials directory is world-readable, | |
2812 | * and the subdir we mount over with a read-only file system readable by the service's user */ | |
2813 | q = path_join(params->prefix[EXEC_DIRECTORY_RUNTIME], "credentials"); | |
2814 | if (!q) | |
2815 | return -ENOMEM; | |
2816 | ||
2817 | r = mkdir_label(q, 0755); /* top-level dir: world readable/searchable */ | |
2818 | if (r < 0 && r != -EEXIST) | |
2819 | return r; | |
2820 | ||
2821 | p = path_join(q, unit); | |
2822 | if (!p) | |
2823 | return -ENOMEM; | |
2824 | ||
2825 | r = mkdir_label(p, 0700); /* per-unit dir: private to user */ | |
2826 | if (r < 0 && r != -EEXIST) | |
2827 | return r; | |
2828 | ||
2829 | r = safe_fork("(sd-mkdcreds)", FORK_DEATHSIG|FORK_WAIT|FORK_NEW_MOUNTNS, NULL); | |
2830 | if (r < 0) { | |
2831 | _cleanup_free_ char *t = NULL, *u = NULL; | |
2832 | ||
2833 | /* If this is not a privilege or support issue then propagate the error */ | |
2834 | if (!ERRNO_IS_NOT_SUPPORTED(r) && !ERRNO_IS_PRIVILEGE(r)) | |
2835 | return r; | |
2836 | ||
2837 | /* Temporary workspace, that remains inaccessible all the time. We prepare stuff there before moving | |
2838 | * it into place, so that users can't access half-initialized credential stores. */ | |
2839 | t = path_join(params->prefix[EXEC_DIRECTORY_RUNTIME], "systemd/temporary-credentials"); | |
2840 | if (!t) | |
2841 | return -ENOMEM; | |
2842 | ||
2843 | /* We can't set up a mount namespace. In that case operate on a fixed, inaccessible per-unit | |
2844 | * directory outside of /run/credentials/ first, and then move it over to /run/credentials/ | |
2845 | * after it is fully set up */ | |
2846 | u = path_join(t, unit); | |
2847 | if (!u) | |
2848 | return -ENOMEM; | |
2849 | ||
2850 | FOREACH_STRING(i, t, u) { | |
2851 | r = mkdir_label(i, 0700); | |
2852 | if (r < 0 && r != -EEXIST) | |
2853 | return r; | |
2854 | } | |
2855 | ||
2856 | r = setup_credentials_internal( | |
2857 | context, | |
2858 | params, | |
d3dcf4e3 | 2859 | unit, |
bb0c0d6f LP |
2860 | p, /* final mount point */ |
2861 | u, /* temporary workspace to overmount */ | |
2862 | true, /* reuse the workspace if it is already a mount */ | |
2863 | false, /* it's OK to fall back to a plain directory if we can't mount anything */ | |
2864 | uid); | |
2865 | ||
2866 | (void) rmdir(u); /* remove the workspace again if we can. */ | |
2867 | ||
2868 | if (r < 0) | |
2869 | return r; | |
2870 | ||
2871 | } else if (r == 0) { | |
2872 | ||
2873 | /* We managed to set up a mount namespace, and are now in a child. That's great. In this case | |
2874 | * we can use the same directory for all cases, after turning off propagation. Question | |
2875 | * though is: where do we turn off propagation exactly, and where do we place the workspace | |
2876 | * directory? We need some place that is guaranteed to be a mount point in the host, and | |
2877 | * which is guaranteed to have a subdir we can mount over. /run/ is not suitable for this, | |
2878 | * since we ultimately want to move the resulting file system there, i.e. we need propagation | |
2879 | * for /run/ eventually. We could use our own /run/systemd/bind mount on itself, but that | |
2880 | * would be visible in the host mount table all the time, which we want to avoid. Hence, what | |
2881 | * we do here instead we use /dev/ and /dev/shm/ for our purposes. We know for sure that | |
2882 | * /dev/ is a mount point and we now for sure that /dev/shm/ exists. Hence we can turn off | |
2883 | * propagation on the former, and then overmount the latter. | |
2884 | * | |
2885 | * Yes it's nasty playing games with /dev/ and /dev/shm/ like this, since it does not exist | |
2886 | * for this purpose, but there are few other candidates that work equally well for us, and | |
2887 | * given that the we do this in a privately namespaced short-lived single-threaded process | |
69e3234d | 2888 | * that no one else sees this should be OK to do.*/ |
bb0c0d6f | 2889 | |
21935150 LP |
2890 | r = mount_nofollow_verbose(LOG_DEBUG, NULL, "/dev", NULL, MS_SLAVE|MS_REC, NULL); /* Turn off propagation from our namespace to host */ |
2891 | if (r < 0) | |
bb0c0d6f LP |
2892 | goto child_fail; |
2893 | ||
2894 | r = setup_credentials_internal( | |
2895 | context, | |
2896 | params, | |
d3dcf4e3 | 2897 | unit, |
bb0c0d6f LP |
2898 | p, /* final mount point */ |
2899 | "/dev/shm", /* temporary workspace to overmount */ | |
2900 | false, /* do not reuse /dev/shm if it is already a mount, under no circumstances */ | |
2901 | true, /* insist that something is mounted, do not allow fallback to plain directory */ | |
2902 | uid); | |
2903 | if (r < 0) | |
2904 | goto child_fail; | |
2905 | ||
2906 | _exit(EXIT_SUCCESS); | |
2907 | ||
2908 | child_fail: | |
2909 | _exit(EXIT_FAILURE); | |
2910 | } | |
2911 | ||
2912 | return 0; | |
2913 | } | |
2914 | ||
92b423b9 | 2915 | #if ENABLE_SMACK |
cefc33ae LP |
2916 | static int setup_smack( |
2917 | const ExecContext *context, | |
b83d5050 | 2918 | int executable_fd) { |
cefc33ae LP |
2919 | int r; |
2920 | ||
2921 | assert(context); | |
b83d5050 | 2922 | assert(executable_fd >= 0); |
cefc33ae | 2923 | |
cefc33ae LP |
2924 | if (context->smack_process_label) { |
2925 | r = mac_smack_apply_pid(0, context->smack_process_label); | |
2926 | if (r < 0) | |
2927 | return r; | |
2928 | } | |
2929 | #ifdef SMACK_DEFAULT_PROCESS_LABEL | |
2930 | else { | |
2931 | _cleanup_free_ char *exec_label = NULL; | |
2932 | ||
b83d5050 | 2933 | r = mac_smack_read_fd(executable_fd, SMACK_ATTR_EXEC, &exec_label); |
4c701096 | 2934 | if (r < 0 && !IN_SET(r, -ENODATA, -EOPNOTSUPP)) |
cefc33ae LP |
2935 | return r; |
2936 | ||
2937 | r = mac_smack_apply_pid(0, exec_label ? : SMACK_DEFAULT_PROCESS_LABEL); | |
2938 | if (r < 0) | |
2939 | return r; | |
2940 | } | |
cefc33ae LP |
2941 | #endif |
2942 | ||
2943 | return 0; | |
2944 | } | |
92b423b9 | 2945 | #endif |
cefc33ae | 2946 | |
6c47cd7d LP |
2947 | static int compile_bind_mounts( |
2948 | const ExecContext *context, | |
2949 | const ExecParameters *params, | |
2950 | BindMount **ret_bind_mounts, | |
da6053d0 | 2951 | size_t *ret_n_bind_mounts, |
6c47cd7d LP |
2952 | char ***ret_empty_directories) { |
2953 | ||
2954 | _cleanup_strv_free_ char **empty_directories = NULL; | |
2955 | BindMount *bind_mounts; | |
5b10116e | 2956 | size_t n, h = 0; |
6c47cd7d LP |
2957 | int r; |
2958 | ||
2959 | assert(context); | |
2960 | assert(params); | |
2961 | assert(ret_bind_mounts); | |
2962 | assert(ret_n_bind_mounts); | |
2963 | assert(ret_empty_directories); | |
2964 | ||
2965 | n = context->n_bind_mounts; | |
5b10116e | 2966 | for (ExecDirectoryType t = 0; t < _EXEC_DIRECTORY_TYPE_MAX; t++) { |
6c47cd7d LP |
2967 | if (!params->prefix[t]) |
2968 | continue; | |
2969 | ||
2970 | n += strv_length(context->directories[t].paths); | |
2971 | } | |
2972 | ||
2973 | if (n <= 0) { | |
2974 | *ret_bind_mounts = NULL; | |
2975 | *ret_n_bind_mounts = 0; | |
2976 | *ret_empty_directories = NULL; | |
2977 | return 0; | |
2978 | } | |
2979 | ||
2980 | bind_mounts = new(BindMount, n); | |
2981 | if (!bind_mounts) | |
2982 | return -ENOMEM; | |
2983 | ||
5b10116e | 2984 | for (size_t i = 0; i < context->n_bind_mounts; i++) { |
6c47cd7d LP |
2985 | BindMount *item = context->bind_mounts + i; |
2986 | char *s, *d; | |
2987 | ||
2988 | s = strdup(item->source); | |
2989 | if (!s) { | |
2990 | r = -ENOMEM; | |
2991 | goto finish; | |
2992 | } | |
2993 | ||
2994 | d = strdup(item->destination); | |
2995 | if (!d) { | |
2996 | free(s); | |
2997 | r = -ENOMEM; | |
2998 | goto finish; | |
2999 | } | |
3000 | ||
3001 | bind_mounts[h++] = (BindMount) { | |
3002 | .source = s, | |
3003 | .destination = d, | |
3004 | .read_only = item->read_only, | |
3005 | .recursive = item->recursive, | |
3006 | .ignore_enoent = item->ignore_enoent, | |
3007 | }; | |
3008 | } | |
3009 | ||
5b10116e | 3010 | for (ExecDirectoryType t = 0; t < _EXEC_DIRECTORY_TYPE_MAX; t++) { |
6c47cd7d LP |
3011 | char **suffix; |
3012 | ||
3013 | if (!params->prefix[t]) | |
3014 | continue; | |
3015 | ||
3016 | if (strv_isempty(context->directories[t].paths)) | |
3017 | continue; | |
3018 | ||
494d0247 | 3019 | if (exec_directory_is_private(context, t) && |
74e12520 | 3020 | !exec_context_with_rootfs(context)) { |
6c47cd7d LP |
3021 | char *private_root; |
3022 | ||
3023 | /* So this is for a dynamic user, and we need to make sure the process can access its own | |
3024 | * directory. For that we overmount the usually inaccessible "private" subdirectory with a | |
3025 | * tmpfs that makes it accessible and is empty except for the submounts we do this for. */ | |
3026 | ||
657ee2d8 | 3027 | private_root = path_join(params->prefix[t], "private"); |
6c47cd7d LP |
3028 | if (!private_root) { |
3029 | r = -ENOMEM; | |
3030 | goto finish; | |
3031 | } | |
3032 | ||
3033 | r = strv_consume(&empty_directories, private_root); | |
a635a7ae | 3034 | if (r < 0) |
6c47cd7d | 3035 | goto finish; |
6c47cd7d LP |
3036 | } |
3037 | ||
3038 | STRV_FOREACH(suffix, context->directories[t].paths) { | |
3039 | char *s, *d; | |
3040 | ||
494d0247 | 3041 | if (exec_directory_is_private(context, t)) |
657ee2d8 | 3042 | s = path_join(params->prefix[t], "private", *suffix); |
6c47cd7d | 3043 | else |
657ee2d8 | 3044 | s = path_join(params->prefix[t], *suffix); |
6c47cd7d LP |
3045 | if (!s) { |
3046 | r = -ENOMEM; | |
3047 | goto finish; | |
3048 | } | |
3049 | ||
494d0247 | 3050 | if (exec_directory_is_private(context, t) && |
74e12520 | 3051 | exec_context_with_rootfs(context)) |
5609f688 YW |
3052 | /* When RootDirectory= or RootImage= are set, then the symbolic link to the private |
3053 | * directory is not created on the root directory. So, let's bind-mount the directory | |
3054 | * on the 'non-private' place. */ | |
657ee2d8 | 3055 | d = path_join(params->prefix[t], *suffix); |
5609f688 YW |
3056 | else |
3057 | d = strdup(s); | |
6c47cd7d LP |
3058 | if (!d) { |
3059 | free(s); | |
3060 | r = -ENOMEM; | |
3061 | goto finish; | |
3062 | } | |
3063 | ||
3064 | bind_mounts[h++] = (BindMount) { | |
3065 | .source = s, | |
3066 | .destination = d, | |
3067 | .read_only = false, | |
9ce4e4b0 | 3068 | .nosuid = context->dynamic_user, /* don't allow suid/sgid when DynamicUser= is on */ |
6c47cd7d LP |
3069 | .recursive = true, |
3070 | .ignore_enoent = false, | |
3071 | }; | |
3072 | } | |
3073 | } | |
3074 | ||
3075 | assert(h == n); | |
3076 | ||
3077 | *ret_bind_mounts = bind_mounts; | |
3078 | *ret_n_bind_mounts = n; | |
ae2a15bc | 3079 | *ret_empty_directories = TAKE_PTR(empty_directories); |
6c47cd7d LP |
3080 | |
3081 | return (int) n; | |
3082 | ||
3083 | finish: | |
3084 | bind_mount_free_many(bind_mounts, h); | |
3085 | return r; | |
3086 | } | |
3087 | ||
4e677599 LP |
3088 | static bool insist_on_sandboxing( |
3089 | const ExecContext *context, | |
3090 | const char *root_dir, | |
3091 | const char *root_image, | |
3092 | const BindMount *bind_mounts, | |
3093 | size_t n_bind_mounts) { | |
3094 | ||
4e677599 LP |
3095 | assert(context); |
3096 | assert(n_bind_mounts == 0 || bind_mounts); | |
3097 | ||
3098 | /* Checks whether we need to insist on fs namespacing. i.e. whether we have settings configured that | |
86b52a39 | 3099 | * would alter the view on the file system beyond making things read-only or invisible, i.e. would |
4e677599 LP |
3100 | * rearrange stuff in a way we cannot ignore gracefully. */ |
3101 | ||
3102 | if (context->n_temporary_filesystems > 0) | |
3103 | return true; | |
3104 | ||
3105 | if (root_dir || root_image) | |
3106 | return true; | |
3107 | ||
b3d13314 LB |
3108 | if (context->n_mount_images > 0) |
3109 | return true; | |
3110 | ||
4e677599 LP |
3111 | if (context->dynamic_user) |
3112 | return true; | |
3113 | ||
3114 | /* If there are any bind mounts set that don't map back onto themselves, fs namespacing becomes | |
3115 | * essential. */ | |
5b10116e | 3116 | for (size_t i = 0; i < n_bind_mounts; i++) |
4e677599 LP |
3117 | if (!path_equal(bind_mounts[i].source, bind_mounts[i].destination)) |
3118 | return true; | |
3119 | ||
91dd5f7c LP |
3120 | if (context->log_namespace) |
3121 | return true; | |
3122 | ||
4e677599 LP |
3123 | return false; |
3124 | } | |
3125 | ||
6818c54c | 3126 | static int apply_mount_namespace( |
34cf6c43 | 3127 | const Unit *u, |
9f71ba8d | 3128 | ExecCommandFlags command_flags, |
6818c54c LP |
3129 | const ExecContext *context, |
3130 | const ExecParameters *params, | |
7cc5ef5f ZJS |
3131 | const ExecRuntime *runtime, |
3132 | char **error_path) { | |
6818c54c | 3133 | |
7bcef4ef | 3134 | _cleanup_strv_free_ char **empty_directories = NULL; |
56a13a49 | 3135 | const char *tmp_dir = NULL, *var_tmp_dir = NULL; |
915e6d16 | 3136 | const char *root_dir = NULL, *root_image = NULL; |
5e8deb94 | 3137 | _cleanup_free_ char *creds_path = NULL, *incoming_dir = NULL, *propagate_dir = NULL; |
228af36f | 3138 | NamespaceInfo ns_info; |
165a31c0 | 3139 | bool needs_sandboxing; |
6c47cd7d | 3140 | BindMount *bind_mounts = NULL; |
da6053d0 | 3141 | size_t n_bind_mounts = 0; |
6818c54c | 3142 | int r; |
93c6bb51 | 3143 | |
2b3c1b9e DH |
3144 | assert(context); |
3145 | ||
915e6d16 LP |
3146 | if (params->flags & EXEC_APPLY_CHROOT) { |
3147 | root_image = context->root_image; | |
3148 | ||
3149 | if (!root_image) | |
3150 | root_dir = context->root_directory; | |
3151 | } | |
93c6bb51 | 3152 | |
6c47cd7d LP |
3153 | r = compile_bind_mounts(context, params, &bind_mounts, &n_bind_mounts, &empty_directories); |
3154 | if (r < 0) | |
3155 | return r; | |
3156 | ||
9f71ba8d | 3157 | needs_sandboxing = (params->flags & EXEC_APPLY_SANDBOXING) && !(command_flags & EXEC_COMMAND_FULLY_PRIVILEGED); |
ecf63c91 NJ |
3158 | if (needs_sandboxing) { |
3159 | /* The runtime struct only contains the parent of the private /tmp, | |
3160 | * which is non-accessible to world users. Inside of it there's a /tmp | |
56a13a49 ZJS |
3161 | * that is sticky, and that's the one we want to use here. |
3162 | * This does not apply when we are using /run/systemd/empty as fallback. */ | |
ecf63c91 NJ |
3163 | |
3164 | if (context->private_tmp && runtime) { | |
56a13a49 ZJS |
3165 | if (streq_ptr(runtime->tmp_dir, RUN_SYSTEMD_EMPTY)) |
3166 | tmp_dir = runtime->tmp_dir; | |
3167 | else if (runtime->tmp_dir) | |
3168 | tmp_dir = strjoina(runtime->tmp_dir, "/tmp"); | |
3169 | ||
3170 | if (streq_ptr(runtime->var_tmp_dir, RUN_SYSTEMD_EMPTY)) | |
3171 | var_tmp_dir = runtime->var_tmp_dir; | |
f63ef937 | 3172 | else if (runtime->var_tmp_dir) |
56a13a49 | 3173 | var_tmp_dir = strjoina(runtime->var_tmp_dir, "/tmp"); |
ecf63c91 NJ |
3174 | } |
3175 | ||
b5a33299 YW |
3176 | ns_info = (NamespaceInfo) { |
3177 | .ignore_protect_paths = false, | |
3178 | .private_dev = context->private_devices, | |
3179 | .protect_control_groups = context->protect_control_groups, | |
3180 | .protect_kernel_tunables = context->protect_kernel_tunables, | |
3181 | .protect_kernel_modules = context->protect_kernel_modules, | |
94a7b275 | 3182 | .protect_kernel_logs = context->protect_kernel_logs, |
aecd5ac6 | 3183 | .protect_hostname = context->protect_hostname, |
5e98086d | 3184 | .mount_apivfs = exec_context_get_effective_mount_apivfs(context), |
228af36f | 3185 | .private_mounts = context->private_mounts, |
52b3d652 LP |
3186 | .protect_home = context->protect_home, |
3187 | .protect_system = context->protect_system, | |
4e399953 LP |
3188 | .protect_proc = context->protect_proc, |
3189 | .proc_subset = context->proc_subset, | |
80271a44 | 3190 | .private_ipc = context->private_ipc || context->ipc_namespace_path, |
d8e3c31b TM |
3191 | /* If NNP is on, we can turn on MS_NOSUID, since it won't have any effect anymore. */ |
3192 | .mount_nosuid = context->no_new_privileges, | |
b5a33299 | 3193 | }; |
ecf63c91 | 3194 | } else if (!context->dynamic_user && root_dir) |
228af36f LP |
3195 | /* |
3196 | * If DynamicUser=no and RootDirectory= is set then lets pass a relaxed | |
3197 | * sandbox info, otherwise enforce it, don't ignore protected paths and | |
3198 | * fail if we are enable to apply the sandbox inside the mount namespace. | |
3199 | */ | |
3200 | ns_info = (NamespaceInfo) { | |
3201 | .ignore_protect_paths = true, | |
3202 | }; | |
3203 | else | |
3204 | ns_info = (NamespaceInfo) {}; | |
b5a33299 | 3205 | |
37ed15d7 FB |
3206 | if (context->mount_flags == MS_SHARED) |
3207 | log_unit_debug(u, "shared mount propagation hidden by other fs namespacing unit settings: ignoring"); | |
3208 | ||
a631cbfa LP |
3209 | if (exec_context_has_credentials(context) && |
3210 | params->prefix[EXEC_DIRECTORY_RUNTIME] && | |
3211 | FLAGS_SET(params->flags, EXEC_WRITE_CREDENTIALS)) { | |
bbb4e7f3 | 3212 | creds_path = path_join(params->prefix[EXEC_DIRECTORY_RUNTIME], "credentials", u->id); |
8062e643 YW |
3213 | if (!creds_path) { |
3214 | r = -ENOMEM; | |
3215 | goto finalize; | |
3216 | } | |
bbb4e7f3 LP |
3217 | } |
3218 | ||
5e8deb94 LB |
3219 | if (MANAGER_IS_SYSTEM(u->manager)) { |
3220 | propagate_dir = path_join("/run/systemd/propagate/", u->id); | |
f2550b98 LP |
3221 | if (!propagate_dir) { |
3222 | r = -ENOMEM; | |
3223 | goto finalize; | |
3224 | } | |
3225 | ||
5e8deb94 | 3226 | incoming_dir = strdup("/run/systemd/incoming"); |
f2550b98 LP |
3227 | if (!incoming_dir) { |
3228 | r = -ENOMEM; | |
3229 | goto finalize; | |
3230 | } | |
5e8deb94 LB |
3231 | } |
3232 | ||
18d73705 | 3233 | r = setup_namespace(root_dir, root_image, context->root_image_options, |
7bcef4ef | 3234 | &ns_info, context->read_write_paths, |
165a31c0 LP |
3235 | needs_sandboxing ? context->read_only_paths : NULL, |
3236 | needs_sandboxing ? context->inaccessible_paths : NULL, | |
ddc155b2 TM |
3237 | needs_sandboxing ? context->exec_paths : NULL, |
3238 | needs_sandboxing ? context->no_exec_paths : NULL, | |
6c47cd7d LP |
3239 | empty_directories, |
3240 | bind_mounts, | |
3241 | n_bind_mounts, | |
2abd4e38 YW |
3242 | context->temporary_filesystems, |
3243 | context->n_temporary_filesystems, | |
b3d13314 LB |
3244 | context->mount_images, |
3245 | context->n_mount_images, | |
56a13a49 ZJS |
3246 | tmp_dir, |
3247 | var_tmp_dir, | |
bbb4e7f3 | 3248 | creds_path, |
91dd5f7c | 3249 | context->log_namespace, |
915e6d16 | 3250 | context->mount_flags, |
d4d55b0d LB |
3251 | context->root_hash, context->root_hash_size, context->root_hash_path, |
3252 | context->root_hash_sig, context->root_hash_sig_size, context->root_hash_sig_path, | |
3253 | context->root_verity, | |
93f59701 LB |
3254 | context->extension_images, |
3255 | context->n_extension_images, | |
5e8deb94 LB |
3256 | propagate_dir, |
3257 | incoming_dir, | |
3bdc25a4 | 3258 | root_dir || root_image ? params->notify_socket : NULL, |
7cc5ef5f | 3259 | error_path); |
93c6bb51 | 3260 | |
1beab8b0 | 3261 | /* If we couldn't set up the namespace this is probably due to a missing capability. setup_namespace() reports |
5238e957 | 3262 | * that with a special, recognizable error ENOANO. In this case, silently proceed, but only if exclusively |
1beab8b0 LP |
3263 | * sandboxing options were used, i.e. nothing such as RootDirectory= or BindMount= that would result in a |
3264 | * completely different execution environment. */ | |
aca835ed | 3265 | if (r == -ENOANO) { |
4e677599 LP |
3266 | if (insist_on_sandboxing( |
3267 | context, | |
3268 | root_dir, root_image, | |
3269 | bind_mounts, | |
3270 | n_bind_mounts)) { | |
3271 | log_unit_debug(u, "Failed to set up namespace, and refusing to continue since the selected namespacing options alter mount environment non-trivially.\n" | |
3272 | "Bind mounts: %zu, temporary filesystems: %zu, root directory: %s, root image: %s, dynamic user: %s", | |
3273 | n_bind_mounts, context->n_temporary_filesystems, yes_no(root_dir), yes_no(root_image), yes_no(context->dynamic_user)); | |
3274 | ||
3275 | r = -EOPNOTSUPP; | |
3276 | } else { | |
aca835ed | 3277 | log_unit_debug(u, "Failed to set up namespace, assuming containerized execution and ignoring."); |
4e677599 | 3278 | r = 0; |
aca835ed | 3279 | } |
93c6bb51 DH |
3280 | } |
3281 | ||
8062e643 | 3282 | finalize: |
4e677599 | 3283 | bind_mount_free_many(bind_mounts, n_bind_mounts); |
93c6bb51 DH |
3284 | return r; |
3285 | } | |
3286 | ||
915e6d16 LP |
3287 | static int apply_working_directory( |
3288 | const ExecContext *context, | |
3289 | const ExecParameters *params, | |
3290 | const char *home, | |
376fecf6 | 3291 | int *exit_status) { |
915e6d16 | 3292 | |
6732edab | 3293 | const char *d, *wd; |
2b3c1b9e DH |
3294 | |
3295 | assert(context); | |
376fecf6 | 3296 | assert(exit_status); |
2b3c1b9e | 3297 | |
6732edab LP |
3298 | if (context->working_directory_home) { |
3299 | ||
376fecf6 LP |
3300 | if (!home) { |
3301 | *exit_status = EXIT_CHDIR; | |
6732edab | 3302 | return -ENXIO; |
376fecf6 | 3303 | } |
6732edab | 3304 | |
2b3c1b9e | 3305 | wd = home; |
6732edab | 3306 | |
14eb3285 LP |
3307 | } else |
3308 | wd = empty_to_root(context->working_directory); | |
e7f1e7c6 | 3309 | |
fa97f630 | 3310 | if (params->flags & EXEC_APPLY_CHROOT) |
2b3c1b9e | 3311 | d = wd; |
fa97f630 | 3312 | else |
3b0e5bb5 | 3313 | d = prefix_roota(context->root_directory, wd); |
e7f1e7c6 | 3314 | |
376fecf6 LP |
3315 | if (chdir(d) < 0 && !context->working_directory_missing_ok) { |
3316 | *exit_status = EXIT_CHDIR; | |
2b3c1b9e | 3317 | return -errno; |
376fecf6 | 3318 | } |
e7f1e7c6 DH |
3319 | |
3320 | return 0; | |
3321 | } | |
3322 | ||
fa97f630 JB |
3323 | static int apply_root_directory( |
3324 | const ExecContext *context, | |
3325 | const ExecParameters *params, | |
3326 | const bool needs_mount_ns, | |
3327 | int *exit_status) { | |
3328 | ||
3329 | assert(context); | |
3330 | assert(exit_status); | |
3331 | ||
5b10116e | 3332 | if (params->flags & EXEC_APPLY_CHROOT) |
fa97f630 JB |
3333 | if (!needs_mount_ns && context->root_directory) |
3334 | if (chroot(context->root_directory) < 0) { | |
3335 | *exit_status = EXIT_CHROOT; | |
3336 | return -errno; | |
3337 | } | |
fa97f630 JB |
3338 | |
3339 | return 0; | |
3340 | } | |
3341 | ||
b1edf445 | 3342 | static int setup_keyring( |
34cf6c43 | 3343 | const Unit *u, |
b1edf445 LP |
3344 | const ExecContext *context, |
3345 | const ExecParameters *p, | |
3346 | uid_t uid, gid_t gid) { | |
3347 | ||
74dd6b51 | 3348 | key_serial_t keyring; |
e64c2d0b DJL |
3349 | int r = 0; |
3350 | uid_t saved_uid; | |
3351 | gid_t saved_gid; | |
74dd6b51 LP |
3352 | |
3353 | assert(u); | |
b1edf445 | 3354 | assert(context); |
74dd6b51 LP |
3355 | assert(p); |
3356 | ||
3357 | /* Let's set up a new per-service "session" kernel keyring for each system service. This has the benefit that | |
3358 | * each service runs with its own keyring shared among all processes of the service, but with no hook-up beyond | |
3359 | * that scope, and in particular no link to the per-UID keyring. If we don't do this the keyring will be | |
3360 | * automatically created on-demand and then linked to the per-UID keyring, by the kernel. The kernel's built-in | |
3361 | * on-demand behaviour is very appropriate for login users, but probably not so much for system services, where | |
3362 | * UIDs are not necessarily specific to a service but reused (at least in the case of UID 0). */ | |
3363 | ||
b1edf445 LP |
3364 | if (context->keyring_mode == EXEC_KEYRING_INHERIT) |
3365 | return 0; | |
3366 | ||
e64c2d0b DJL |
3367 | /* Acquiring a reference to the user keyring is nasty. We briefly change identity in order to get things set up |
3368 | * properly by the kernel. If we don't do that then we can't create it atomically, and that sucks for parallel | |
3369 | * execution. This mimics what pam_keyinit does, too. Setting up session keyring, to be owned by the right user | |
3370 | * & group is just as nasty as acquiring a reference to the user keyring. */ | |
3371 | ||
3372 | saved_uid = getuid(); | |
3373 | saved_gid = getgid(); | |
3374 | ||
3375 | if (gid_is_valid(gid) && gid != saved_gid) { | |
3376 | if (setregid(gid, -1) < 0) | |
3377 | return log_unit_error_errno(u, errno, "Failed to change GID for user keyring: %m"); | |
3378 | } | |
3379 | ||
3380 | if (uid_is_valid(uid) && uid != saved_uid) { | |
3381 | if (setreuid(uid, -1) < 0) { | |
3382 | r = log_unit_error_errno(u, errno, "Failed to change UID for user keyring: %m"); | |
3383 | goto out; | |
3384 | } | |
3385 | } | |
3386 | ||
74dd6b51 LP |
3387 | keyring = keyctl(KEYCTL_JOIN_SESSION_KEYRING, 0, 0, 0, 0); |
3388 | if (keyring == -1) { | |
3389 | if (errno == ENOSYS) | |
8002fb97 | 3390 | log_unit_debug_errno(u, errno, "Kernel keyring not supported, ignoring."); |
065b4774 | 3391 | else if (ERRNO_IS_PRIVILEGE(errno)) |
8002fb97 | 3392 | log_unit_debug_errno(u, errno, "Kernel keyring access prohibited, ignoring."); |
74dd6b51 | 3393 | else if (errno == EDQUOT) |
8002fb97 | 3394 | log_unit_debug_errno(u, errno, "Out of kernel keyrings to allocate, ignoring."); |
74dd6b51 | 3395 | else |
e64c2d0b | 3396 | r = log_unit_error_errno(u, errno, "Setting up kernel keyring failed: %m"); |
74dd6b51 | 3397 | |
e64c2d0b | 3398 | goto out; |
74dd6b51 LP |
3399 | } |
3400 | ||
e64c2d0b DJL |
3401 | /* When requested link the user keyring into the session keyring. */ |
3402 | if (context->keyring_mode == EXEC_KEYRING_SHARED) { | |
3403 | ||
3404 | if (keyctl(KEYCTL_LINK, | |
3405 | KEY_SPEC_USER_KEYRING, | |
3406 | KEY_SPEC_SESSION_KEYRING, 0, 0) < 0) { | |
3407 | r = log_unit_error_errno(u, errno, "Failed to link user keyring into session keyring: %m"); | |
3408 | goto out; | |
3409 | } | |
3410 | } | |
3411 | ||
3412 | /* Restore uid/gid back */ | |
3413 | if (uid_is_valid(uid) && uid != saved_uid) { | |
3414 | if (setreuid(saved_uid, -1) < 0) { | |
3415 | r = log_unit_error_errno(u, errno, "Failed to change UID back for user keyring: %m"); | |
3416 | goto out; | |
3417 | } | |
3418 | } | |
3419 | ||
3420 | if (gid_is_valid(gid) && gid != saved_gid) { | |
3421 | if (setregid(saved_gid, -1) < 0) | |
3422 | return log_unit_error_errno(u, errno, "Failed to change GID back for user keyring: %m"); | |
3423 | } | |
3424 | ||
3425 | /* Populate they keyring with the invocation ID by default, as original saved_uid. */ | |
b3415f5d LP |
3426 | if (!sd_id128_is_null(u->invocation_id)) { |
3427 | key_serial_t key; | |
3428 | ||
3429 | key = add_key("user", "invocation_id", &u->invocation_id, sizeof(u->invocation_id), KEY_SPEC_SESSION_KEYRING); | |
3430 | if (key == -1) | |
8002fb97 | 3431 | log_unit_debug_errno(u, errno, "Failed to add invocation ID to keyring, ignoring: %m"); |
b3415f5d LP |
3432 | else { |
3433 | if (keyctl(KEYCTL_SETPERM, key, | |
3434 | KEY_POS_VIEW|KEY_POS_READ|KEY_POS_SEARCH| | |
3435 | KEY_USR_VIEW|KEY_USR_READ|KEY_USR_SEARCH, 0, 0) < 0) | |
e64c2d0b | 3436 | r = log_unit_error_errno(u, errno, "Failed to restrict invocation ID permission: %m"); |
b3415f5d LP |
3437 | } |
3438 | } | |
3439 | ||
e64c2d0b | 3440 | out: |
37b22b3b | 3441 | /* Revert back uid & gid for the last time, and exit */ |
e64c2d0b DJL |
3442 | /* no extra logging, as only the first already reported error matters */ |
3443 | if (getuid() != saved_uid) | |
3444 | (void) setreuid(saved_uid, -1); | |
b1edf445 | 3445 | |
e64c2d0b DJL |
3446 | if (getgid() != saved_gid) |
3447 | (void) setregid(saved_gid, -1); | |
b1edf445 | 3448 | |
e64c2d0b | 3449 | return r; |
74dd6b51 LP |
3450 | } |
3451 | ||
3042bbeb | 3452 | static void append_socket_pair(int *array, size_t *n, const int pair[static 2]) { |
29206d46 LP |
3453 | assert(array); |
3454 | assert(n); | |
2caa38e9 | 3455 | assert(pair); |
29206d46 LP |
3456 | |
3457 | if (pair[0] >= 0) | |
3458 | array[(*n)++] = pair[0]; | |
3459 | if (pair[1] >= 0) | |
3460 | array[(*n)++] = pair[1]; | |
3461 | } | |
3462 | ||
a34ceba6 LP |
3463 | static int close_remaining_fds( |
3464 | const ExecParameters *params, | |
34cf6c43 YW |
3465 | const ExecRuntime *runtime, |
3466 | const DynamicCreds *dcreds, | |
00d9ef85 | 3467 | int user_lookup_fd, |
a34ceba6 | 3468 | int socket_fd, |
5b8d1f6b | 3469 | const int *fds, size_t n_fds) { |
a34ceba6 | 3470 | |
da6053d0 | 3471 | size_t n_dont_close = 0; |
00d9ef85 | 3472 | int dont_close[n_fds + 12]; |
a34ceba6 LP |
3473 | |
3474 | assert(params); | |
3475 | ||
3476 | if (params->stdin_fd >= 0) | |
3477 | dont_close[n_dont_close++] = params->stdin_fd; | |
3478 | if (params->stdout_fd >= 0) | |
3479 | dont_close[n_dont_close++] = params->stdout_fd; | |
3480 | if (params->stderr_fd >= 0) | |
3481 | dont_close[n_dont_close++] = params->stderr_fd; | |
3482 | ||
3483 | if (socket_fd >= 0) | |
3484 | dont_close[n_dont_close++] = socket_fd; | |
3485 | if (n_fds > 0) { | |
3486 | memcpy(dont_close + n_dont_close, fds, sizeof(int) * n_fds); | |
3487 | n_dont_close += n_fds; | |
3488 | } | |
3489 | ||
a70581ff | 3490 | if (runtime) { |
29206d46 | 3491 | append_socket_pair(dont_close, &n_dont_close, runtime->netns_storage_socket); |
a70581ff XR |
3492 | append_socket_pair(dont_close, &n_dont_close, runtime->ipcns_storage_socket); |
3493 | } | |
29206d46 LP |
3494 | |
3495 | if (dcreds) { | |
3496 | if (dcreds->user) | |
3497 | append_socket_pair(dont_close, &n_dont_close, dcreds->user->storage_socket); | |
3498 | if (dcreds->group) | |
3499 | append_socket_pair(dont_close, &n_dont_close, dcreds->group->storage_socket); | |
a34ceba6 LP |
3500 | } |
3501 | ||
00d9ef85 LP |
3502 | if (user_lookup_fd >= 0) |
3503 | dont_close[n_dont_close++] = user_lookup_fd; | |
3504 | ||
a34ceba6 LP |
3505 | return close_all_fds(dont_close, n_dont_close); |
3506 | } | |
3507 | ||
00d9ef85 LP |
3508 | static int send_user_lookup( |
3509 | Unit *unit, | |
3510 | int user_lookup_fd, | |
3511 | uid_t uid, | |
3512 | gid_t gid) { | |
3513 | ||
3514 | assert(unit); | |
3515 | ||
3516 | /* Send the resolved UID/GID to PID 1 after we learnt it. We send a single datagram, containing the UID/GID | |
3517 | * data as well as the unit name. Note that we suppress sending this if no user/group to resolve was | |
3518 | * specified. */ | |
3519 | ||
3520 | if (user_lookup_fd < 0) | |
3521 | return 0; | |
3522 | ||
3523 | if (!uid_is_valid(uid) && !gid_is_valid(gid)) | |
3524 | return 0; | |
3525 | ||
3526 | if (writev(user_lookup_fd, | |
3527 | (struct iovec[]) { | |
e6a7ec4b LP |
3528 | IOVEC_INIT(&uid, sizeof(uid)), |
3529 | IOVEC_INIT(&gid, sizeof(gid)), | |
3530 | IOVEC_INIT_STRING(unit->id) }, 3) < 0) | |
00d9ef85 LP |
3531 | return -errno; |
3532 | ||
3533 | return 0; | |
3534 | } | |
3535 | ||
6732edab LP |
3536 | static int acquire_home(const ExecContext *c, uid_t uid, const char** home, char **buf) { |
3537 | int r; | |
3538 | ||
3539 | assert(c); | |
3540 | assert(home); | |
3541 | assert(buf); | |
3542 | ||
3543 | /* If WorkingDirectory=~ is set, try to acquire a usable home directory. */ | |
3544 | ||
3545 | if (*home) | |
3546 | return 0; | |
3547 | ||
3548 | if (!c->working_directory_home) | |
3549 | return 0; | |
3550 | ||
6732edab LP |
3551 | r = get_home_dir(buf); |
3552 | if (r < 0) | |
3553 | return r; | |
3554 | ||
3555 | *home = *buf; | |
3556 | return 1; | |
3557 | } | |
3558 | ||
da50b85a LP |
3559 | static int compile_suggested_paths(const ExecContext *c, const ExecParameters *p, char ***ret) { |
3560 | _cleanup_strv_free_ char ** list = NULL; | |
da50b85a LP |
3561 | int r; |
3562 | ||
3563 | assert(c); | |
3564 | assert(p); | |
3565 | assert(ret); | |
3566 | ||
3567 | assert(c->dynamic_user); | |
3568 | ||
3569 | /* Compile a list of paths that it might make sense to read the owning UID from to use as initial candidate for | |
3570 | * dynamic UID allocation, in order to save us from doing costly recursive chown()s of the special | |
3571 | * directories. */ | |
3572 | ||
5b10116e | 3573 | for (ExecDirectoryType t = 0; t < _EXEC_DIRECTORY_TYPE_MAX; t++) { |
da50b85a LP |
3574 | char **i; |
3575 | ||
3576 | if (t == EXEC_DIRECTORY_CONFIGURATION) | |
3577 | continue; | |
3578 | ||
3579 | if (!p->prefix[t]) | |
3580 | continue; | |
3581 | ||
3582 | STRV_FOREACH(i, c->directories[t].paths) { | |
3583 | char *e; | |
3584 | ||
494d0247 | 3585 | if (exec_directory_is_private(c, t)) |
657ee2d8 | 3586 | e = path_join(p->prefix[t], "private", *i); |
494d0247 YW |
3587 | else |
3588 | e = path_join(p->prefix[t], *i); | |
da50b85a LP |
3589 | if (!e) |
3590 | return -ENOMEM; | |
3591 | ||
3592 | r = strv_consume(&list, e); | |
3593 | if (r < 0) | |
3594 | return r; | |
3595 | } | |
3596 | } | |
3597 | ||
ae2a15bc | 3598 | *ret = TAKE_PTR(list); |
da50b85a LP |
3599 | |
3600 | return 0; | |
3601 | } | |
3602 | ||
34cf6c43 YW |
3603 | static char *exec_command_line(char **argv); |
3604 | ||
78f93209 LP |
3605 | static int exec_parameters_get_cgroup_path(const ExecParameters *params, char **ret) { |
3606 | bool using_subcgroup; | |
3607 | char *p; | |
3608 | ||
3609 | assert(params); | |
3610 | assert(ret); | |
3611 | ||
3612 | if (!params->cgroup_path) | |
3613 | return -EINVAL; | |
3614 | ||
3615 | /* If we are called for a unit where cgroup delegation is on, and the payload created its own populated | |
3616 | * subcgroup (which we expect it to do, after all it asked for delegation), then we cannot place the control | |
3617 | * processes started after the main unit's process in the unit's main cgroup because it is now an inner one, | |
3618 | * and inner cgroups may not contain processes. Hence, if delegation is on, and this is a control process, | |
3619 | * let's use ".control" as subcgroup instead. Note that we do so only for ExecStartPost=, ExecReload=, | |
3620 | * ExecStop=, ExecStopPost=, i.e. for the commands where the main process is already forked. For ExecStartPre= | |
3621 | * this is not necessary, the cgroup is still empty. We distinguish these cases with the EXEC_CONTROL_CGROUP | |
3622 | * flag, which is only passed for the former statements, not for the latter. */ | |
3623 | ||
3624 | using_subcgroup = FLAGS_SET(params->flags, EXEC_CONTROL_CGROUP|EXEC_CGROUP_DELEGATE|EXEC_IS_CONTROL); | |
3625 | if (using_subcgroup) | |
657ee2d8 | 3626 | p = path_join(params->cgroup_path, ".control"); |
78f93209 LP |
3627 | else |
3628 | p = strdup(params->cgroup_path); | |
3629 | if (!p) | |
3630 | return -ENOMEM; | |
3631 | ||
3632 | *ret = p; | |
3633 | return using_subcgroup; | |
3634 | } | |
3635 | ||
e2b2fb7f MS |
3636 | static int exec_context_cpu_affinity_from_numa(const ExecContext *c, CPUSet *ret) { |
3637 | _cleanup_(cpu_set_reset) CPUSet s = {}; | |
3638 | int r; | |
3639 | ||
3640 | assert(c); | |
3641 | assert(ret); | |
3642 | ||
3643 | if (!c->numa_policy.nodes.set) { | |
3644 | log_debug("Can't derive CPU affinity mask from NUMA mask because NUMA mask is not set, ignoring"); | |
3645 | return 0; | |
3646 | } | |
3647 | ||
3648 | r = numa_to_cpu_set(&c->numa_policy, &s); | |
3649 | if (r < 0) | |
3650 | return r; | |
3651 | ||
3652 | cpu_set_reset(ret); | |
3653 | ||
3654 | return cpu_set_add_all(ret, &s); | |
3655 | } | |
3656 | ||
3657 | bool exec_context_get_cpu_affinity_from_numa(const ExecContext *c) { | |
3658 | assert(c); | |
3659 | ||
3660 | return c->cpu_affinity_from_numa; | |
3661 | } | |
3662 | ||
1da37e58 ZJS |
3663 | static int add_shifted_fd(int *fds, size_t fds_size, size_t *n_fds, int fd, int *ret_fd) { |
3664 | int r; | |
3665 | ||
3666 | assert(fds); | |
3667 | assert(n_fds); | |
3668 | assert(*n_fds < fds_size); | |
3669 | assert(ret_fd); | |
3670 | ||
3671 | if (fd < 0) { | |
3672 | *ret_fd = -1; | |
3673 | return 0; | |
3674 | } | |
3675 | ||
3676 | if (fd < 3 + (int) *n_fds) { | |
3677 | /* Let's move the fd up, so that it's outside of the fd range we will use to store | |
3678 | * the fds we pass to the process (or which are closed only during execve). */ | |
3679 | ||
3680 | r = fcntl(fd, F_DUPFD_CLOEXEC, 3 + (int) *n_fds); | |
3681 | if (r < 0) | |
3682 | return -errno; | |
3683 | ||
3684 | CLOSE_AND_REPLACE(fd, r); | |
3685 | } | |
3686 | ||
3687 | *ret_fd = fds[*n_fds] = fd; | |
3688 | (*n_fds) ++; | |
3689 | return 1; | |
3690 | } | |
3691 | ||
ff0af2a1 | 3692 | static int exec_child( |
f2341e0a | 3693 | Unit *unit, |
34cf6c43 | 3694 | const ExecCommand *command, |
ff0af2a1 LP |
3695 | const ExecContext *context, |
3696 | const ExecParameters *params, | |
3697 | ExecRuntime *runtime, | |
29206d46 | 3698 | DynamicCreds *dcreds, |
ff0af2a1 | 3699 | int socket_fd, |
2caa38e9 | 3700 | const int named_iofds[static 3], |
4c47affc | 3701 | int *fds, |
da6053d0 | 3702 | size_t n_socket_fds, |
25b583d7 | 3703 | size_t n_storage_fds, |
ff0af2a1 | 3704 | char **files_env, |
00d9ef85 | 3705 | int user_lookup_fd, |
12145637 | 3706 | int *exit_status) { |
d35fbf6b | 3707 | |
7ca69792 | 3708 | _cleanup_strv_free_ char **our_env = NULL, **pass_env = NULL, **accum_env = NULL, **replaced_argv = NULL; |
1da37e58 | 3709 | int r, ngids = 0, exec_fd; |
4d885bd3 DH |
3710 | _cleanup_free_ gid_t *supplementary_gids = NULL; |
3711 | const char *username = NULL, *groupname = NULL; | |
5686391b | 3712 | _cleanup_free_ char *home_buffer = NULL; |
2b3c1b9e | 3713 | const char *home = NULL, *shell = NULL; |
7ca69792 | 3714 | char **final_argv = NULL; |
7bce046b LP |
3715 | dev_t journal_stream_dev = 0; |
3716 | ino_t journal_stream_ino = 0; | |
5749f855 | 3717 | bool userns_set_up = false; |
165a31c0 LP |
3718 | bool needs_sandboxing, /* Do we need to set up full sandboxing? (i.e. all namespacing, all MAC stuff, caps, yadda yadda */ |
3719 | needs_setuid, /* Do we need to do the actual setresuid()/setresgid() calls? */ | |
3720 | needs_mount_namespace, /* Do we need to set up a mount namespace for this kernel? */ | |
3721 | needs_ambient_hack; /* Do we need to apply the ambient capabilities hack? */ | |
349cc4a5 | 3722 | #if HAVE_SELINUX |
7f59dd35 | 3723 | _cleanup_free_ char *mac_selinux_context_net = NULL; |
43b1f709 | 3724 | bool use_selinux = false; |
ecfbc84f | 3725 | #endif |
f9fa32f0 | 3726 | #if ENABLE_SMACK |
43b1f709 | 3727 | bool use_smack = false; |
ecfbc84f | 3728 | #endif |
349cc4a5 | 3729 | #if HAVE_APPARMOR |
43b1f709 | 3730 | bool use_apparmor = false; |
ecfbc84f | 3731 | #endif |
5749f855 AZ |
3732 | uid_t saved_uid = getuid(); |
3733 | gid_t saved_gid = getgid(); | |
fed1e721 LP |
3734 | uid_t uid = UID_INVALID; |
3735 | gid_t gid = GID_INVALID; | |
1da37e58 ZJS |
3736 | size_t n_fds = n_socket_fds + n_storage_fds, /* fds to pass to the child */ |
3737 | n_keep_fds; /* total number of fds not to close */ | |
165a31c0 | 3738 | int secure_bits; |
afb11bf1 DG |
3739 | _cleanup_free_ gid_t *gids_after_pam = NULL; |
3740 | int ngids_after_pam = 0; | |
034c6ed7 | 3741 | |
f2341e0a | 3742 | assert(unit); |
5cb5a6ff LP |
3743 | assert(command); |
3744 | assert(context); | |
d35fbf6b | 3745 | assert(params); |
ff0af2a1 | 3746 | assert(exit_status); |
d35fbf6b DM |
3747 | |
3748 | rename_process_from_path(command->path); | |
3749 | ||
9c274488 LP |
3750 | /* We reset exactly these signals, since they are the only ones we set to SIG_IGN in the main |
3751 | * daemon. All others we leave untouched because we set them to SIG_DFL or a valid handler initially, | |
3752 | * both of which will be demoted to SIG_DFL. */ | |
ce30c8dc | 3753 | (void) default_signals(SIGNALS_CRASH_HANDLER, |
9c274488 | 3754 | SIGNALS_IGNORE); |
d35fbf6b DM |
3755 | |
3756 | if (context->ignore_sigpipe) | |
9c274488 | 3757 | (void) ignore_signals(SIGPIPE); |
d35fbf6b | 3758 | |
ff0af2a1 LP |
3759 | r = reset_signal_mask(); |
3760 | if (r < 0) { | |
3761 | *exit_status = EXIT_SIGNAL_MASK; | |
12145637 | 3762 | return log_unit_error_errno(unit, r, "Failed to set process signal mask: %m"); |
d35fbf6b | 3763 | } |
034c6ed7 | 3764 | |
d35fbf6b DM |
3765 | if (params->idle_pipe) |
3766 | do_idle_pipe_dance(params->idle_pipe); | |
4f2d528d | 3767 | |
2c027c62 LP |
3768 | /* Close fds we don't need very early to make sure we don't block init reexecution because it cannot bind its |
3769 | * sockets. Among the fds we close are the logging fds, and we want to keep them closed, so that we don't have | |
3770 | * any fds open we don't really want open during the transition. In order to make logging work, we switch the | |
3771 | * log subsystem into open_when_needed mode, so that it reopens the logs on every single log call. */ | |
ff0af2a1 | 3772 | |
d35fbf6b | 3773 | log_forget_fds(); |
2c027c62 | 3774 | log_set_open_when_needed(true); |
4f2d528d | 3775 | |
40a80078 LP |
3776 | /* In case anything used libc syslog(), close this here, too */ |
3777 | closelog(); | |
3778 | ||
b83d5050 | 3779 | int keep_fds[n_fds + 2]; |
1da37e58 ZJS |
3780 | memcpy_safe(keep_fds, fds, n_fds * sizeof(int)); |
3781 | n_keep_fds = n_fds; | |
3782 | ||
3783 | r = add_shifted_fd(keep_fds, ELEMENTSOF(keep_fds), &n_keep_fds, params->exec_fd, &exec_fd); | |
3784 | if (r < 0) { | |
3785 | *exit_status = EXIT_FDS; | |
3786 | return log_unit_error_errno(unit, r, "Failed to shift fd and set FD_CLOEXEC: %m"); | |
3787 | } | |
3788 | ||
3789 | r = close_remaining_fds(params, runtime, dcreds, user_lookup_fd, socket_fd, keep_fds, n_keep_fds); | |
ff0af2a1 LP |
3790 | if (r < 0) { |
3791 | *exit_status = EXIT_FDS; | |
12145637 | 3792 | return log_unit_error_errno(unit, r, "Failed to close unwanted file descriptors: %m"); |
8c7be95e LP |
3793 | } |
3794 | ||
0af07108 ZJS |
3795 | if (!context->same_pgrp && |
3796 | setsid() < 0) { | |
3797 | *exit_status = EXIT_SETSID; | |
3798 | return log_unit_error_errno(unit, errno, "Failed to create new process session: %m"); | |
3799 | } | |
9e2f7c11 | 3800 | |
1e22b5cd | 3801 | exec_context_tty_reset(context, params); |
d35fbf6b | 3802 | |
c891efaf | 3803 | if (unit_shall_confirm_spawn(unit)) { |
7d5ceb64 | 3804 | const char *vc = params->confirm_spawn; |
3b20f877 FB |
3805 | _cleanup_free_ char *cmdline = NULL; |
3806 | ||
ee39ca20 | 3807 | cmdline = exec_command_line(command->argv); |
3b20f877 | 3808 | if (!cmdline) { |
0460aa5c | 3809 | *exit_status = EXIT_MEMORY; |
12145637 | 3810 | return log_oom(); |
3b20f877 | 3811 | } |
d35fbf6b | 3812 | |
eedf223a | 3813 | r = ask_for_confirmation(vc, unit, cmdline); |
3b20f877 FB |
3814 | if (r != CONFIRM_EXECUTE) { |
3815 | if (r == CONFIRM_PRETEND_SUCCESS) { | |
3816 | *exit_status = EXIT_SUCCESS; | |
3817 | return 0; | |
3818 | } | |
ff0af2a1 | 3819 | *exit_status = EXIT_CONFIRM; |
0af07108 ZJS |
3820 | return log_unit_error_errno(unit, SYNTHETIC_ERRNO(ECANCELED), |
3821 | "Execution cancelled by the user"); | |
d35fbf6b DM |
3822 | } |
3823 | } | |
1a63a750 | 3824 | |
d521916d LP |
3825 | /* We are about to invoke NSS and PAM modules. Let's tell them what we are doing here, maybe they care. This is |
3826 | * used by nss-resolve to disable itself when we are about to start systemd-resolved, to avoid deadlocks. Note | |
3827 | * that these env vars do not survive the execve(), which means they really only apply to the PAM and NSS | |
3828 | * invocations themselves. Also note that while we'll only invoke NSS modules involved in user management they | |
3829 | * might internally call into other NSS modules that are involved in hostname resolution, we never know. */ | |
3830 | if (setenv("SYSTEMD_ACTIVATION_UNIT", unit->id, true) != 0 || | |
3831 | setenv("SYSTEMD_ACTIVATION_SCOPE", MANAGER_IS_SYSTEM(unit->manager) ? "system" : "user", true) != 0) { | |
3832 | *exit_status = EXIT_MEMORY; | |
3833 | return log_unit_error_errno(unit, errno, "Failed to update environment: %m"); | |
3834 | } | |
3835 | ||
29206d46 | 3836 | if (context->dynamic_user && dcreds) { |
da50b85a | 3837 | _cleanup_strv_free_ char **suggested_paths = NULL; |
29206d46 | 3838 | |
d521916d LP |
3839 | /* On top of that, make sure we bypass our own NSS module nss-systemd comprehensively for any NSS |
3840 | * checks, if DynamicUser=1 is used, as we shouldn't create a feedback loop with ourselves here.*/ | |
409093fe LP |
3841 | if (putenv((char*) "SYSTEMD_NSS_DYNAMIC_BYPASS=1") != 0) { |
3842 | *exit_status = EXIT_USER; | |
12145637 | 3843 | return log_unit_error_errno(unit, errno, "Failed to update environment: %m"); |
409093fe LP |
3844 | } |
3845 | ||
da50b85a LP |
3846 | r = compile_suggested_paths(context, params, &suggested_paths); |
3847 | if (r < 0) { | |
3848 | *exit_status = EXIT_MEMORY; | |
3849 | return log_oom(); | |
3850 | } | |
3851 | ||
3852 | r = dynamic_creds_realize(dcreds, suggested_paths, &uid, &gid); | |
ff0af2a1 LP |
3853 | if (r < 0) { |
3854 | *exit_status = EXIT_USER; | |
d85ff944 YW |
3855 | if (r == -EILSEQ) |
3856 | return log_unit_error_errno(unit, SYNTHETIC_ERRNO(EOPNOTSUPP), | |
3857 | "Failed to update dynamic user credentials: User or group with specified name already exists."); | |
12145637 | 3858 | return log_unit_error_errno(unit, r, "Failed to update dynamic user credentials: %m"); |
524daa8c | 3859 | } |
524daa8c | 3860 | |
70dd455c | 3861 | if (!uid_is_valid(uid)) { |
29206d46 | 3862 | *exit_status = EXIT_USER; |
d85ff944 | 3863 | return log_unit_error_errno(unit, SYNTHETIC_ERRNO(ESRCH), "UID validation failed for \""UID_FMT"\"", uid); |
70dd455c ZJS |
3864 | } |
3865 | ||
3866 | if (!gid_is_valid(gid)) { | |
3867 | *exit_status = EXIT_USER; | |
d85ff944 | 3868 | return log_unit_error_errno(unit, SYNTHETIC_ERRNO(ESRCH), "GID validation failed for \""GID_FMT"\"", gid); |
29206d46 | 3869 | } |
5bc7452b | 3870 | |
29206d46 LP |
3871 | if (dcreds->user) |
3872 | username = dcreds->user->name; | |
3873 | ||
3874 | } else { | |
4d885bd3 DH |
3875 | r = get_fixed_user(context, &username, &uid, &gid, &home, &shell); |
3876 | if (r < 0) { | |
3877 | *exit_status = EXIT_USER; | |
12145637 | 3878 | return log_unit_error_errno(unit, r, "Failed to determine user credentials: %m"); |
5bc7452b | 3879 | } |
5bc7452b | 3880 | |
4d885bd3 DH |
3881 | r = get_fixed_group(context, &groupname, &gid); |
3882 | if (r < 0) { | |
3883 | *exit_status = EXIT_GROUP; | |
12145637 | 3884 | return log_unit_error_errno(unit, r, "Failed to determine group credentials: %m"); |
4d885bd3 | 3885 | } |
cdc5d5c5 | 3886 | } |
29206d46 | 3887 | |
cdc5d5c5 DH |
3888 | /* Initialize user supplementary groups and get SupplementaryGroups= ones */ |
3889 | r = get_supplementary_groups(context, username, groupname, gid, | |
3890 | &supplementary_gids, &ngids); | |
3891 | if (r < 0) { | |
3892 | *exit_status = EXIT_GROUP; | |
12145637 | 3893 | return log_unit_error_errno(unit, r, "Failed to determine supplementary groups: %m"); |
29206d46 | 3894 | } |
5bc7452b | 3895 | |
00d9ef85 LP |
3896 | r = send_user_lookup(unit, user_lookup_fd, uid, gid); |
3897 | if (r < 0) { | |
3898 | *exit_status = EXIT_USER; | |
12145637 | 3899 | return log_unit_error_errno(unit, r, "Failed to send user credentials to PID1: %m"); |
00d9ef85 LP |
3900 | } |
3901 | ||
3902 | user_lookup_fd = safe_close(user_lookup_fd); | |
3903 | ||
6732edab LP |
3904 | r = acquire_home(context, uid, &home, &home_buffer); |
3905 | if (r < 0) { | |
3906 | *exit_status = EXIT_CHDIR; | |
12145637 | 3907 | return log_unit_error_errno(unit, r, "Failed to determine $HOME for user: %m"); |
6732edab LP |
3908 | } |
3909 | ||
d35fbf6b DM |
3910 | /* If a socket is connected to STDIN/STDOUT/STDERR, we |
3911 | * must sure to drop O_NONBLOCK */ | |
3912 | if (socket_fd >= 0) | |
a34ceba6 | 3913 | (void) fd_nonblock(socket_fd, false); |
acbb0225 | 3914 | |
4c70a4a7 MS |
3915 | /* Journald will try to look-up our cgroup in order to populate _SYSTEMD_CGROUP and _SYSTEMD_UNIT fields. |
3916 | * Hence we need to migrate to the target cgroup from init.scope before connecting to journald */ | |
3917 | if (params->cgroup_path) { | |
3918 | _cleanup_free_ char *p = NULL; | |
3919 | ||
3920 | r = exec_parameters_get_cgroup_path(params, &p); | |
3921 | if (r < 0) { | |
3922 | *exit_status = EXIT_CGROUP; | |
3923 | return log_unit_error_errno(unit, r, "Failed to acquire cgroup path: %m"); | |
3924 | } | |
3925 | ||
3926 | r = cg_attach_everywhere(params->cgroup_supported, p, 0, NULL, NULL); | |
3927 | if (r < 0) { | |
3928 | *exit_status = EXIT_CGROUP; | |
3929 | return log_unit_error_errno(unit, r, "Failed to attach to cgroup %s: %m", p); | |
3930 | } | |
3931 | } | |
3932 | ||
a8d08f39 | 3933 | if (context->network_namespace_path && runtime && runtime->netns_storage_socket[0] >= 0) { |
54c2459d | 3934 | r = open_shareable_ns_path(runtime->netns_storage_socket, context->network_namespace_path, CLONE_NEWNET); |
a8d08f39 LP |
3935 | if (r < 0) { |
3936 | *exit_status = EXIT_NETWORK; | |
3937 | return log_unit_error_errno(unit, r, "Failed to open network namespace path %s: %m", context->network_namespace_path); | |
3938 | } | |
3939 | } | |
3940 | ||
a70581ff XR |
3941 | if (context->ipc_namespace_path && runtime && runtime->ipcns_storage_socket[0] >= 0) { |
3942 | r = open_shareable_ns_path(runtime->ipcns_storage_socket, context->ipc_namespace_path, CLONE_NEWIPC); | |
3943 | if (r < 0) { | |
3944 | *exit_status = EXIT_NAMESPACE; | |
3945 | return log_unit_error_errno(unit, r, "Failed to open IPC namespace path %s: %m", context->ipc_namespace_path); | |
3946 | } | |
3947 | } | |
3948 | ||
52c239d7 | 3949 | r = setup_input(context, params, socket_fd, named_iofds); |
ff0af2a1 LP |
3950 | if (r < 0) { |
3951 | *exit_status = EXIT_STDIN; | |
12145637 | 3952 | return log_unit_error_errno(unit, r, "Failed to set up standard input: %m"); |
d35fbf6b | 3953 | } |
034c6ed7 | 3954 | |
52c239d7 | 3955 | 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 |
3956 | if (r < 0) { |
3957 | *exit_status = EXIT_STDOUT; | |
12145637 | 3958 | return log_unit_error_errno(unit, r, "Failed to set up standard output: %m"); |
d35fbf6b DM |
3959 | } |
3960 | ||
52c239d7 | 3961 | 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 |
3962 | if (r < 0) { |
3963 | *exit_status = EXIT_STDERR; | |
12145637 | 3964 | return log_unit_error_errno(unit, r, "Failed to set up standard error output: %m"); |
d35fbf6b DM |
3965 | } |
3966 | ||
d35fbf6b | 3967 | if (context->oom_score_adjust_set) { |
9f8168eb LP |
3968 | /* When we can't make this change due to EPERM, then let's silently skip over it. User namespaces |
3969 | * prohibit write access to this file, and we shouldn't trip up over that. */ | |
3970 | r = set_oom_score_adjust(context->oom_score_adjust); | |
065b4774 | 3971 | if (ERRNO_IS_PRIVILEGE(r)) |
f2341e0a | 3972 | log_unit_debug_errno(unit, r, "Failed to adjust OOM setting, assuming containerized execution, ignoring: %m"); |
12145637 | 3973 | else if (r < 0) { |
ff0af2a1 | 3974 | *exit_status = EXIT_OOM_ADJUST; |
12145637 | 3975 | return log_unit_error_errno(unit, r, "Failed to adjust OOM setting: %m"); |
613b411c | 3976 | } |
d35fbf6b DM |
3977 | } |
3978 | ||
ad21e542 ZJS |
3979 | if (context->coredump_filter_set) { |
3980 | r = set_coredump_filter(context->coredump_filter); | |
3981 | if (ERRNO_IS_PRIVILEGE(r)) | |
3982 | log_unit_debug_errno(unit, r, "Failed to adjust coredump_filter, ignoring: %m"); | |
3983 | else if (r < 0) | |
3984 | return log_unit_error_errno(unit, r, "Failed to adjust coredump_filter: %m"); | |
3985 | } | |
3986 | ||
39090201 DJL |
3987 | if (context->nice_set) { |
3988 | r = setpriority_closest(context->nice); | |
3989 | if (r < 0) | |
3990 | return log_unit_error_errno(unit, r, "Failed to set up process scheduling priority (nice level): %m"); | |
3991 | } | |
613b411c | 3992 | |
d35fbf6b DM |
3993 | if (context->cpu_sched_set) { |
3994 | struct sched_param param = { | |
3995 | .sched_priority = context->cpu_sched_priority, | |
3996 | }; | |
3997 | ||
ff0af2a1 LP |
3998 | r = sched_setscheduler(0, |
3999 | context->cpu_sched_policy | | |
4000 | (context->cpu_sched_reset_on_fork ? | |
4001 | SCHED_RESET_ON_FORK : 0), | |
4002 | ¶m); | |
4003 | if (r < 0) { | |
4004 | *exit_status = EXIT_SETSCHEDULER; | |
12145637 | 4005 | return log_unit_error_errno(unit, errno, "Failed to set up CPU scheduling: %m"); |
fc9b2a84 | 4006 | } |
d35fbf6b | 4007 | } |
fc9b2a84 | 4008 | |
e2b2fb7f MS |
4009 | if (context->cpu_affinity_from_numa || context->cpu_set.set) { |
4010 | _cleanup_(cpu_set_reset) CPUSet converted_cpu_set = {}; | |
4011 | const CPUSet *cpu_set; | |
4012 | ||
4013 | if (context->cpu_affinity_from_numa) { | |
4014 | r = exec_context_cpu_affinity_from_numa(context, &converted_cpu_set); | |
4015 | if (r < 0) { | |
4016 | *exit_status = EXIT_CPUAFFINITY; | |
4017 | return log_unit_error_errno(unit, r, "Failed to derive CPU affinity mask from NUMA mask: %m"); | |
4018 | } | |
4019 | ||
4020 | cpu_set = &converted_cpu_set; | |
4021 | } else | |
4022 | cpu_set = &context->cpu_set; | |
4023 | ||
4024 | if (sched_setaffinity(0, cpu_set->allocated, cpu_set->set) < 0) { | |
ff0af2a1 | 4025 | *exit_status = EXIT_CPUAFFINITY; |
12145637 | 4026 | return log_unit_error_errno(unit, errno, "Failed to set up CPU affinity: %m"); |
034c6ed7 | 4027 | } |
e2b2fb7f | 4028 | } |
034c6ed7 | 4029 | |
b070c7c0 MS |
4030 | if (mpol_is_valid(numa_policy_get_type(&context->numa_policy))) { |
4031 | r = apply_numa_policy(&context->numa_policy); | |
4032 | if (r == -EOPNOTSUPP) | |
33fe9e3f | 4033 | log_unit_debug_errno(unit, r, "NUMA support not available, ignoring."); |
b070c7c0 MS |
4034 | else if (r < 0) { |
4035 | *exit_status = EXIT_NUMA_POLICY; | |
4036 | return log_unit_error_errno(unit, r, "Failed to set NUMA memory policy: %m"); | |
4037 | } | |
4038 | } | |
4039 | ||
d35fbf6b DM |
4040 | if (context->ioprio_set) |
4041 | if (ioprio_set(IOPRIO_WHO_PROCESS, 0, context->ioprio) < 0) { | |
ff0af2a1 | 4042 | *exit_status = EXIT_IOPRIO; |
12145637 | 4043 | return log_unit_error_errno(unit, errno, "Failed to set up IO scheduling priority: %m"); |
d35fbf6b | 4044 | } |
da726a4d | 4045 | |
d35fbf6b DM |
4046 | if (context->timer_slack_nsec != NSEC_INFINITY) |
4047 | if (prctl(PR_SET_TIMERSLACK, context->timer_slack_nsec) < 0) { | |
ff0af2a1 | 4048 | *exit_status = EXIT_TIMERSLACK; |
12145637 | 4049 | return log_unit_error_errno(unit, errno, "Failed to set up timer slack: %m"); |
4c2630eb | 4050 | } |
9eba9da4 | 4051 | |
21022b9d LP |
4052 | if (context->personality != PERSONALITY_INVALID) { |
4053 | r = safe_personality(context->personality); | |
4054 | if (r < 0) { | |
ff0af2a1 | 4055 | *exit_status = EXIT_PERSONALITY; |
12145637 | 4056 | return log_unit_error_errno(unit, r, "Failed to set up execution domain (personality): %m"); |
4c2630eb | 4057 | } |
21022b9d | 4058 | } |
94f04347 | 4059 | |
d35fbf6b | 4060 | if (context->utmp_id) |
df0ff127 | 4061 | utmp_put_init_process(context->utmp_id, getpid_cached(), getsid(0), |
6a93917d | 4062 | context->tty_path, |
023a4f67 LP |
4063 | context->utmp_mode == EXEC_UTMP_INIT ? INIT_PROCESS : |
4064 | context->utmp_mode == EXEC_UTMP_LOGIN ? LOGIN_PROCESS : | |
4065 | USER_PROCESS, | |
6a93917d | 4066 | username); |
d35fbf6b | 4067 | |
08f67696 | 4068 | if (uid_is_valid(uid)) { |
ff0af2a1 LP |
4069 | r = chown_terminal(STDIN_FILENO, uid); |
4070 | if (r < 0) { | |
4071 | *exit_status = EXIT_STDIN; | |
12145637 | 4072 | return log_unit_error_errno(unit, r, "Failed to change ownership of terminal: %m"); |
071830ff | 4073 | } |
d35fbf6b | 4074 | } |
8e274523 | 4075 | |
4e1dfa45 | 4076 | /* If delegation is enabled we'll pass ownership of the cgroup to the user of the new process. On cgroup v1 |
62b9bb26 | 4077 | * this is only about systemd's own hierarchy, i.e. not the controller hierarchies, simply because that's not |
4e1dfa45 | 4078 | * safe. On cgroup v2 there's only one hierarchy anyway, and delegation is safe there, hence in that case only |
62b9bb26 | 4079 | * touch a single hierarchy too. */ |
584b8688 | 4080 | if (params->cgroup_path && context->user && (params->flags & EXEC_CGROUP_DELEGATE)) { |
62b9bb26 | 4081 | r = cg_set_access(SYSTEMD_CGROUP_CONTROLLER, params->cgroup_path, uid, gid); |
ff0af2a1 LP |
4082 | if (r < 0) { |
4083 | *exit_status = EXIT_CGROUP; | |
12145637 | 4084 | return log_unit_error_errno(unit, r, "Failed to adjust control group access: %m"); |
034c6ed7 | 4085 | } |
d35fbf6b | 4086 | } |
034c6ed7 | 4087 | |
5b10116e | 4088 | for (ExecDirectoryType dt = 0; dt < _EXEC_DIRECTORY_TYPE_MAX; dt++) { |
8679efde | 4089 | r = setup_exec_directory(context, params, uid, gid, dt, exit_status); |
12145637 LP |
4090 | if (r < 0) |
4091 | return log_unit_error_errno(unit, r, "Failed to set up special execution directory in %s: %m", params->prefix[dt]); | |
d35fbf6b | 4092 | } |
94f04347 | 4093 | |
bb0c0d6f LP |
4094 | if (FLAGS_SET(params->flags, EXEC_WRITE_CREDENTIALS)) { |
4095 | r = setup_credentials(context, params, unit->id, uid); | |
4096 | if (r < 0) { | |
4097 | *exit_status = EXIT_CREDENTIALS; | |
4098 | return log_unit_error_errno(unit, r, "Failed to set up credentials: %m"); | |
4099 | } | |
4100 | } | |
4101 | ||
7bce046b | 4102 | r = build_environment( |
fd63e712 | 4103 | unit, |
7bce046b LP |
4104 | context, |
4105 | params, | |
4106 | n_fds, | |
4107 | home, | |
4108 | username, | |
4109 | shell, | |
4110 | journal_stream_dev, | |
4111 | journal_stream_ino, | |
4112 | &our_env); | |
2065ca69 JW |
4113 | if (r < 0) { |
4114 | *exit_status = EXIT_MEMORY; | |
12145637 | 4115 | return log_oom(); |
2065ca69 JW |
4116 | } |
4117 | ||
4118 | r = build_pass_environment(context, &pass_env); | |
4119 | if (r < 0) { | |
4120 | *exit_status = EXIT_MEMORY; | |
12145637 | 4121 | return log_oom(); |
2065ca69 JW |
4122 | } |
4123 | ||
4124 | accum_env = strv_env_merge(5, | |
4125 | params->environment, | |
4126 | our_env, | |
4127 | pass_env, | |
4128 | context->environment, | |
44e5d006 | 4129 | files_env); |
2065ca69 JW |
4130 | if (!accum_env) { |
4131 | *exit_status = EXIT_MEMORY; | |
12145637 | 4132 | return log_oom(); |
2065ca69 | 4133 | } |
1280503b | 4134 | accum_env = strv_env_clean(accum_env); |
2065ca69 | 4135 | |
096424d1 | 4136 | (void) umask(context->umask); |
b213e1c1 | 4137 | |
b1edf445 | 4138 | r = setup_keyring(unit, context, params, uid, gid); |
74dd6b51 LP |
4139 | if (r < 0) { |
4140 | *exit_status = EXIT_KEYRING; | |
12145637 | 4141 | return log_unit_error_errno(unit, r, "Failed to set up kernel keyring: %m"); |
74dd6b51 LP |
4142 | } |
4143 | ||
165a31c0 | 4144 | /* We need sandboxing if the caller asked us to apply it and the command isn't explicitly excepted from it */ |
1703fa41 | 4145 | needs_sandboxing = (params->flags & EXEC_APPLY_SANDBOXING) && !(command->flags & EXEC_COMMAND_FULLY_PRIVILEGED); |
7f18ef0a | 4146 | |
165a31c0 LP |
4147 | /* 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 */ |
4148 | needs_ambient_hack = (params->flags & EXEC_APPLY_SANDBOXING) && (command->flags & EXEC_COMMAND_AMBIENT_MAGIC) && !ambient_capabilities_supported(); | |
7f18ef0a | 4149 | |
165a31c0 LP |
4150 | /* 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 */ |
4151 | if (needs_ambient_hack) | |
4152 | needs_setuid = false; | |
4153 | else | |
4154 | needs_setuid = (params->flags & EXEC_APPLY_SANDBOXING) && !(command->flags & (EXEC_COMMAND_FULLY_PRIVILEGED|EXEC_COMMAND_NO_SETUID)); | |
4155 | ||
4156 | if (needs_sandboxing) { | |
7f18ef0a FK |
4157 | /* MAC enablement checks need to be done before a new mount ns is created, as they rely on /sys being |
4158 | * present. The actual MAC context application will happen later, as late as possible, to avoid | |
4159 | * impacting our own code paths. */ | |
4160 | ||
349cc4a5 | 4161 | #if HAVE_SELINUX |
43b1f709 | 4162 | use_selinux = mac_selinux_use(); |
7f18ef0a | 4163 | #endif |
f9fa32f0 | 4164 | #if ENABLE_SMACK |
43b1f709 | 4165 | use_smack = mac_smack_use(); |
7f18ef0a | 4166 | #endif |
349cc4a5 | 4167 | #if HAVE_APPARMOR |
43b1f709 | 4168 | use_apparmor = mac_apparmor_use(); |
7f18ef0a | 4169 | #endif |
165a31c0 | 4170 | } |
7f18ef0a | 4171 | |
ce932d2d LP |
4172 | if (needs_sandboxing) { |
4173 | int which_failed; | |
4174 | ||
4175 | /* Let's set the resource limits before we call into PAM, so that pam_limits wins over what | |
4176 | * is set here. (See below.) */ | |
4177 | ||
4178 | r = setrlimit_closest_all((const struct rlimit* const *) context->rlimit, &which_failed); | |
4179 | if (r < 0) { | |
4180 | *exit_status = EXIT_LIMITS; | |
4181 | return log_unit_error_errno(unit, r, "Failed to adjust resource limit RLIMIT_%s: %m", rlimit_to_string(which_failed)); | |
4182 | } | |
4183 | } | |
4184 | ||
0af07108 | 4185 | if (needs_setuid && context->pam_name && username) { |
ce932d2d LP |
4186 | /* Let's call into PAM after we set up our own idea of resource limits to that pam_limits |
4187 | * wins here. (See above.) */ | |
4188 | ||
1da37e58 | 4189 | /* All fds passed in the fds array will be closed in the pam child process. */ |
0af07108 ZJS |
4190 | r = setup_pam(context->pam_name, username, uid, gid, context->tty_path, &accum_env, fds, n_fds); |
4191 | if (r < 0) { | |
4192 | *exit_status = EXIT_PAM; | |
4193 | return log_unit_error_errno(unit, r, "Failed to set up PAM session: %m"); | |
165a31c0 | 4194 | } |
ac45f971 | 4195 | |
0af07108 ZJS |
4196 | ngids_after_pam = getgroups_alloc(&gids_after_pam); |
4197 | if (ngids_after_pam < 0) { | |
4198 | *exit_status = EXIT_MEMORY; | |
4199 | return log_unit_error_errno(unit, ngids_after_pam, "Failed to obtain groups after setting up PAM: %m"); | |
5749f855 | 4200 | } |
b213e1c1 | 4201 | } |
5749f855 | 4202 | |
0af07108 | 4203 | if (needs_sandboxing && context->private_users && !have_effective_cap(CAP_SYS_ADMIN)) { |
5749f855 AZ |
4204 | /* If we're unprivileged, set up the user namespace first to enable use of the other namespaces. |
4205 | * Users with CAP_SYS_ADMIN can set up user namespaces last because they will be able to | |
4206 | * set up the all of the other namespaces (i.e. network, mount, UTS) without a user namespace. */ | |
0af07108 ZJS |
4207 | |
4208 | userns_set_up = true; | |
4209 | r = setup_private_users(saved_uid, saved_gid, uid, gid); | |
4210 | if (r < 0) { | |
4211 | *exit_status = EXIT_USER; | |
4212 | return log_unit_error_errno(unit, r, "Failed to set up user namespacing for unprivileged user: %m"); | |
5749f855 AZ |
4213 | } |
4214 | } | |
4215 | ||
a8d08f39 LP |
4216 | if ((context->private_network || context->network_namespace_path) && runtime && runtime->netns_storage_socket[0] >= 0) { |
4217 | ||
6e2d7c4f | 4218 | if (ns_type_supported(NAMESPACE_NET)) { |
54c2459d | 4219 | r = setup_shareable_ns(runtime->netns_storage_socket, CLONE_NEWNET); |
ee00d1e9 ZJS |
4220 | if (r == -EPERM) |
4221 | log_unit_warning_errno(unit, r, | |
4222 | "PrivateNetwork=yes is configured, but network namespace setup failed, ignoring: %m"); | |
4223 | else if (r < 0) { | |
6e2d7c4f MS |
4224 | *exit_status = EXIT_NETWORK; |
4225 | return log_unit_error_errno(unit, r, "Failed to set up network namespacing: %m"); | |
4226 | } | |
a8d08f39 LP |
4227 | } else if (context->network_namespace_path) { |
4228 | *exit_status = EXIT_NETWORK; | |
ee00d1e9 ZJS |
4229 | return log_unit_error_errno(unit, SYNTHETIC_ERRNO(EOPNOTSUPP), |
4230 | "NetworkNamespacePath= is not supported, refusing."); | |
6e2d7c4f MS |
4231 | } else |
4232 | log_unit_warning(unit, "PrivateNetwork=yes is configured, but the kernel does not support network namespaces, ignoring."); | |
d35fbf6b | 4233 | } |
169c1bda | 4234 | |
a70581ff XR |
4235 | if ((context->private_ipc || context->ipc_namespace_path) && runtime && runtime->ipcns_storage_socket[0] >= 0) { |
4236 | ||
4237 | if (ns_type_supported(NAMESPACE_IPC)) { | |
4238 | r = setup_shareable_ns(runtime->ipcns_storage_socket, CLONE_NEWIPC); | |
4239 | if (r == -EPERM) | |
4240 | log_unit_warning_errno(unit, r, | |
4241 | "PrivateIPC=yes is configured, but IPC namespace setup failed, ignoring: %m"); | |
4242 | else if (r < 0) { | |
4243 | *exit_status = EXIT_NAMESPACE; | |
4244 | return log_unit_error_errno(unit, r, "Failed to set up IPC namespacing: %m"); | |
4245 | } | |
4246 | } else if (context->ipc_namespace_path) { | |
4247 | *exit_status = EXIT_NAMESPACE; | |
4248 | return log_unit_error_errno(unit, SYNTHETIC_ERRNO(EOPNOTSUPP), | |
4249 | "IPCNamespacePath= is not supported, refusing."); | |
4250 | } else | |
4251 | log_unit_warning(unit, "PrivateIPC=yes is configured, but the kernel does not support IPC namespaces, ignoring."); | |
4252 | } | |
4253 | ||
ee818b89 | 4254 | needs_mount_namespace = exec_needs_mount_namespace(context, params, runtime); |
ee818b89 | 4255 | if (needs_mount_namespace) { |
7cc5ef5f ZJS |
4256 | _cleanup_free_ char *error_path = NULL; |
4257 | ||
9f71ba8d | 4258 | r = apply_mount_namespace(unit, command->flags, context, params, runtime, &error_path); |
3fbe8dbe LP |
4259 | if (r < 0) { |
4260 | *exit_status = EXIT_NAMESPACE; | |
7cc5ef5f ZJS |
4261 | return log_unit_error_errno(unit, r, "Failed to set up mount namespacing%s%s: %m", |
4262 | error_path ? ": " : "", strempty(error_path)); | |
3fbe8dbe | 4263 | } |
d35fbf6b | 4264 | } |
81a2b7ce | 4265 | |
daf8f72b LP |
4266 | if (needs_sandboxing) { |
4267 | r = apply_protect_hostname(unit, context, exit_status); | |
4268 | if (r < 0) | |
4269 | return r; | |
aecd5ac6 TM |
4270 | } |
4271 | ||
5749f855 AZ |
4272 | /* Drop groups as early as possible. |
4273 | * This needs to be done after PrivateDevices=y setup as device nodes should be owned by the host's root. | |
4274 | * For non-root in a userns, devices will be owned by the user/group before the group change, and nobody. */ | |
165a31c0 | 4275 | if (needs_setuid) { |
afb11bf1 DG |
4276 | _cleanup_free_ gid_t *gids_to_enforce = NULL; |
4277 | int ngids_to_enforce = 0; | |
4278 | ||
4279 | ngids_to_enforce = merge_gid_lists(supplementary_gids, | |
4280 | ngids, | |
4281 | gids_after_pam, | |
4282 | ngids_after_pam, | |
4283 | &gids_to_enforce); | |
4284 | if (ngids_to_enforce < 0) { | |
4285 | *exit_status = EXIT_MEMORY; | |
4286 | return log_unit_error_errno(unit, | |
4287 | ngids_to_enforce, | |
4288 | "Failed to merge group lists. Group membership might be incorrect: %m"); | |
4289 | } | |
4290 | ||
4291 | r = enforce_groups(gid, gids_to_enforce, ngids_to_enforce); | |
096424d1 LP |
4292 | if (r < 0) { |
4293 | *exit_status = EXIT_GROUP; | |
12145637 | 4294 | return log_unit_error_errno(unit, r, "Changing group credentials failed: %m"); |
096424d1 | 4295 | } |
165a31c0 | 4296 | } |
096424d1 | 4297 | |
5749f855 AZ |
4298 | /* If the user namespace was not set up above, try to do it now. |
4299 | * It's preferred to set up the user namespace later (after all other namespaces) so as not to be | |
4300 | * restricted by rules pertaining to combining user namspaces with other namespaces (e.g. in the | |
4301 | * case of mount namespaces being less privileged when the mount point list is copied from a | |
4302 | * different user namespace). */ | |
9008e1ac | 4303 | |
5749f855 AZ |
4304 | if (needs_sandboxing && context->private_users && !userns_set_up) { |
4305 | r = setup_private_users(saved_uid, saved_gid, uid, gid); | |
4306 | if (r < 0) { | |
4307 | *exit_status = EXIT_USER; | |
4308 | return log_unit_error_errno(unit, r, "Failed to set up user namespacing: %m"); | |
d251207d LP |
4309 | } |
4310 | } | |
4311 | ||
9f71ba8d ZJS |
4312 | /* Now that the mount namespace has been set up and privileges adjusted, let's look for the thing we |
4313 | * shall execute. */ | |
4314 | ||
4315 | _cleanup_free_ char *executable = NULL; | |
b83d5050 ZJS |
4316 | _cleanup_close_ int executable_fd = -1; |
4317 | r = find_executable_full(command->path, false, &executable, &executable_fd); | |
9f71ba8d ZJS |
4318 | if (r < 0) { |
4319 | if (r != -ENOMEM && (command->flags & EXEC_COMMAND_IGNORE_FAILURE)) { | |
c2503e35 RH |
4320 | log_unit_struct_errno(unit, LOG_INFO, r, |
4321 | "MESSAGE_ID=" SD_MESSAGE_SPAWN_FAILED_STR, | |
4322 | LOG_UNIT_INVOCATION_ID(unit), | |
4323 | LOG_UNIT_MESSAGE(unit, "Executable %s missing, skipping: %m", | |
4324 | command->path), | |
4325 | "EXECUTABLE=%s", command->path); | |
9f71ba8d ZJS |
4326 | return 0; |
4327 | } | |
4328 | ||
4329 | *exit_status = EXIT_EXEC; | |
c2503e35 RH |
4330 | |
4331 | return log_unit_struct_errno(unit, LOG_INFO, r, | |
4332 | "MESSAGE_ID=" SD_MESSAGE_SPAWN_FAILED_STR, | |
4333 | LOG_UNIT_INVOCATION_ID(unit), | |
4334 | LOG_UNIT_MESSAGE(unit, "Failed to locate executable %s: %m", | |
4335 | command->path), | |
4336 | "EXECUTABLE=%s", command->path); | |
9f71ba8d ZJS |
4337 | } |
4338 | ||
b83d5050 ZJS |
4339 | r = add_shifted_fd(keep_fds, ELEMENTSOF(keep_fds), &n_keep_fds, executable_fd, &executable_fd); |
4340 | if (r < 0) { | |
4341 | *exit_status = EXIT_FDS; | |
4342 | return log_unit_error_errno(unit, r, "Failed to shift fd and set FD_CLOEXEC: %m"); | |
4343 | } | |
4344 | ||
9f71ba8d ZJS |
4345 | #if HAVE_SELINUX |
4346 | if (needs_sandboxing && use_selinux && params->selinux_context_net && socket_fd >= 0) { | |
4347 | r = mac_selinux_get_child_mls_label(socket_fd, executable, context->selinux_context, &mac_selinux_context_net); | |
4348 | if (r < 0) { | |
4349 | *exit_status = EXIT_SELINUX_CONTEXT; | |
4350 | return log_unit_error_errno(unit, r, "Failed to determine SELinux context: %m"); | |
4351 | } | |
4352 | } | |
4353 | #endif | |
4354 | ||
165a31c0 | 4355 | /* We repeat the fd closing here, to make sure that nothing is leaked from the PAM modules. Note that we are |
a70581ff | 4356 | * more aggressive this time since socket_fd and the netns and ipcns fds we don't need anymore. We do keep the exec_fd |
5686391b LP |
4357 | * however if we have it as we want to keep it open until the final execve(). */ |
4358 | ||
1da37e58 | 4359 | r = close_all_fds(keep_fds, n_keep_fds); |
ff0af2a1 LP |
4360 | if (r >= 0) |
4361 | r = shift_fds(fds, n_fds); | |
4362 | if (r >= 0) | |
25b583d7 | 4363 | r = flags_fds(fds, n_socket_fds, n_storage_fds, context->non_blocking); |
ff0af2a1 LP |
4364 | if (r < 0) { |
4365 | *exit_status = EXIT_FDS; | |
12145637 | 4366 | return log_unit_error_errno(unit, r, "Failed to adjust passed file descriptors: %m"); |
d35fbf6b | 4367 | } |
e66cf1a3 | 4368 | |
5686391b LP |
4369 | /* At this point, the fds we want to pass to the program are all ready and set up, with O_CLOEXEC turned off |
4370 | * and at the right fd numbers. The are no other fds open, with one exception: the exec_fd if it is defined, | |
4371 | * and it has O_CLOEXEC set, after all we want it to be closed by the execve(), so that our parent knows we | |
4372 | * came this far. */ | |
4373 | ||
165a31c0 | 4374 | secure_bits = context->secure_bits; |
e66cf1a3 | 4375 | |
165a31c0 LP |
4376 | if (needs_sandboxing) { |
4377 | uint64_t bset; | |
e66cf1a3 | 4378 | |
ce932d2d LP |
4379 | /* Set the RTPRIO resource limit to 0, but only if nothing else was explicitly |
4380 | * requested. (Note this is placed after the general resource limit initialization, see | |
4381 | * above, in order to take precedence.) */ | |
f4170c67 LP |
4382 | if (context->restrict_realtime && !context->rlimit[RLIMIT_RTPRIO]) { |
4383 | if (setrlimit(RLIMIT_RTPRIO, &RLIMIT_MAKE_CONST(0)) < 0) { | |
4384 | *exit_status = EXIT_LIMITS; | |
12145637 | 4385 | return log_unit_error_errno(unit, errno, "Failed to adjust RLIMIT_RTPRIO resource limit: %m"); |
f4170c67 LP |
4386 | } |
4387 | } | |
4388 | ||
37ac2744 JB |
4389 | #if ENABLE_SMACK |
4390 | /* LSM Smack needs the capability CAP_MAC_ADMIN to change the current execution security context of the | |
4391 | * process. This is the latest place before dropping capabilities. Other MAC context are set later. */ | |
4392 | if (use_smack) { | |
b83d5050 | 4393 | r = setup_smack(context, executable_fd); |
37ac2744 JB |
4394 | if (r < 0) { |
4395 | *exit_status = EXIT_SMACK_PROCESS_LABEL; | |
4396 | return log_unit_error_errno(unit, r, "Failed to set SMACK process label: %m"); | |
4397 | } | |
4398 | } | |
4399 | #endif | |
4400 | ||
165a31c0 LP |
4401 | bset = context->capability_bounding_set; |
4402 | /* If the ambient caps hack is enabled (which means the kernel can't do them, and the user asked for | |
4403 | * our magic fallback), then let's add some extra caps, so that the service can drop privs of its own, | |
4404 | * instead of us doing that */ | |
4405 | if (needs_ambient_hack) | |
4406 | bset |= (UINT64_C(1) << CAP_SETPCAP) | | |
4407 | (UINT64_C(1) << CAP_SETUID) | | |
4408 | (UINT64_C(1) << CAP_SETGID); | |
4409 | ||
4410 | if (!cap_test_all(bset)) { | |
4411 | r = capability_bounding_set_drop(bset, false); | |
ff0af2a1 LP |
4412 | if (r < 0) { |
4413 | *exit_status = EXIT_CAPABILITIES; | |
12145637 | 4414 | return log_unit_error_errno(unit, r, "Failed to drop capabilities: %m"); |
3b8bddde | 4415 | } |
4c2630eb | 4416 | } |
3b8bddde | 4417 | |
16fcb191 TK |
4418 | /* Ambient capabilities are cleared during setresuid() (in enforce_user()) even with |
4419 | * keep-caps set. | |
4420 | * To be able to raise the ambient capabilities after setresuid() they have to be | |
4421 | * added to the inherited set and keep caps has to be set (done in enforce_user()). | |
4422 | * After setresuid() the ambient capabilities can be raised as they are present in | |
4423 | * the permitted and inhertiable set. However it is possible that someone wants to | |
4424 | * set ambient capabilities without changing the user, so we also set the ambient | |
4425 | * capabilities here. | |
4426 | * The requested ambient capabilities are raised in the inheritable set if the | |
4427 | * second argument is true. */ | |
943800f4 | 4428 | if (!needs_ambient_hack) { |
755d4b67 IP |
4429 | r = capability_ambient_set_apply(context->capability_ambient_set, true); |
4430 | if (r < 0) { | |
4431 | *exit_status = EXIT_CAPABILITIES; | |
12145637 | 4432 | return log_unit_error_errno(unit, r, "Failed to apply ambient capabilities (before UID change): %m"); |
755d4b67 | 4433 | } |
755d4b67 | 4434 | } |
165a31c0 | 4435 | } |
755d4b67 | 4436 | |
fa97f630 JB |
4437 | /* chroot to root directory first, before we lose the ability to chroot */ |
4438 | r = apply_root_directory(context, params, needs_mount_namespace, exit_status); | |
4439 | if (r < 0) | |
4440 | return log_unit_error_errno(unit, r, "Chrooting to the requested root directory failed: %m"); | |
4441 | ||
165a31c0 | 4442 | if (needs_setuid) { |
08f67696 | 4443 | if (uid_is_valid(uid)) { |
ff0af2a1 LP |
4444 | r = enforce_user(context, uid); |
4445 | if (r < 0) { | |
4446 | *exit_status = EXIT_USER; | |
12145637 | 4447 | return log_unit_error_errno(unit, r, "Failed to change UID to " UID_FMT ": %m", uid); |
5b6319dc | 4448 | } |
165a31c0 LP |
4449 | |
4450 | if (!needs_ambient_hack && | |
4451 | context->capability_ambient_set != 0) { | |
755d4b67 | 4452 | |
16fcb191 | 4453 | /* Raise the ambient capabilities after user change. */ |
755d4b67 IP |
4454 | r = capability_ambient_set_apply(context->capability_ambient_set, false); |
4455 | if (r < 0) { | |
4456 | *exit_status = EXIT_CAPABILITIES; | |
12145637 | 4457 | return log_unit_error_errno(unit, r, "Failed to apply ambient capabilities (after UID change): %m"); |
755d4b67 | 4458 | } |
755d4b67 | 4459 | } |
5b6319dc | 4460 | } |
165a31c0 | 4461 | } |
d35fbf6b | 4462 | |
56ef8db9 JB |
4463 | /* Apply working directory here, because the working directory might be on NFS and only the user running |
4464 | * this service might have the correct privilege to change to the working directory */ | |
fa97f630 | 4465 | r = apply_working_directory(context, params, home, exit_status); |
56ef8db9 JB |
4466 | if (r < 0) |
4467 | return log_unit_error_errno(unit, r, "Changing to the requested working directory failed: %m"); | |
4468 | ||
165a31c0 | 4469 | if (needs_sandboxing) { |
37ac2744 | 4470 | /* Apply other MAC contexts late, but before seccomp syscall filtering, as those should really be last to |
5cd9cd35 LP |
4471 | * influence our own codepaths as little as possible. Moreover, applying MAC contexts usually requires |
4472 | * syscalls that are subject to seccomp filtering, hence should probably be applied before the syscalls | |
4473 | * are restricted. */ | |
4474 | ||
349cc4a5 | 4475 | #if HAVE_SELINUX |
43b1f709 | 4476 | if (use_selinux) { |
5cd9cd35 LP |
4477 | char *exec_context = mac_selinux_context_net ?: context->selinux_context; |
4478 | ||
4479 | if (exec_context) { | |
4480 | r = setexeccon(exec_context); | |
4481 | if (r < 0) { | |
4482 | *exit_status = EXIT_SELINUX_CONTEXT; | |
12145637 | 4483 | return log_unit_error_errno(unit, r, "Failed to change SELinux context to %s: %m", exec_context); |
5cd9cd35 LP |
4484 | } |
4485 | } | |
4486 | } | |
4487 | #endif | |
4488 | ||
349cc4a5 | 4489 | #if HAVE_APPARMOR |
43b1f709 | 4490 | if (use_apparmor && context->apparmor_profile) { |
5cd9cd35 LP |
4491 | r = aa_change_onexec(context->apparmor_profile); |
4492 | if (r < 0 && !context->apparmor_profile_ignore) { | |
4493 | *exit_status = EXIT_APPARMOR_PROFILE; | |
12145637 | 4494 | return log_unit_error_errno(unit, errno, "Failed to prepare AppArmor profile change to %s: %m", context->apparmor_profile); |
5cd9cd35 LP |
4495 | } |
4496 | } | |
4497 | #endif | |
4498 | ||
165a31c0 | 4499 | /* PR_GET_SECUREBITS is not privileged, while PR_SET_SECUREBITS is. So to suppress potential EPERMs |
dbdc4098 TK |
4500 | * we'll try not to call PR_SET_SECUREBITS unless necessary. Setting securebits requires |
4501 | * CAP_SETPCAP. */ | |
4502 | if (prctl(PR_GET_SECUREBITS) != secure_bits) { | |
69e3234d | 4503 | /* CAP_SETPCAP is required to set securebits. This capability is raised into the |
dbdc4098 TK |
4504 | * effective set here. |
4505 | * The effective set is overwritten during execve with the following values: | |
4506 | * - ambient set (for non-root processes) | |
4507 | * - (inheritable | bounding) set for root processes) | |
4508 | * | |
4509 | * Hence there is no security impact to raise it in the effective set before execve | |
4510 | */ | |
4511 | r = capability_gain_cap_setpcap(NULL); | |
4512 | if (r < 0) { | |
4513 | *exit_status = EXIT_CAPABILITIES; | |
4514 | return log_unit_error_errno(unit, r, "Failed to gain CAP_SETPCAP for setting secure bits"); | |
4515 | } | |
755d4b67 | 4516 | if (prctl(PR_SET_SECUREBITS, secure_bits) < 0) { |
ff0af2a1 | 4517 | *exit_status = EXIT_SECUREBITS; |
12145637 | 4518 | return log_unit_error_errno(unit, errno, "Failed to set process secure bits: %m"); |
ff01d048 | 4519 | } |
dbdc4098 | 4520 | } |
5b6319dc | 4521 | |
59eeb84b | 4522 | if (context_has_no_new_privileges(context)) |
d35fbf6b | 4523 | if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) < 0) { |
ff0af2a1 | 4524 | *exit_status = EXIT_NO_NEW_PRIVILEGES; |
12145637 | 4525 | return log_unit_error_errno(unit, errno, "Failed to disable new privileges: %m"); |
d35fbf6b DM |
4526 | } |
4527 | ||
349cc4a5 | 4528 | #if HAVE_SECCOMP |
469830d1 LP |
4529 | r = apply_address_families(unit, context); |
4530 | if (r < 0) { | |
4531 | *exit_status = EXIT_ADDRESS_FAMILIES; | |
12145637 | 4532 | return log_unit_error_errno(unit, r, "Failed to restrict address families: %m"); |
4c2630eb | 4533 | } |
04aa0cb9 | 4534 | |
469830d1 LP |
4535 | r = apply_memory_deny_write_execute(unit, context); |
4536 | if (r < 0) { | |
4537 | *exit_status = EXIT_SECCOMP; | |
12145637 | 4538 | return log_unit_error_errno(unit, r, "Failed to disable writing to executable memory: %m"); |
f3e43635 | 4539 | } |
f4170c67 | 4540 | |
469830d1 LP |
4541 | r = apply_restrict_realtime(unit, context); |
4542 | if (r < 0) { | |
4543 | *exit_status = EXIT_SECCOMP; | |
12145637 | 4544 | return log_unit_error_errno(unit, r, "Failed to apply realtime restrictions: %m"); |
f4170c67 LP |
4545 | } |
4546 | ||
f69567cb LP |
4547 | r = apply_restrict_suid_sgid(unit, context); |
4548 | if (r < 0) { | |
4549 | *exit_status = EXIT_SECCOMP; | |
4550 | return log_unit_error_errno(unit, r, "Failed to apply SUID/SGID restrictions: %m"); | |
4551 | } | |
4552 | ||
add00535 LP |
4553 | r = apply_restrict_namespaces(unit, context); |
4554 | if (r < 0) { | |
4555 | *exit_status = EXIT_SECCOMP; | |
12145637 | 4556 | return log_unit_error_errno(unit, r, "Failed to apply namespace restrictions: %m"); |
add00535 LP |
4557 | } |
4558 | ||
469830d1 LP |
4559 | r = apply_protect_sysctl(unit, context); |
4560 | if (r < 0) { | |
4561 | *exit_status = EXIT_SECCOMP; | |
12145637 | 4562 | return log_unit_error_errno(unit, r, "Failed to apply sysctl restrictions: %m"); |
502d704e DH |
4563 | } |
4564 | ||
469830d1 LP |
4565 | r = apply_protect_kernel_modules(unit, context); |
4566 | if (r < 0) { | |
4567 | *exit_status = EXIT_SECCOMP; | |
12145637 | 4568 | return log_unit_error_errno(unit, r, "Failed to apply module loading restrictions: %m"); |
59eeb84b LP |
4569 | } |
4570 | ||
84703040 KK |
4571 | r = apply_protect_kernel_logs(unit, context); |
4572 | if (r < 0) { | |
4573 | *exit_status = EXIT_SECCOMP; | |
4574 | return log_unit_error_errno(unit, r, "Failed to apply kernel log restrictions: %m"); | |
4575 | } | |
4576 | ||
fc64760d KK |
4577 | r = apply_protect_clock(unit, context); |
4578 | if (r < 0) { | |
4579 | *exit_status = EXIT_SECCOMP; | |
4580 | return log_unit_error_errno(unit, r, "Failed to apply clock restrictions: %m"); | |
4581 | } | |
4582 | ||
469830d1 LP |
4583 | r = apply_private_devices(unit, context); |
4584 | if (r < 0) { | |
4585 | *exit_status = EXIT_SECCOMP; | |
12145637 | 4586 | return log_unit_error_errno(unit, r, "Failed to set up private devices: %m"); |
469830d1 LP |
4587 | } |
4588 | ||
4589 | r = apply_syscall_archs(unit, context); | |
4590 | if (r < 0) { | |
4591 | *exit_status = EXIT_SECCOMP; | |
12145637 | 4592 | return log_unit_error_errno(unit, r, "Failed to apply syscall architecture restrictions: %m"); |
ba128bb8 LP |
4593 | } |
4594 | ||
78e864e5 TM |
4595 | r = apply_lock_personality(unit, context); |
4596 | if (r < 0) { | |
4597 | *exit_status = EXIT_SECCOMP; | |
12145637 | 4598 | return log_unit_error_errno(unit, r, "Failed to lock personalities: %m"); |
78e864e5 TM |
4599 | } |
4600 | ||
9df2cdd8 TM |
4601 | r = apply_syscall_log(unit, context); |
4602 | if (r < 0) { | |
4603 | *exit_status = EXIT_SECCOMP; | |
4604 | return log_unit_error_errno(unit, r, "Failed to apply system call log filters: %m"); | |
4605 | } | |
4606 | ||
5cd9cd35 LP |
4607 | /* This really should remain the last step before the execve(), to make sure our own code is unaffected |
4608 | * by the filter as little as possible. */ | |
165a31c0 | 4609 | r = apply_syscall_filter(unit, context, needs_ambient_hack); |
469830d1 LP |
4610 | if (r < 0) { |
4611 | *exit_status = EXIT_SECCOMP; | |
12145637 | 4612 | return log_unit_error_errno(unit, r, "Failed to apply system call filters: %m"); |
d35fbf6b DM |
4613 | } |
4614 | #endif | |
d35fbf6b | 4615 | } |
034c6ed7 | 4616 | |
00819cc1 LP |
4617 | if (!strv_isempty(context->unset_environment)) { |
4618 | char **ee = NULL; | |
4619 | ||
4620 | ee = strv_env_delete(accum_env, 1, context->unset_environment); | |
4621 | if (!ee) { | |
4622 | *exit_status = EXIT_MEMORY; | |
12145637 | 4623 | return log_oom(); |
00819cc1 LP |
4624 | } |
4625 | ||
130d3d22 | 4626 | strv_free_and_replace(accum_env, ee); |
00819cc1 LP |
4627 | } |
4628 | ||
7ca69792 AZ |
4629 | if (!FLAGS_SET(command->flags, EXEC_COMMAND_NO_ENV_EXPAND)) { |
4630 | replaced_argv = replace_env_argv(command->argv, accum_env); | |
4631 | if (!replaced_argv) { | |
4632 | *exit_status = EXIT_MEMORY; | |
4633 | return log_oom(); | |
4634 | } | |
4635 | final_argv = replaced_argv; | |
4636 | } else | |
4637 | final_argv = command->argv; | |
034c6ed7 | 4638 | |
f1d34068 | 4639 | if (DEBUG_LOGGING) { |
c2b2df60 | 4640 | _cleanup_free_ char *line = NULL; |
81a2b7ce | 4641 | |
d35fbf6b | 4642 | line = exec_command_line(final_argv); |
a1230ff9 | 4643 | if (line) |
c2503e35 RH |
4644 | log_unit_struct(unit, LOG_DEBUG, |
4645 | "EXECUTABLE=%s", executable, | |
4646 | LOG_UNIT_MESSAGE(unit, "Executing: %s", line), | |
4647 | LOG_UNIT_INVOCATION_ID(unit)); | |
d35fbf6b | 4648 | } |
dd305ec9 | 4649 | |
5686391b LP |
4650 | if (exec_fd >= 0) { |
4651 | uint8_t hot = 1; | |
4652 | ||
4653 | /* We have finished with all our initializations. Let's now let the manager know that. From this point | |
4654 | * on, if the manager sees POLLHUP on the exec_fd, then execve() was successful. */ | |
4655 | ||
4656 | if (write(exec_fd, &hot, sizeof(hot)) < 0) { | |
4657 | *exit_status = EXIT_EXEC; | |
4658 | return log_unit_error_errno(unit, errno, "Failed to enable exec_fd: %m"); | |
4659 | } | |
4660 | } | |
4661 | ||
a6d9111c | 4662 | r = fexecve_or_execve(executable_fd, executable, final_argv, accum_env); |
5686391b LP |
4663 | |
4664 | if (exec_fd >= 0) { | |
4665 | uint8_t hot = 0; | |
4666 | ||
4667 | /* The execve() failed. This means the exec_fd is still open. Which means we need to tell the manager | |
4668 | * that POLLHUP on it no longer means execve() succeeded. */ | |
4669 | ||
4670 | if (write(exec_fd, &hot, sizeof(hot)) < 0) { | |
4671 | *exit_status = EXIT_EXEC; | |
4672 | return log_unit_error_errno(unit, errno, "Failed to disable exec_fd: %m"); | |
4673 | } | |
4674 | } | |
12145637 | 4675 | |
ff0af2a1 | 4676 | *exit_status = EXIT_EXEC; |
9f71ba8d | 4677 | return log_unit_error_errno(unit, r, "Failed to execute %s: %m", executable); |
d35fbf6b | 4678 | } |
81a2b7ce | 4679 | |
34cf6c43 | 4680 | static int exec_context_load_environment(const Unit *unit, const ExecContext *c, char ***l); |
2caa38e9 | 4681 | static int exec_context_named_iofds(const ExecContext *c, const ExecParameters *p, int named_iofds[static 3]); |
34cf6c43 | 4682 | |
f2341e0a LP |
4683 | int exec_spawn(Unit *unit, |
4684 | ExecCommand *command, | |
d35fbf6b DM |
4685 | const ExecContext *context, |
4686 | const ExecParameters *params, | |
4687 | ExecRuntime *runtime, | |
29206d46 | 4688 | DynamicCreds *dcreds, |
d35fbf6b | 4689 | pid_t *ret) { |
8351ceae | 4690 | |
ee39ca20 | 4691 | int socket_fd, r, named_iofds[3] = { -1, -1, -1 }, *fds = NULL; |
78f93209 | 4692 | _cleanup_free_ char *subcgroup_path = NULL; |
d35fbf6b | 4693 | _cleanup_strv_free_ char **files_env = NULL; |
da6053d0 | 4694 | size_t n_storage_fds = 0, n_socket_fds = 0; |
ff0af2a1 | 4695 | _cleanup_free_ char *line = NULL; |
d35fbf6b | 4696 | pid_t pid; |
8351ceae | 4697 | |
f2341e0a | 4698 | assert(unit); |
d35fbf6b DM |
4699 | assert(command); |
4700 | assert(context); | |
4701 | assert(ret); | |
4702 | assert(params); | |
25b583d7 | 4703 | assert(params->fds || (params->n_socket_fds + params->n_storage_fds <= 0)); |
4298d0b5 | 4704 | |
d35fbf6b DM |
4705 | if (context->std_input == EXEC_INPUT_SOCKET || |
4706 | context->std_output == EXEC_OUTPUT_SOCKET || | |
4707 | context->std_error == EXEC_OUTPUT_SOCKET) { | |
17df7223 | 4708 | |
d85ff944 YW |
4709 | if (params->n_socket_fds > 1) |
4710 | return log_unit_error_errno(unit, SYNTHETIC_ERRNO(EINVAL), "Got more than one socket."); | |
eef65bf3 | 4711 | |
d85ff944 YW |
4712 | if (params->n_socket_fds == 0) |
4713 | return log_unit_error_errno(unit, SYNTHETIC_ERRNO(EINVAL), "Got no socket."); | |
488ab41c | 4714 | |
d35fbf6b DM |
4715 | socket_fd = params->fds[0]; |
4716 | } else { | |
4717 | socket_fd = -1; | |
4718 | fds = params->fds; | |
9b141911 | 4719 | n_socket_fds = params->n_socket_fds; |
25b583d7 | 4720 | n_storage_fds = params->n_storage_fds; |
d35fbf6b | 4721 | } |
94f04347 | 4722 | |
34cf6c43 | 4723 | r = exec_context_named_iofds(context, params, named_iofds); |
52c239d7 LB |
4724 | if (r < 0) |
4725 | return log_unit_error_errno(unit, r, "Failed to load a named file descriptor: %m"); | |
4726 | ||
f2341e0a | 4727 | r = exec_context_load_environment(unit, context, &files_env); |
ff0af2a1 | 4728 | if (r < 0) |
f2341e0a | 4729 | return log_unit_error_errno(unit, r, "Failed to load environment files: %m"); |
034c6ed7 | 4730 | |
ee39ca20 | 4731 | line = exec_command_line(command->argv); |
d35fbf6b DM |
4732 | if (!line) |
4733 | return log_oom(); | |
fab56fc5 | 4734 | |
9f71ba8d ZJS |
4735 | /* Fork with up-to-date SELinux label database, so the child inherits the up-to-date db |
4736 | and, until the next SELinux policy changes, we save further reloads in future children. */ | |
2df2152c CG |
4737 | mac_selinux_maybe_reload(); |
4738 | ||
c2503e35 RH |
4739 | log_unit_struct(unit, LOG_DEBUG, |
4740 | LOG_UNIT_MESSAGE(unit, "About to execute %s", line), | |
4741 | "EXECUTABLE=%s", command->path, /* We won't know the real executable path until we create | |
4742 | the mount namespace in the child, but we want to log | |
4743 | from the parent, so we need to use the (possibly | |
4744 | inaccurate) path here. */ | |
4745 | LOG_UNIT_INVOCATION_ID(unit)); | |
12145637 | 4746 | |
78f93209 LP |
4747 | if (params->cgroup_path) { |
4748 | r = exec_parameters_get_cgroup_path(params, &subcgroup_path); | |
4749 | if (r < 0) | |
4750 | return log_unit_error_errno(unit, r, "Failed to acquire subcgroup path: %m"); | |
4751 | if (r > 0) { /* We are using a child cgroup */ | |
4752 | r = cg_create(SYSTEMD_CGROUP_CONTROLLER, subcgroup_path); | |
4753 | if (r < 0) | |
4754 | return log_unit_error_errno(unit, r, "Failed to create control group '%s': %m", subcgroup_path); | |
4e806bfa AZ |
4755 | |
4756 | /* Normally we would not propagate the oomd xattrs to children but since we created this | |
4757 | * sub-cgroup internally we should do it. */ | |
4758 | cgroup_oomd_xattr_apply(unit, subcgroup_path); | |
78f93209 LP |
4759 | } |
4760 | } | |
4761 | ||
d35fbf6b DM |
4762 | pid = fork(); |
4763 | if (pid < 0) | |
74129a12 | 4764 | return log_unit_error_errno(unit, errno, "Failed to fork: %m"); |
d35fbf6b DM |
4765 | |
4766 | if (pid == 0) { | |
12145637 | 4767 | int exit_status = EXIT_SUCCESS; |
ff0af2a1 | 4768 | |
f2341e0a LP |
4769 | r = exec_child(unit, |
4770 | command, | |
ff0af2a1 LP |
4771 | context, |
4772 | params, | |
4773 | runtime, | |
29206d46 | 4774 | dcreds, |
ff0af2a1 | 4775 | socket_fd, |
52c239d7 | 4776 | named_iofds, |
4c47affc | 4777 | fds, |
9b141911 | 4778 | n_socket_fds, |
25b583d7 | 4779 | n_storage_fds, |
ff0af2a1 | 4780 | files_env, |
00d9ef85 | 4781 | unit->manager->user_lookup_fds[1], |
12145637 LP |
4782 | &exit_status); |
4783 | ||
e1714f02 ZJS |
4784 | if (r < 0) { |
4785 | const char *status = | |
4786 | exit_status_to_string(exit_status, | |
e04ed6db | 4787 | EXIT_STATUS_LIBC | EXIT_STATUS_SYSTEMD); |
e1714f02 | 4788 | |
c2503e35 RH |
4789 | log_unit_struct_errno(unit, LOG_ERR, r, |
4790 | "MESSAGE_ID=" SD_MESSAGE_SPAWN_FAILED_STR, | |
4791 | LOG_UNIT_INVOCATION_ID(unit), | |
4792 | LOG_UNIT_MESSAGE(unit, "Failed at step %s spawning %s: %m", | |
4793 | status, command->path), | |
4794 | "EXECUTABLE=%s", command->path); | |
e1714f02 | 4795 | } |
4c2630eb | 4796 | |
ff0af2a1 | 4797 | _exit(exit_status); |
034c6ed7 LP |
4798 | } |
4799 | ||
f2341e0a | 4800 | log_unit_debug(unit, "Forked %s as "PID_FMT, command->path, pid); |
23635a85 | 4801 | |
78f93209 LP |
4802 | /* We add the new process to the cgroup both in the child (so that we can be sure that no user code is ever |
4803 | * executed outside of the cgroup) and in the parent (so that we can be sure that when we kill the cgroup the | |
4804 | * process will be killed too). */ | |
4805 | if (subcgroup_path) | |
4806 | (void) cg_attach(SYSTEMD_CGROUP_CONTROLLER, subcgroup_path, pid); | |
2da3263a | 4807 | |
b58b4116 | 4808 | exec_status_start(&command->exec_status, pid); |
9fb86720 | 4809 | |
034c6ed7 | 4810 | *ret = pid; |
5cb5a6ff LP |
4811 | return 0; |
4812 | } | |
4813 | ||
034c6ed7 LP |
4814 | void exec_context_init(ExecContext *c) { |
4815 | assert(c); | |
4816 | ||
4c12626c | 4817 | c->umask = 0022; |
9eba9da4 | 4818 | c->ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 0); |
94f04347 | 4819 | c->cpu_sched_policy = SCHED_OTHER; |
071830ff | 4820 | c->syslog_priority = LOG_DAEMON|LOG_INFO; |
74922904 | 4821 | c->syslog_level_prefix = true; |
353e12c2 | 4822 | c->ignore_sigpipe = true; |
3a43da28 | 4823 | c->timer_slack_nsec = NSEC_INFINITY; |
050f7277 | 4824 | c->personality = PERSONALITY_INVALID; |
5b10116e ZJS |
4825 | for (ExecDirectoryType t = 0; t < _EXEC_DIRECTORY_TYPE_MAX; t++) |
4826 | c->directories[t].mode = 0755; | |
12213aed | 4827 | c->timeout_clean_usec = USEC_INFINITY; |
a103496c | 4828 | c->capability_bounding_set = CAP_ALL; |
aa9d574d YW |
4829 | assert_cc(NAMESPACE_FLAGS_INITIAL != NAMESPACE_FLAGS_ALL); |
4830 | c->restrict_namespaces = NAMESPACE_FLAGS_INITIAL; | |
d3070fbd | 4831 | c->log_level_max = -1; |
005bfaf1 TM |
4832 | #if HAVE_SECCOMP |
4833 | c->syscall_errno = SECCOMP_ERROR_NUMBER_KILL; | |
4834 | #endif | |
b070c7c0 | 4835 | numa_policy_reset(&c->numa_policy); |
034c6ed7 LP |
4836 | } |
4837 | ||
613b411c | 4838 | void exec_context_done(ExecContext *c) { |
5cb5a6ff LP |
4839 | assert(c); |
4840 | ||
6796073e LP |
4841 | c->environment = strv_free(c->environment); |
4842 | c->environment_files = strv_free(c->environment_files); | |
b4c14404 | 4843 | c->pass_environment = strv_free(c->pass_environment); |
00819cc1 | 4844 | c->unset_environment = strv_free(c->unset_environment); |
8c7be95e | 4845 | |
31ce987c | 4846 | rlimit_free_all(c->rlimit); |
034c6ed7 | 4847 | |
5b10116e | 4848 | for (size_t l = 0; l < 3; l++) { |
52c239d7 | 4849 | c->stdio_fdname[l] = mfree(c->stdio_fdname[l]); |
2038c3f5 LP |
4850 | c->stdio_file[l] = mfree(c->stdio_file[l]); |
4851 | } | |
52c239d7 | 4852 | |
a1e58e8e LP |
4853 | c->working_directory = mfree(c->working_directory); |
4854 | c->root_directory = mfree(c->root_directory); | |
915e6d16 | 4855 | c->root_image = mfree(c->root_image); |
18d73705 | 4856 | c->root_image_options = mount_options_free_all(c->root_image_options); |
0389f4fa LB |
4857 | c->root_hash = mfree(c->root_hash); |
4858 | c->root_hash_size = 0; | |
4859 | c->root_hash_path = mfree(c->root_hash_path); | |
d4d55b0d LB |
4860 | c->root_hash_sig = mfree(c->root_hash_sig); |
4861 | c->root_hash_sig_size = 0; | |
4862 | c->root_hash_sig_path = mfree(c->root_hash_sig_path); | |
0389f4fa | 4863 | c->root_verity = mfree(c->root_verity); |
93f59701 | 4864 | c->extension_images = mount_image_free_many(c->extension_images, &c->n_extension_images); |
a1e58e8e LP |
4865 | c->tty_path = mfree(c->tty_path); |
4866 | c->syslog_identifier = mfree(c->syslog_identifier); | |
4867 | c->user = mfree(c->user); | |
4868 | c->group = mfree(c->group); | |
034c6ed7 | 4869 | |
6796073e | 4870 | c->supplementary_groups = strv_free(c->supplementary_groups); |
94f04347 | 4871 | |
a1e58e8e | 4872 | c->pam_name = mfree(c->pam_name); |
5b6319dc | 4873 | |
2a624c36 AP |
4874 | c->read_only_paths = strv_free(c->read_only_paths); |
4875 | c->read_write_paths = strv_free(c->read_write_paths); | |
4876 | c->inaccessible_paths = strv_free(c->inaccessible_paths); | |
ddc155b2 TM |
4877 | c->exec_paths = strv_free(c->exec_paths); |
4878 | c->no_exec_paths = strv_free(c->no_exec_paths); | |
82c121a4 | 4879 | |
d2d6c096 | 4880 | bind_mount_free_many(c->bind_mounts, c->n_bind_mounts); |
8e06d57c YW |
4881 | c->bind_mounts = NULL; |
4882 | c->n_bind_mounts = 0; | |
2abd4e38 YW |
4883 | temporary_filesystem_free_many(c->temporary_filesystems, c->n_temporary_filesystems); |
4884 | c->temporary_filesystems = NULL; | |
4885 | c->n_temporary_filesystems = 0; | |
b3d13314 | 4886 | c->mount_images = mount_image_free_many(c->mount_images, &c->n_mount_images); |
d2d6c096 | 4887 | |
0985c7c4 | 4888 | cpu_set_reset(&c->cpu_set); |
b070c7c0 | 4889 | numa_policy_reset(&c->numa_policy); |
86a3475b | 4890 | |
a1e58e8e LP |
4891 | c->utmp_id = mfree(c->utmp_id); |
4892 | c->selinux_context = mfree(c->selinux_context); | |
4893 | c->apparmor_profile = mfree(c->apparmor_profile); | |
5b8e1b77 | 4894 | c->smack_process_label = mfree(c->smack_process_label); |
eef65bf3 | 4895 | |
8cfa775f | 4896 | c->syscall_filter = hashmap_free(c->syscall_filter); |
525d3cc7 LP |
4897 | c->syscall_archs = set_free(c->syscall_archs); |
4898 | c->address_families = set_free(c->address_families); | |
e66cf1a3 | 4899 | |
5b10116e ZJS |
4900 | for (ExecDirectoryType t = 0; t < _EXEC_DIRECTORY_TYPE_MAX; t++) |
4901 | c->directories[t].paths = strv_free(c->directories[t].paths); | |
d3070fbd LP |
4902 | |
4903 | c->log_level_max = -1; | |
4904 | ||
4905 | exec_context_free_log_extra_fields(c); | |
08f3be7a | 4906 | |
5ac1530e ZJS |
4907 | c->log_ratelimit_interval_usec = 0; |
4908 | c->log_ratelimit_burst = 0; | |
90fc172e | 4909 | |
08f3be7a LP |
4910 | c->stdin_data = mfree(c->stdin_data); |
4911 | c->stdin_data_size = 0; | |
a8d08f39 LP |
4912 | |
4913 | c->network_namespace_path = mfree(c->network_namespace_path); | |
71d1e583 | 4914 | c->ipc_namespace_path = mfree(c->ipc_namespace_path); |
91dd5f7c LP |
4915 | |
4916 | c->log_namespace = mfree(c->log_namespace); | |
bb0c0d6f LP |
4917 | |
4918 | c->load_credentials = strv_free(c->load_credentials); | |
4919 | c->set_credentials = hashmap_free(c->set_credentials); | |
e66cf1a3 LP |
4920 | } |
4921 | ||
34cf6c43 | 4922 | int exec_context_destroy_runtime_directory(const ExecContext *c, const char *runtime_prefix) { |
e66cf1a3 LP |
4923 | char **i; |
4924 | ||
4925 | assert(c); | |
4926 | ||
4927 | if (!runtime_prefix) | |
4928 | return 0; | |
4929 | ||
3536f49e | 4930 | STRV_FOREACH(i, c->directories[EXEC_DIRECTORY_RUNTIME].paths) { |
c2b2df60 | 4931 | _cleanup_free_ char *p = NULL; |
e66cf1a3 | 4932 | |
494d0247 YW |
4933 | if (exec_directory_is_private(c, EXEC_DIRECTORY_RUNTIME)) |
4934 | p = path_join(runtime_prefix, "private", *i); | |
4935 | else | |
4936 | p = path_join(runtime_prefix, *i); | |
e66cf1a3 LP |
4937 | if (!p) |
4938 | return -ENOMEM; | |
4939 | ||
7bc4bf4a LP |
4940 | /* We execute this synchronously, since we need to be sure this is gone when we start the |
4941 | * service next. */ | |
c6878637 | 4942 | (void) rm_rf(p, REMOVE_ROOT); |
e66cf1a3 LP |
4943 | } |
4944 | ||
4945 | return 0; | |
5cb5a6ff LP |
4946 | } |
4947 | ||
bb0c0d6f LP |
4948 | int exec_context_destroy_credentials(const ExecContext *c, const char *runtime_prefix, const char *unit) { |
4949 | _cleanup_free_ char *p = NULL; | |
4950 | ||
4951 | assert(c); | |
4952 | ||
4953 | if (!runtime_prefix || !unit) | |
4954 | return 0; | |
4955 | ||
4956 | p = path_join(runtime_prefix, "credentials", unit); | |
4957 | if (!p) | |
4958 | return -ENOMEM; | |
4959 | ||
4960 | /* This is either a tmpfs/ramfs of its own, or a plain directory. Either way, let's first try to | |
4961 | * unmount it, and afterwards remove the mount point */ | |
4962 | (void) umount2(p, MNT_DETACH|UMOUNT_NOFOLLOW); | |
4963 | (void) rm_rf(p, REMOVE_ROOT|REMOVE_CHMOD); | |
4964 | ||
4965 | return 0; | |
4966 | } | |
4967 | ||
34cf6c43 | 4968 | static void exec_command_done(ExecCommand *c) { |
43d0fcbd LP |
4969 | assert(c); |
4970 | ||
a1e58e8e | 4971 | c->path = mfree(c->path); |
6796073e | 4972 | c->argv = strv_free(c->argv); |
43d0fcbd LP |
4973 | } |
4974 | ||
da6053d0 | 4975 | void exec_command_done_array(ExecCommand *c, size_t n) { |
fe96c0f8 | 4976 | for (size_t i = 0; i < n; i++) |
43d0fcbd LP |
4977 | exec_command_done(c+i); |
4978 | } | |
4979 | ||
f1acf85a | 4980 | ExecCommand* exec_command_free_list(ExecCommand *c) { |
5cb5a6ff LP |
4981 | ExecCommand *i; |
4982 | ||
4983 | while ((i = c)) { | |
71fda00f | 4984 | LIST_REMOVE(command, c, i); |
43d0fcbd | 4985 | exec_command_done(i); |
5cb5a6ff LP |
4986 | free(i); |
4987 | } | |
f1acf85a ZJS |
4988 | |
4989 | return NULL; | |
5cb5a6ff LP |
4990 | } |
4991 | ||
da6053d0 | 4992 | void exec_command_free_array(ExecCommand **c, size_t n) { |
5b10116e | 4993 | for (size_t i = 0; i < n; i++) |
f1acf85a | 4994 | c[i] = exec_command_free_list(c[i]); |
034c6ed7 LP |
4995 | } |
4996 | ||
6a1d4d9f | 4997 | void exec_command_reset_status_array(ExecCommand *c, size_t n) { |
5b10116e | 4998 | for (size_t i = 0; i < n; i++) |
6a1d4d9f LP |
4999 | exec_status_reset(&c[i].exec_status); |
5000 | } | |
5001 | ||
5002 | void exec_command_reset_status_list_array(ExecCommand **c, size_t n) { | |
5b10116e | 5003 | for (size_t i = 0; i < n; i++) { |
6a1d4d9f LP |
5004 | ExecCommand *z; |
5005 | ||
5006 | LIST_FOREACH(command, z, c[i]) | |
5007 | exec_status_reset(&z->exec_status); | |
5008 | } | |
5009 | } | |
5010 | ||
039f0e70 | 5011 | typedef struct InvalidEnvInfo { |
34cf6c43 | 5012 | const Unit *unit; |
039f0e70 LP |
5013 | const char *path; |
5014 | } InvalidEnvInfo; | |
5015 | ||
5016 | static void invalid_env(const char *p, void *userdata) { | |
5017 | InvalidEnvInfo *info = userdata; | |
5018 | ||
f2341e0a | 5019 | log_unit_error(info->unit, "Ignoring invalid environment assignment '%s': %s", p, info->path); |
039f0e70 LP |
5020 | } |
5021 | ||
52c239d7 LB |
5022 | const char* exec_context_fdname(const ExecContext *c, int fd_index) { |
5023 | assert(c); | |
5024 | ||
5025 | switch (fd_index) { | |
5073ff6b | 5026 | |
52c239d7 LB |
5027 | case STDIN_FILENO: |
5028 | if (c->std_input != EXEC_INPUT_NAMED_FD) | |
5029 | return NULL; | |
5073ff6b | 5030 | |
52c239d7 | 5031 | return c->stdio_fdname[STDIN_FILENO] ?: "stdin"; |
5073ff6b | 5032 | |
52c239d7 LB |
5033 | case STDOUT_FILENO: |
5034 | if (c->std_output != EXEC_OUTPUT_NAMED_FD) | |
5035 | return NULL; | |
5073ff6b | 5036 | |
52c239d7 | 5037 | return c->stdio_fdname[STDOUT_FILENO] ?: "stdout"; |
5073ff6b | 5038 | |
52c239d7 LB |
5039 | case STDERR_FILENO: |
5040 | if (c->std_error != EXEC_OUTPUT_NAMED_FD) | |
5041 | return NULL; | |
5073ff6b | 5042 | |
52c239d7 | 5043 | return c->stdio_fdname[STDERR_FILENO] ?: "stderr"; |
5073ff6b | 5044 | |
52c239d7 LB |
5045 | default: |
5046 | return NULL; | |
5047 | } | |
5048 | } | |
5049 | ||
2caa38e9 LP |
5050 | static int exec_context_named_iofds( |
5051 | const ExecContext *c, | |
5052 | const ExecParameters *p, | |
5053 | int named_iofds[static 3]) { | |
5054 | ||
5b10116e | 5055 | size_t targets; |
56fbd561 | 5056 | const char* stdio_fdname[3]; |
da6053d0 | 5057 | size_t n_fds; |
52c239d7 LB |
5058 | |
5059 | assert(c); | |
5060 | assert(p); | |
2caa38e9 | 5061 | assert(named_iofds); |
52c239d7 LB |
5062 | |
5063 | targets = (c->std_input == EXEC_INPUT_NAMED_FD) + | |
5064 | (c->std_output == EXEC_OUTPUT_NAMED_FD) + | |
5065 | (c->std_error == EXEC_OUTPUT_NAMED_FD); | |
5066 | ||
5b10116e | 5067 | for (size_t i = 0; i < 3; i++) |
52c239d7 LB |
5068 | stdio_fdname[i] = exec_context_fdname(c, i); |
5069 | ||
4c47affc FB |
5070 | n_fds = p->n_storage_fds + p->n_socket_fds; |
5071 | ||
5b10116e | 5072 | for (size_t i = 0; i < n_fds && targets > 0; i++) |
56fbd561 ZJS |
5073 | if (named_iofds[STDIN_FILENO] < 0 && |
5074 | c->std_input == EXEC_INPUT_NAMED_FD && | |
5075 | stdio_fdname[STDIN_FILENO] && | |
5076 | streq(p->fd_names[i], stdio_fdname[STDIN_FILENO])) { | |
5077 | ||
52c239d7 LB |
5078 | named_iofds[STDIN_FILENO] = p->fds[i]; |
5079 | targets--; | |
56fbd561 ZJS |
5080 | |
5081 | } else if (named_iofds[STDOUT_FILENO] < 0 && | |
5082 | c->std_output == EXEC_OUTPUT_NAMED_FD && | |
5083 | stdio_fdname[STDOUT_FILENO] && | |
5084 | streq(p->fd_names[i], stdio_fdname[STDOUT_FILENO])) { | |
5085 | ||
52c239d7 LB |
5086 | named_iofds[STDOUT_FILENO] = p->fds[i]; |
5087 | targets--; | |
56fbd561 ZJS |
5088 | |
5089 | } else if (named_iofds[STDERR_FILENO] < 0 && | |
5090 | c->std_error == EXEC_OUTPUT_NAMED_FD && | |
5091 | stdio_fdname[STDERR_FILENO] && | |
5092 | streq(p->fd_names[i], stdio_fdname[STDERR_FILENO])) { | |
5093 | ||
52c239d7 LB |
5094 | named_iofds[STDERR_FILENO] = p->fds[i]; |
5095 | targets--; | |
5096 | } | |
5097 | ||
56fbd561 | 5098 | return targets == 0 ? 0 : -ENOENT; |
52c239d7 LB |
5099 | } |
5100 | ||
34cf6c43 | 5101 | static int exec_context_load_environment(const Unit *unit, const ExecContext *c, char ***l) { |
8c7be95e LP |
5102 | char **i, **r = NULL; |
5103 | ||
5104 | assert(c); | |
5105 | assert(l); | |
5106 | ||
5107 | STRV_FOREACH(i, c->environment_files) { | |
5108 | char *fn; | |
52511fae | 5109 | int k; |
8c7be95e LP |
5110 | bool ignore = false; |
5111 | char **p; | |
7fd1b19b | 5112 | _cleanup_globfree_ glob_t pglob = {}; |
8c7be95e LP |
5113 | |
5114 | fn = *i; | |
5115 | ||
5116 | if (fn[0] == '-') { | |
5117 | ignore = true; | |
313cefa1 | 5118 | fn++; |
8c7be95e LP |
5119 | } |
5120 | ||
5121 | if (!path_is_absolute(fn)) { | |
8c7be95e LP |
5122 | if (ignore) |
5123 | continue; | |
5124 | ||
5125 | strv_free(r); | |
5126 | return -EINVAL; | |
5127 | } | |
5128 | ||
2bef10ab | 5129 | /* Filename supports globbing, take all matching files */ |
d8c92e8b ZJS |
5130 | k = safe_glob(fn, 0, &pglob); |
5131 | if (k < 0) { | |
2bef10ab PL |
5132 | if (ignore) |
5133 | continue; | |
8c7be95e | 5134 | |
2bef10ab | 5135 | strv_free(r); |
d8c92e8b | 5136 | return k; |
2bef10ab | 5137 | } |
8c7be95e | 5138 | |
d8c92e8b ZJS |
5139 | /* When we don't match anything, -ENOENT should be returned */ |
5140 | assert(pglob.gl_pathc > 0); | |
5141 | ||
5b10116e | 5142 | for (unsigned n = 0; n < pglob.gl_pathc; n++) { |
aa8fbc74 | 5143 | k = load_env_file(NULL, pglob.gl_pathv[n], &p); |
2bef10ab PL |
5144 | if (k < 0) { |
5145 | if (ignore) | |
5146 | continue; | |
8c7be95e | 5147 | |
2bef10ab | 5148 | strv_free(r); |
2bef10ab | 5149 | return k; |
e9c1ea9d | 5150 | } |
ebc05a09 | 5151 | /* Log invalid environment variables with filename */ |
039f0e70 LP |
5152 | if (p) { |
5153 | InvalidEnvInfo info = { | |
f2341e0a | 5154 | .unit = unit, |
039f0e70 LP |
5155 | .path = pglob.gl_pathv[n] |
5156 | }; | |
5157 | ||
5158 | p = strv_env_clean_with_callback(p, invalid_env, &info); | |
5159 | } | |
8c7be95e | 5160 | |
234519ae | 5161 | if (!r) |
2bef10ab PL |
5162 | r = p; |
5163 | else { | |
5164 | char **m; | |
8c7be95e | 5165 | |
2bef10ab PL |
5166 | m = strv_env_merge(2, r, p); |
5167 | strv_free(r); | |
5168 | strv_free(p); | |
c84a9488 | 5169 | if (!m) |
2bef10ab | 5170 | return -ENOMEM; |
2bef10ab PL |
5171 | |
5172 | r = m; | |
5173 | } | |
8c7be95e LP |
5174 | } |
5175 | } | |
5176 | ||
5177 | *l = r; | |
5178 | ||
5179 | return 0; | |
5180 | } | |
5181 | ||
6ac8fdc9 | 5182 | static bool tty_may_match_dev_console(const char *tty) { |
7b912648 | 5183 | _cleanup_free_ char *resolved = NULL; |
6ac8fdc9 | 5184 | |
1e22b5cd LP |
5185 | if (!tty) |
5186 | return true; | |
5187 | ||
a119ec7c | 5188 | tty = skip_dev_prefix(tty); |
6ac8fdc9 MS |
5189 | |
5190 | /* trivial identity? */ | |
5191 | if (streq(tty, "console")) | |
5192 | return true; | |
5193 | ||
7b912648 LP |
5194 | if (resolve_dev_console(&resolved) < 0) |
5195 | return true; /* if we could not resolve, assume it may */ | |
6ac8fdc9 MS |
5196 | |
5197 | /* "tty0" means the active VC, so it may be the same sometimes */ | |
955f1c85 | 5198 | return path_equal(resolved, tty) || (streq(resolved, "tty0") && tty_is_vc(tty)); |
6ac8fdc9 MS |
5199 | } |
5200 | ||
6c0ae739 LP |
5201 | static bool exec_context_may_touch_tty(const ExecContext *ec) { |
5202 | assert(ec); | |
1e22b5cd | 5203 | |
6c0ae739 | 5204 | return ec->tty_reset || |
1e22b5cd LP |
5205 | ec->tty_vhangup || |
5206 | ec->tty_vt_disallocate || | |
6ac8fdc9 MS |
5207 | is_terminal_input(ec->std_input) || |
5208 | is_terminal_output(ec->std_output) || | |
6c0ae739 LP |
5209 | is_terminal_output(ec->std_error); |
5210 | } | |
5211 | ||
5212 | bool exec_context_may_touch_console(const ExecContext *ec) { | |
5213 | ||
5214 | return exec_context_may_touch_tty(ec) && | |
1e22b5cd | 5215 | tty_may_match_dev_console(exec_context_tty_path(ec)); |
6ac8fdc9 MS |
5216 | } |
5217 | ||
15ae422b LP |
5218 | static void strv_fprintf(FILE *f, char **l) { |
5219 | char **g; | |
5220 | ||
5221 | assert(f); | |
5222 | ||
5223 | STRV_FOREACH(g, l) | |
5224 | fprintf(f, " %s", *g); | |
5225 | } | |
5226 | ||
ddc155b2 TM |
5227 | static void strv_dump(FILE* f, const char *prefix, const char *name, char **strv) { |
5228 | assert(f); | |
5229 | assert(prefix); | |
5230 | assert(name); | |
5231 | ||
5232 | if (!strv_isempty(strv)) { | |
a7bd1656 | 5233 | fprintf(f, "%s%s:", prefix, name); |
ddc155b2 TM |
5234 | strv_fprintf(f, strv); |
5235 | fputs("\n", f); | |
5236 | } | |
5237 | } | |
5238 | ||
34cf6c43 | 5239 | void exec_context_dump(const ExecContext *c, FILE* f, const char *prefix) { |
12213aed | 5240 | char **e, **d, buf_clean[FORMAT_TIMESPAN_MAX]; |
add00535 | 5241 | int r; |
9eba9da4 | 5242 | |
5cb5a6ff LP |
5243 | assert(c); |
5244 | assert(f); | |
5245 | ||
4ad49000 | 5246 | prefix = strempty(prefix); |
5cb5a6ff LP |
5247 | |
5248 | fprintf(f, | |
94f04347 LP |
5249 | "%sUMask: %04o\n" |
5250 | "%sWorkingDirectory: %s\n" | |
451a074f | 5251 | "%sRootDirectory: %s\n" |
15ae422b | 5252 | "%sNonBlocking: %s\n" |
64747e2d | 5253 | "%sPrivateTmp: %s\n" |
7f112f50 | 5254 | "%sPrivateDevices: %s\n" |
59eeb84b | 5255 | "%sProtectKernelTunables: %s\n" |
e66a2f65 | 5256 | "%sProtectKernelModules: %s\n" |
84703040 | 5257 | "%sProtectKernelLogs: %s\n" |
fc64760d | 5258 | "%sProtectClock: %s\n" |
59eeb84b | 5259 | "%sProtectControlGroups: %s\n" |
d251207d LP |
5260 | "%sPrivateNetwork: %s\n" |
5261 | "%sPrivateUsers: %s\n" | |
1b8689f9 LP |
5262 | "%sProtectHome: %s\n" |
5263 | "%sProtectSystem: %s\n" | |
5d997827 | 5264 | "%sMountAPIVFS: %s\n" |
f3e43635 | 5265 | "%sIgnoreSIGPIPE: %s\n" |
f4170c67 | 5266 | "%sMemoryDenyWriteExecute: %s\n" |
b1edf445 | 5267 | "%sRestrictRealtime: %s\n" |
f69567cb | 5268 | "%sRestrictSUIDSGID: %s\n" |
aecd5ac6 | 5269 | "%sKeyringMode: %s\n" |
4e399953 LP |
5270 | "%sProtectHostname: %s\n" |
5271 | "%sProtectProc: %s\n" | |
5272 | "%sProcSubset: %s\n", | |
5cb5a6ff | 5273 | prefix, c->umask, |
14eb3285 LP |
5274 | prefix, empty_to_root(c->working_directory), |
5275 | prefix, empty_to_root(c->root_directory), | |
15ae422b | 5276 | prefix, yes_no(c->non_blocking), |
64747e2d | 5277 | prefix, yes_no(c->private_tmp), |
7f112f50 | 5278 | prefix, yes_no(c->private_devices), |
59eeb84b | 5279 | prefix, yes_no(c->protect_kernel_tunables), |
e66a2f65 | 5280 | prefix, yes_no(c->protect_kernel_modules), |
84703040 | 5281 | prefix, yes_no(c->protect_kernel_logs), |
fc64760d | 5282 | prefix, yes_no(c->protect_clock), |
59eeb84b | 5283 | prefix, yes_no(c->protect_control_groups), |
d251207d LP |
5284 | prefix, yes_no(c->private_network), |
5285 | prefix, yes_no(c->private_users), | |
1b8689f9 LP |
5286 | prefix, protect_home_to_string(c->protect_home), |
5287 | prefix, protect_system_to_string(c->protect_system), | |
5e98086d | 5288 | prefix, yes_no(exec_context_get_effective_mount_apivfs(c)), |
f3e43635 | 5289 | prefix, yes_no(c->ignore_sigpipe), |
f4170c67 | 5290 | prefix, yes_no(c->memory_deny_write_execute), |
b1edf445 | 5291 | prefix, yes_no(c->restrict_realtime), |
f69567cb | 5292 | prefix, yes_no(c->restrict_suid_sgid), |
aecd5ac6 | 5293 | prefix, exec_keyring_mode_to_string(c->keyring_mode), |
4e399953 LP |
5294 | prefix, yes_no(c->protect_hostname), |
5295 | prefix, protect_proc_to_string(c->protect_proc), | |
5296 | prefix, proc_subset_to_string(c->proc_subset)); | |
fb33a393 | 5297 | |
915e6d16 LP |
5298 | if (c->root_image) |
5299 | fprintf(f, "%sRootImage: %s\n", prefix, c->root_image); | |
5300 | ||
18d73705 LB |
5301 | if (c->root_image_options) { |
5302 | MountOptions *o; | |
5303 | ||
5304 | fprintf(f, "%sRootImageOptions:", prefix); | |
5305 | LIST_FOREACH(mount_options, o, c->root_image_options) | |
5306 | if (!isempty(o->options)) | |
9ece6444 LB |
5307 | fprintf(f, " %s:%s", |
5308 | partition_designator_to_string(o->partition_designator), | |
5309 | o->options); | |
18d73705 LB |
5310 | fprintf(f, "\n"); |
5311 | } | |
5312 | ||
0389f4fa LB |
5313 | if (c->root_hash) { |
5314 | _cleanup_free_ char *encoded = NULL; | |
5315 | encoded = hexmem(c->root_hash, c->root_hash_size); | |
5316 | if (encoded) | |
5317 | fprintf(f, "%sRootHash: %s\n", prefix, encoded); | |
5318 | } | |
5319 | ||
5320 | if (c->root_hash_path) | |
5321 | fprintf(f, "%sRootHash: %s\n", prefix, c->root_hash_path); | |
5322 | ||
d4d55b0d LB |
5323 | if (c->root_hash_sig) { |
5324 | _cleanup_free_ char *encoded = NULL; | |
5325 | ssize_t len; | |
5326 | len = base64mem(c->root_hash_sig, c->root_hash_sig_size, &encoded); | |
5327 | if (len) | |
5328 | fprintf(f, "%sRootHashSignature: base64:%s\n", prefix, encoded); | |
5329 | } | |
5330 | ||
5331 | if (c->root_hash_sig_path) | |
5332 | fprintf(f, "%sRootHashSignature: %s\n", prefix, c->root_hash_sig_path); | |
5333 | ||
0389f4fa LB |
5334 | if (c->root_verity) |
5335 | fprintf(f, "%sRootVerity: %s\n", prefix, c->root_verity); | |
5336 | ||
8c7be95e LP |
5337 | STRV_FOREACH(e, c->environment) |
5338 | fprintf(f, "%sEnvironment: %s\n", prefix, *e); | |
5339 | ||
5340 | STRV_FOREACH(e, c->environment_files) | |
5341 | fprintf(f, "%sEnvironmentFile: %s\n", prefix, *e); | |
94f04347 | 5342 | |
b4c14404 FB |
5343 | STRV_FOREACH(e, c->pass_environment) |
5344 | fprintf(f, "%sPassEnvironment: %s\n", prefix, *e); | |
5345 | ||
00819cc1 LP |
5346 | STRV_FOREACH(e, c->unset_environment) |
5347 | fprintf(f, "%sUnsetEnvironment: %s\n", prefix, *e); | |
5348 | ||
53f47dfc YW |
5349 | fprintf(f, "%sRuntimeDirectoryPreserve: %s\n", prefix, exec_preserve_mode_to_string(c->runtime_directory_preserve_mode)); |
5350 | ||
5b10116e | 5351 | for (ExecDirectoryType dt = 0; dt < _EXEC_DIRECTORY_TYPE_MAX; dt++) { |
3536f49e YW |
5352 | fprintf(f, "%s%sMode: %04o\n", prefix, exec_directory_type_to_string(dt), c->directories[dt].mode); |
5353 | ||
5354 | STRV_FOREACH(d, c->directories[dt].paths) | |
5355 | fprintf(f, "%s%s: %s\n", prefix, exec_directory_type_to_string(dt), *d); | |
5356 | } | |
c2bbd90b | 5357 | |
12213aed YW |
5358 | fprintf(f, |
5359 | "%sTimeoutCleanSec: %s\n", | |
5360 | prefix, format_timespan(buf_clean, sizeof(buf_clean), c->timeout_clean_usec, USEC_PER_SEC)); | |
5361 | ||
fb33a393 LP |
5362 | if (c->nice_set) |
5363 | fprintf(f, | |
5364 | "%sNice: %i\n", | |
5365 | prefix, c->nice); | |
5366 | ||
dd6c17b1 | 5367 | if (c->oom_score_adjust_set) |
fb33a393 | 5368 | fprintf(f, |
dd6c17b1 LP |
5369 | "%sOOMScoreAdjust: %i\n", |
5370 | prefix, c->oom_score_adjust); | |
9eba9da4 | 5371 | |
ad21e542 ZJS |
5372 | if (c->coredump_filter_set) |
5373 | fprintf(f, | |
5374 | "%sCoredumpFilter: 0x%"PRIx64"\n", | |
5375 | prefix, c->coredump_filter); | |
5376 | ||
5b10116e | 5377 | for (unsigned i = 0; i < RLIM_NLIMITS; i++) |
3c11da9d | 5378 | if (c->rlimit[i]) { |
4c3a2b84 | 5379 | fprintf(f, "%sLimit%s: " RLIM_FMT "\n", |
3c11da9d | 5380 | prefix, rlimit_to_string(i), c->rlimit[i]->rlim_max); |
4c3a2b84 | 5381 | fprintf(f, "%sLimit%sSoft: " RLIM_FMT "\n", |
3c11da9d EV |
5382 | prefix, rlimit_to_string(i), c->rlimit[i]->rlim_cur); |
5383 | } | |
94f04347 | 5384 | |
f8b69d1d | 5385 | if (c->ioprio_set) { |
1756a011 | 5386 | _cleanup_free_ char *class_str = NULL; |
f8b69d1d | 5387 | |
837df140 YW |
5388 | r = ioprio_class_to_string_alloc(IOPRIO_PRIO_CLASS(c->ioprio), &class_str); |
5389 | if (r >= 0) | |
5390 | fprintf(f, "%sIOSchedulingClass: %s\n", prefix, class_str); | |
5391 | ||
5392 | fprintf(f, "%sIOPriority: %lu\n", prefix, IOPRIO_PRIO_DATA(c->ioprio)); | |
f8b69d1d | 5393 | } |
94f04347 | 5394 | |
f8b69d1d | 5395 | if (c->cpu_sched_set) { |
1756a011 | 5396 | _cleanup_free_ char *policy_str = NULL; |
f8b69d1d | 5397 | |
837df140 YW |
5398 | r = sched_policy_to_string_alloc(c->cpu_sched_policy, &policy_str); |
5399 | if (r >= 0) | |
5400 | fprintf(f, "%sCPUSchedulingPolicy: %s\n", prefix, policy_str); | |
5401 | ||
94f04347 | 5402 | fprintf(f, |
38b48754 LP |
5403 | "%sCPUSchedulingPriority: %i\n" |
5404 | "%sCPUSchedulingResetOnFork: %s\n", | |
38b48754 LP |
5405 | prefix, c->cpu_sched_priority, |
5406 | prefix, yes_no(c->cpu_sched_reset_on_fork)); | |
b929bf04 | 5407 | } |
94f04347 | 5408 | |
0985c7c4 | 5409 | if (c->cpu_set.set) { |
e7fca352 MS |
5410 | _cleanup_free_ char *affinity = NULL; |
5411 | ||
5412 | affinity = cpu_set_to_range_string(&c->cpu_set); | |
5413 | fprintf(f, "%sCPUAffinity: %s\n", prefix, affinity); | |
94f04347 LP |
5414 | } |
5415 | ||
b070c7c0 MS |
5416 | if (mpol_is_valid(numa_policy_get_type(&c->numa_policy))) { |
5417 | _cleanup_free_ char *nodes = NULL; | |
5418 | ||
5419 | nodes = cpu_set_to_range_string(&c->numa_policy.nodes); | |
5420 | fprintf(f, "%sNUMAPolicy: %s\n", prefix, mpol_to_string(numa_policy_get_type(&c->numa_policy))); | |
5421 | fprintf(f, "%sNUMAMask: %s\n", prefix, strnull(nodes)); | |
5422 | } | |
5423 | ||
3a43da28 | 5424 | if (c->timer_slack_nsec != NSEC_INFINITY) |
ccd06097 | 5425 | fprintf(f, "%sTimerSlackNSec: "NSEC_FMT "\n", prefix, c->timer_slack_nsec); |
94f04347 LP |
5426 | |
5427 | fprintf(f, | |
80876c20 LP |
5428 | "%sStandardInput: %s\n" |
5429 | "%sStandardOutput: %s\n" | |
5430 | "%sStandardError: %s\n", | |
5431 | prefix, exec_input_to_string(c->std_input), | |
5432 | prefix, exec_output_to_string(c->std_output), | |
5433 | prefix, exec_output_to_string(c->std_error)); | |
5434 | ||
befc4a80 LP |
5435 | if (c->std_input == EXEC_INPUT_NAMED_FD) |
5436 | fprintf(f, "%sStandardInputFileDescriptorName: %s\n", prefix, c->stdio_fdname[STDIN_FILENO]); | |
5437 | if (c->std_output == EXEC_OUTPUT_NAMED_FD) | |
5438 | fprintf(f, "%sStandardOutputFileDescriptorName: %s\n", prefix, c->stdio_fdname[STDOUT_FILENO]); | |
5439 | if (c->std_error == EXEC_OUTPUT_NAMED_FD) | |
5440 | fprintf(f, "%sStandardErrorFileDescriptorName: %s\n", prefix, c->stdio_fdname[STDERR_FILENO]); | |
5441 | ||
5442 | if (c->std_input == EXEC_INPUT_FILE) | |
5443 | fprintf(f, "%sStandardInputFile: %s\n", prefix, c->stdio_file[STDIN_FILENO]); | |
5444 | if (c->std_output == EXEC_OUTPUT_FILE) | |
5445 | fprintf(f, "%sStandardOutputFile: %s\n", prefix, c->stdio_file[STDOUT_FILENO]); | |
566b7d23 ZD |
5446 | if (c->std_output == EXEC_OUTPUT_FILE_APPEND) |
5447 | fprintf(f, "%sStandardOutputFileToAppend: %s\n", prefix, c->stdio_file[STDOUT_FILENO]); | |
8d7dab1f LW |
5448 | if (c->std_output == EXEC_OUTPUT_FILE_TRUNCATE) |
5449 | fprintf(f, "%sStandardOutputFileToTruncate: %s\n", prefix, c->stdio_file[STDOUT_FILENO]); | |
befc4a80 LP |
5450 | if (c->std_error == EXEC_OUTPUT_FILE) |
5451 | fprintf(f, "%sStandardErrorFile: %s\n", prefix, c->stdio_file[STDERR_FILENO]); | |
566b7d23 ZD |
5452 | if (c->std_error == EXEC_OUTPUT_FILE_APPEND) |
5453 | fprintf(f, "%sStandardErrorFileToAppend: %s\n", prefix, c->stdio_file[STDERR_FILENO]); | |
8d7dab1f LW |
5454 | if (c->std_error == EXEC_OUTPUT_FILE_TRUNCATE) |
5455 | fprintf(f, "%sStandardErrorFileToTruncate: %s\n", prefix, c->stdio_file[STDERR_FILENO]); | |
befc4a80 | 5456 | |
80876c20 LP |
5457 | if (c->tty_path) |
5458 | fprintf(f, | |
6ea832a2 LP |
5459 | "%sTTYPath: %s\n" |
5460 | "%sTTYReset: %s\n" | |
5461 | "%sTTYVHangup: %s\n" | |
5462 | "%sTTYVTDisallocate: %s\n", | |
5463 | prefix, c->tty_path, | |
5464 | prefix, yes_no(c->tty_reset), | |
5465 | prefix, yes_no(c->tty_vhangup), | |
5466 | prefix, yes_no(c->tty_vt_disallocate)); | |
94f04347 | 5467 | |
9f6444eb | 5468 | if (IN_SET(c->std_output, |
9f6444eb LP |
5469 | EXEC_OUTPUT_KMSG, |
5470 | EXEC_OUTPUT_JOURNAL, | |
9f6444eb LP |
5471 | EXEC_OUTPUT_KMSG_AND_CONSOLE, |
5472 | EXEC_OUTPUT_JOURNAL_AND_CONSOLE) || | |
5473 | IN_SET(c->std_error, | |
9f6444eb LP |
5474 | EXEC_OUTPUT_KMSG, |
5475 | EXEC_OUTPUT_JOURNAL, | |
9f6444eb LP |
5476 | EXEC_OUTPUT_KMSG_AND_CONSOLE, |
5477 | EXEC_OUTPUT_JOURNAL_AND_CONSOLE)) { | |
f8b69d1d | 5478 | |
5ce70e5b | 5479 | _cleanup_free_ char *fac_str = NULL, *lvl_str = NULL; |
f8b69d1d | 5480 | |
837df140 YW |
5481 | r = log_facility_unshifted_to_string_alloc(c->syslog_priority >> 3, &fac_str); |
5482 | if (r >= 0) | |
5483 | fprintf(f, "%sSyslogFacility: %s\n", prefix, fac_str); | |
f8b69d1d | 5484 | |
837df140 YW |
5485 | r = log_level_to_string_alloc(LOG_PRI(c->syslog_priority), &lvl_str); |
5486 | if (r >= 0) | |
5487 | fprintf(f, "%sSyslogLevel: %s\n", prefix, lvl_str); | |
f8b69d1d | 5488 | } |
94f04347 | 5489 | |
d3070fbd LP |
5490 | if (c->log_level_max >= 0) { |
5491 | _cleanup_free_ char *t = NULL; | |
5492 | ||
5493 | (void) log_level_to_string_alloc(c->log_level_max, &t); | |
5494 | ||
5495 | fprintf(f, "%sLogLevelMax: %s\n", prefix, strna(t)); | |
5496 | } | |
5497 | ||
5ac1530e | 5498 | if (c->log_ratelimit_interval_usec > 0) { |
90fc172e AZ |
5499 | char buf_timespan[FORMAT_TIMESPAN_MAX]; |
5500 | ||
5501 | fprintf(f, | |
5502 | "%sLogRateLimitIntervalSec: %s\n", | |
5ac1530e | 5503 | prefix, format_timespan(buf_timespan, sizeof(buf_timespan), c->log_ratelimit_interval_usec, USEC_PER_SEC)); |
90fc172e AZ |
5504 | } |
5505 | ||
5ac1530e ZJS |
5506 | if (c->log_ratelimit_burst > 0) |
5507 | fprintf(f, "%sLogRateLimitBurst: %u\n", prefix, c->log_ratelimit_burst); | |
90fc172e | 5508 | |
5b10116e ZJS |
5509 | for (size_t j = 0; j < c->n_log_extra_fields; j++) { |
5510 | fprintf(f, "%sLogExtraFields: ", prefix); | |
5511 | fwrite(c->log_extra_fields[j].iov_base, | |
5512 | 1, c->log_extra_fields[j].iov_len, | |
5513 | f); | |
5514 | fputc('\n', f); | |
d3070fbd LP |
5515 | } |
5516 | ||
91dd5f7c LP |
5517 | if (c->log_namespace) |
5518 | fprintf(f, "%sLogNamespace: %s\n", prefix, c->log_namespace); | |
5519 | ||
07d46372 YW |
5520 | if (c->secure_bits) { |
5521 | _cleanup_free_ char *str = NULL; | |
5522 | ||
5523 | r = secure_bits_to_string_alloc(c->secure_bits, &str); | |
5524 | if (r >= 0) | |
5525 | fprintf(f, "%sSecure Bits: %s\n", prefix, str); | |
5526 | } | |
94f04347 | 5527 | |
a103496c | 5528 | if (c->capability_bounding_set != CAP_ALL) { |
dd1f5bd0 | 5529 | _cleanup_free_ char *str = NULL; |
94f04347 | 5530 | |
dd1f5bd0 YW |
5531 | r = capability_set_to_string_alloc(c->capability_bounding_set, &str); |
5532 | if (r >= 0) | |
5533 | fprintf(f, "%sCapabilityBoundingSet: %s\n", prefix, str); | |
755d4b67 IP |
5534 | } |
5535 | ||
5536 | if (c->capability_ambient_set != 0) { | |
dd1f5bd0 | 5537 | _cleanup_free_ char *str = NULL; |
755d4b67 | 5538 | |
dd1f5bd0 YW |
5539 | r = capability_set_to_string_alloc(c->capability_ambient_set, &str); |
5540 | if (r >= 0) | |
5541 | fprintf(f, "%sAmbientCapabilities: %s\n", prefix, str); | |
94f04347 LP |
5542 | } |
5543 | ||
5544 | if (c->user) | |
f2d3769a | 5545 | fprintf(f, "%sUser: %s\n", prefix, c->user); |
94f04347 | 5546 | if (c->group) |
f2d3769a | 5547 | fprintf(f, "%sGroup: %s\n", prefix, c->group); |
94f04347 | 5548 | |
29206d46 LP |
5549 | fprintf(f, "%sDynamicUser: %s\n", prefix, yes_no(c->dynamic_user)); |
5550 | ||
ddc155b2 | 5551 | strv_dump(f, prefix, "SupplementaryGroups", c->supplementary_groups); |
94f04347 | 5552 | |
5b6319dc | 5553 | if (c->pam_name) |
f2d3769a | 5554 | fprintf(f, "%sPAMName: %s\n", prefix, c->pam_name); |
5b6319dc | 5555 | |
ddc155b2 TM |
5556 | strv_dump(f, prefix, "ReadWritePaths", c->read_write_paths); |
5557 | strv_dump(f, prefix, "ReadOnlyPaths", c->read_only_paths); | |
5558 | strv_dump(f, prefix, "InaccessiblePaths", c->inaccessible_paths); | |
5559 | strv_dump(f, prefix, "ExecPaths", c->exec_paths); | |
5560 | strv_dump(f, prefix, "NoExecPaths", c->no_exec_paths); | |
2e22afe9 | 5561 | |
5b10116e ZJS |
5562 | for (size_t i = 0; i < c->n_bind_mounts; i++) |
5563 | fprintf(f, "%s%s: %s%s:%s:%s\n", prefix, | |
5564 | c->bind_mounts[i].read_only ? "BindReadOnlyPaths" : "BindPaths", | |
5565 | c->bind_mounts[i].ignore_enoent ? "-": "", | |
5566 | c->bind_mounts[i].source, | |
5567 | c->bind_mounts[i].destination, | |
5568 | c->bind_mounts[i].recursive ? "rbind" : "norbind"); | |
d2d6c096 | 5569 | |
5b10116e ZJS |
5570 | for (size_t i = 0; i < c->n_temporary_filesystems; i++) { |
5571 | const TemporaryFileSystem *t = c->temporary_filesystems + i; | |
2abd4e38 | 5572 | |
5b10116e ZJS |
5573 | fprintf(f, "%sTemporaryFileSystem: %s%s%s\n", prefix, |
5574 | t->path, | |
5575 | isempty(t->options) ? "" : ":", | |
5576 | strempty(t->options)); | |
5577 | } | |
2abd4e38 | 5578 | |
169c1bda LP |
5579 | if (c->utmp_id) |
5580 | fprintf(f, | |
5581 | "%sUtmpIdentifier: %s\n", | |
5582 | prefix, c->utmp_id); | |
7b52a628 MS |
5583 | |
5584 | if (c->selinux_context) | |
5585 | fprintf(f, | |
5f8640fb LP |
5586 | "%sSELinuxContext: %s%s\n", |
5587 | prefix, c->selinux_context_ignore ? "-" : "", c->selinux_context); | |
17df7223 | 5588 | |
80c21aea WC |
5589 | if (c->apparmor_profile) |
5590 | fprintf(f, | |
5591 | "%sAppArmorProfile: %s%s\n", | |
5592 | prefix, c->apparmor_profile_ignore ? "-" : "", c->apparmor_profile); | |
5593 | ||
5594 | if (c->smack_process_label) | |
5595 | fprintf(f, | |
5596 | "%sSmackProcessLabel: %s%s\n", | |
5597 | prefix, c->smack_process_label_ignore ? "-" : "", c->smack_process_label); | |
5598 | ||
050f7277 | 5599 | if (c->personality != PERSONALITY_INVALID) |
ac45f971 LP |
5600 | fprintf(f, |
5601 | "%sPersonality: %s\n", | |
5602 | prefix, strna(personality_to_string(c->personality))); | |
5603 | ||
78e864e5 TM |
5604 | fprintf(f, |
5605 | "%sLockPersonality: %s\n", | |
5606 | prefix, yes_no(c->lock_personality)); | |
5607 | ||
17df7223 | 5608 | if (c->syscall_filter) { |
349cc4a5 | 5609 | #if HAVE_SECCOMP |
8cfa775f | 5610 | void *id, *val; |
17df7223 | 5611 | bool first = true; |
351a19b1 | 5612 | #endif |
17df7223 LP |
5613 | |
5614 | fprintf(f, | |
57183d11 | 5615 | "%sSystemCallFilter: ", |
17df7223 LP |
5616 | prefix); |
5617 | ||
6b000af4 | 5618 | if (!c->syscall_allow_list) |
17df7223 LP |
5619 | fputc('~', f); |
5620 | ||
349cc4a5 | 5621 | #if HAVE_SECCOMP |
90e74a66 | 5622 | HASHMAP_FOREACH_KEY(val, id, c->syscall_filter) { |
17df7223 | 5623 | _cleanup_free_ char *name = NULL; |
8cfa775f YW |
5624 | const char *errno_name = NULL; |
5625 | int num = PTR_TO_INT(val); | |
17df7223 LP |
5626 | |
5627 | if (first) | |
5628 | first = false; | |
5629 | else | |
5630 | fputc(' ', f); | |
5631 | ||
57183d11 | 5632 | name = seccomp_syscall_resolve_num_arch(SCMP_ARCH_NATIVE, PTR_TO_INT(id) - 1); |
17df7223 | 5633 | fputs(strna(name), f); |
8cfa775f YW |
5634 | |
5635 | if (num >= 0) { | |
005bfaf1 | 5636 | errno_name = seccomp_errno_or_action_to_string(num); |
8cfa775f YW |
5637 | if (errno_name) |
5638 | fprintf(f, ":%s", errno_name); | |
5639 | else | |
5640 | fprintf(f, ":%d", num); | |
5641 | } | |
17df7223 | 5642 | } |
351a19b1 | 5643 | #endif |
17df7223 LP |
5644 | |
5645 | fputc('\n', f); | |
5646 | } | |
5647 | ||
57183d11 | 5648 | if (c->syscall_archs) { |
349cc4a5 | 5649 | #if HAVE_SECCOMP |
57183d11 LP |
5650 | void *id; |
5651 | #endif | |
5652 | ||
5653 | fprintf(f, | |
5654 | "%sSystemCallArchitectures:", | |
5655 | prefix); | |
5656 | ||
349cc4a5 | 5657 | #if HAVE_SECCOMP |
90e74a66 | 5658 | SET_FOREACH(id, c->syscall_archs) |
57183d11 LP |
5659 | fprintf(f, " %s", strna(seccomp_arch_to_string(PTR_TO_UINT32(id) - 1))); |
5660 | #endif | |
5661 | fputc('\n', f); | |
5662 | } | |
5663 | ||
add00535 LP |
5664 | if (exec_context_restrict_namespaces_set(c)) { |
5665 | _cleanup_free_ char *s = NULL; | |
5666 | ||
86c2a9f1 | 5667 | r = namespace_flags_to_string(c->restrict_namespaces, &s); |
add00535 LP |
5668 | if (r >= 0) |
5669 | fprintf(f, "%sRestrictNamespaces: %s\n", | |
dd0395b5 | 5670 | prefix, strna(s)); |
add00535 LP |
5671 | } |
5672 | ||
a8d08f39 LP |
5673 | if (c->network_namespace_path) |
5674 | fprintf(f, | |
5675 | "%sNetworkNamespacePath: %s\n", | |
5676 | prefix, c->network_namespace_path); | |
5677 | ||
3df90f24 | 5678 | if (c->syscall_errno > 0) { |
005bfaf1 | 5679 | #if HAVE_SECCOMP |
3df90f24 | 5680 | const char *errno_name; |
005bfaf1 | 5681 | #endif |
3df90f24 YW |
5682 | |
5683 | fprintf(f, "%sSystemCallErrorNumber: ", prefix); | |
5684 | ||
005bfaf1 TM |
5685 | #if HAVE_SECCOMP |
5686 | errno_name = seccomp_errno_or_action_to_string(c->syscall_errno); | |
3df90f24 | 5687 | if (errno_name) |
005bfaf1 | 5688 | fputs(errno_name, f); |
3df90f24 | 5689 | else |
005bfaf1 TM |
5690 | fprintf(f, "%d", c->syscall_errno); |
5691 | #endif | |
5692 | fputc('\n', f); | |
3df90f24 | 5693 | } |
b3d13314 | 5694 | |
5b10116e | 5695 | for (size_t i = 0; i < c->n_mount_images; i++) { |
427353f6 LB |
5696 | MountOptions *o; |
5697 | ||
79e20ceb | 5698 | fprintf(f, "%sMountImages: %s%s:%s", prefix, |
b3d13314 LB |
5699 | c->mount_images[i].ignore_enoent ? "-": "", |
5700 | c->mount_images[i].source, | |
79e20ceb | 5701 | c->mount_images[i].destination); |
427353f6 | 5702 | LIST_FOREACH(mount_options, o, c->mount_images[i].mount_options) |
79e20ceb | 5703 | fprintf(f, ":%s:%s", |
427353f6 | 5704 | partition_designator_to_string(o->partition_designator), |
79e20ceb | 5705 | strempty(o->options)); |
427353f6 LB |
5706 | fprintf(f, "\n"); |
5707 | } | |
93f59701 LB |
5708 | |
5709 | for (size_t i = 0; i < c->n_extension_images; i++) { | |
5710 | MountOptions *o; | |
5711 | ||
5712 | fprintf(f, "%sExtensionImages: %s%s", prefix, | |
5713 | c->extension_images[i].ignore_enoent ? "-": "", | |
5714 | c->extension_images[i].source); | |
5715 | LIST_FOREACH(mount_options, o, c->extension_images[i].mount_options) | |
5716 | fprintf(f, ":%s:%s", | |
5717 | partition_designator_to_string(o->partition_designator), | |
5718 | strempty(o->options)); | |
5719 | fprintf(f, "\n"); | |
5720 | } | |
5cb5a6ff LP |
5721 | } |
5722 | ||
34cf6c43 | 5723 | bool exec_context_maintains_privileges(const ExecContext *c) { |
a931ad47 LP |
5724 | assert(c); |
5725 | ||
61233823 | 5726 | /* Returns true if the process forked off would run under |
a931ad47 LP |
5727 | * an unchanged UID or as root. */ |
5728 | ||
5729 | if (!c->user) | |
5730 | return true; | |
5731 | ||
5732 | if (streq(c->user, "root") || streq(c->user, "0")) | |
5733 | return true; | |
5734 | ||
5735 | return false; | |
5736 | } | |
5737 | ||
34cf6c43 | 5738 | int exec_context_get_effective_ioprio(const ExecContext *c) { |
7f452159 LP |
5739 | int p; |
5740 | ||
5741 | assert(c); | |
5742 | ||
5743 | if (c->ioprio_set) | |
5744 | return c->ioprio; | |
5745 | ||
5746 | p = ioprio_get(IOPRIO_WHO_PROCESS, 0); | |
5747 | if (p < 0) | |
5748 | return IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 4); | |
5749 | ||
5750 | return p; | |
5751 | } | |
5752 | ||
5e98086d ZJS |
5753 | bool exec_context_get_effective_mount_apivfs(const ExecContext *c) { |
5754 | assert(c); | |
5755 | ||
61198784 | 5756 | /* Explicit setting wins */ |
5e98086d ZJS |
5757 | if (c->mount_apivfs_set) |
5758 | return c->mount_apivfs; | |
5759 | ||
61198784 | 5760 | /* Default to "yes" if root directory or image are specified */ |
74e12520 | 5761 | if (exec_context_with_rootfs(c)) |
61198784 ZJS |
5762 | return true; |
5763 | ||
5e98086d ZJS |
5764 | return false; |
5765 | } | |
5766 | ||
d3070fbd | 5767 | void exec_context_free_log_extra_fields(ExecContext *c) { |
d3070fbd LP |
5768 | assert(c); |
5769 | ||
5b10116e | 5770 | for (size_t l = 0; l < c->n_log_extra_fields; l++) |
d3070fbd LP |
5771 | free(c->log_extra_fields[l].iov_base); |
5772 | c->log_extra_fields = mfree(c->log_extra_fields); | |
5773 | c->n_log_extra_fields = 0; | |
5774 | } | |
5775 | ||
6f765baf | 5776 | void exec_context_revert_tty(ExecContext *c) { |
0ba976e8 LP |
5777 | _cleanup_close_ int fd = -1; |
5778 | const char *path; | |
5779 | struct stat st; | |
6f765baf LP |
5780 | int r; |
5781 | ||
5782 | assert(c); | |
5783 | ||
5784 | /* First, reset the TTY (possibly kicking everybody else from the TTY) */ | |
5785 | exec_context_tty_reset(c, NULL); | |
5786 | ||
5787 | /* And then undo what chown_terminal() did earlier. Note that we only do this if we have a path | |
5788 | * configured. If the TTY was passed to us as file descriptor we assume the TTY is opened and managed | |
5789 | * by whoever passed it to us and thus knows better when and how to chmod()/chown() it back. */ | |
0ba976e8 LP |
5790 | if (!exec_context_may_touch_tty(c)) |
5791 | return; | |
6f765baf | 5792 | |
0ba976e8 LP |
5793 | path = exec_context_tty_path(c); |
5794 | if (!path) | |
5795 | return; | |
6f765baf | 5796 | |
0ba976e8 LP |
5797 | fd = open(path, O_PATH|O_CLOEXEC); |
5798 | if (fd < 0) | |
5799 | return (void) log_full_errno(errno == ENOENT ? LOG_DEBUG : LOG_WARNING, errno, | |
5800 | "Failed to open TTY inode of '%s' to adjust ownership/access mode, ignoring: %m", | |
5801 | path); | |
5802 | ||
5803 | if (fstat(fd, &st) < 0) | |
5804 | return (void) log_warning_errno(errno, "Failed to stat TTY '%s', ignoring: %m", path); | |
5805 | ||
5806 | /* Let's add a superficial check that we only do this for stuff that looks like a TTY. We only check | |
5807 | * if things are a character device, since a proper check either means we'd have to open the TTY and | |
5808 | * use isatty(), but we'd rather not do that since opening TTYs comes with all kinds of side-effects | |
5809 | * and is slow. Or we'd have to hardcode dev_t major information, which we'd rather avoid. Why bother | |
5810 | * with this at all? → https://github.com/systemd/systemd/issues/19213 */ | |
5811 | if (!S_ISCHR(st.st_mode)) | |
5812 | return log_warning("Configured TTY '%s' is not actually a character device, ignoring.", path); | |
5813 | ||
5814 | r = fchmod_and_chown(fd, TTY_MODE, 0, TTY_GID); | |
5815 | if (r < 0) | |
5816 | log_warning_errno(r, "Failed to reset TTY ownership/access mode of %s, ignoring: %m", path); | |
6f765baf LP |
5817 | } |
5818 | ||
4c2f5842 LP |
5819 | int exec_context_get_clean_directories( |
5820 | ExecContext *c, | |
5821 | char **prefix, | |
5822 | ExecCleanMask mask, | |
5823 | char ***ret) { | |
5824 | ||
5825 | _cleanup_strv_free_ char **l = NULL; | |
4c2f5842 LP |
5826 | int r; |
5827 | ||
5828 | assert(c); | |
5829 | assert(prefix); | |
5830 | assert(ret); | |
5831 | ||
5b10116e | 5832 | for (ExecDirectoryType t = 0; t < _EXEC_DIRECTORY_TYPE_MAX; t++) { |
4c2f5842 LP |
5833 | char **i; |
5834 | ||
5835 | if (!FLAGS_SET(mask, 1U << t)) | |
5836 | continue; | |
5837 | ||
5838 | if (!prefix[t]) | |
5839 | continue; | |
5840 | ||
5841 | STRV_FOREACH(i, c->directories[t].paths) { | |
5842 | char *j; | |
5843 | ||
5844 | j = path_join(prefix[t], *i); | |
5845 | if (!j) | |
5846 | return -ENOMEM; | |
5847 | ||
5848 | r = strv_consume(&l, j); | |
5849 | if (r < 0) | |
5850 | return r; | |
7f622a19 YW |
5851 | |
5852 | /* Also remove private directories unconditionally. */ | |
5853 | if (t != EXEC_DIRECTORY_CONFIGURATION) { | |
5854 | j = path_join(prefix[t], "private", *i); | |
5855 | if (!j) | |
5856 | return -ENOMEM; | |
5857 | ||
5858 | r = strv_consume(&l, j); | |
5859 | if (r < 0) | |
5860 | return r; | |
5861 | } | |
4c2f5842 LP |
5862 | } |
5863 | } | |
5864 | ||
5865 | *ret = TAKE_PTR(l); | |
5866 | return 0; | |
5867 | } | |
5868 | ||
5869 | int exec_context_get_clean_mask(ExecContext *c, ExecCleanMask *ret) { | |
5870 | ExecCleanMask mask = 0; | |
5871 | ||
5872 | assert(c); | |
5873 | assert(ret); | |
5874 | ||
5875 | for (ExecDirectoryType t = 0; t < _EXEC_DIRECTORY_TYPE_MAX; t++) | |
5876 | if (!strv_isempty(c->directories[t].paths)) | |
5877 | mask |= 1U << t; | |
5878 | ||
5879 | *ret = mask; | |
5880 | return 0; | |
5881 | } | |
5882 | ||
b58b4116 | 5883 | void exec_status_start(ExecStatus *s, pid_t pid) { |
034c6ed7 | 5884 | assert(s); |
5cb5a6ff | 5885 | |
2ed26ed0 LP |
5886 | *s = (ExecStatus) { |
5887 | .pid = pid, | |
5888 | }; | |
5889 | ||
b58b4116 LP |
5890 | dual_timestamp_get(&s->start_timestamp); |
5891 | } | |
5892 | ||
34cf6c43 | 5893 | void exec_status_exit(ExecStatus *s, const ExecContext *context, pid_t pid, int code, int status) { |
b58b4116 LP |
5894 | assert(s); |
5895 | ||
d46b79bb | 5896 | if (s->pid != pid) |
2ed26ed0 LP |
5897 | *s = (ExecStatus) { |
5898 | .pid = pid, | |
5899 | }; | |
b58b4116 | 5900 | |
63983207 | 5901 | dual_timestamp_get(&s->exit_timestamp); |
9fb86720 | 5902 | |
034c6ed7 LP |
5903 | s->code = code; |
5904 | s->status = status; | |
169c1bda | 5905 | |
6f765baf LP |
5906 | if (context && context->utmp_id) |
5907 | (void) utmp_put_dead_process(context->utmp_id, pid, code, status); | |
9fb86720 LP |
5908 | } |
5909 | ||
6a1d4d9f LP |
5910 | void exec_status_reset(ExecStatus *s) { |
5911 | assert(s); | |
5912 | ||
5913 | *s = (ExecStatus) {}; | |
5914 | } | |
5915 | ||
34cf6c43 | 5916 | void exec_status_dump(const ExecStatus *s, FILE *f, const char *prefix) { |
9fb86720 LP |
5917 | char buf[FORMAT_TIMESTAMP_MAX]; |
5918 | ||
5919 | assert(s); | |
5920 | assert(f); | |
5921 | ||
9fb86720 LP |
5922 | if (s->pid <= 0) |
5923 | return; | |
5924 | ||
4c940960 LP |
5925 | prefix = strempty(prefix); |
5926 | ||
9fb86720 | 5927 | fprintf(f, |
ccd06097 ZJS |
5928 | "%sPID: "PID_FMT"\n", |
5929 | prefix, s->pid); | |
9fb86720 | 5930 | |
af9d16e1 | 5931 | if (dual_timestamp_is_set(&s->start_timestamp)) |
9fb86720 LP |
5932 | fprintf(f, |
5933 | "%sStart Timestamp: %s\n", | |
63983207 | 5934 | prefix, format_timestamp(buf, sizeof(buf), s->start_timestamp.realtime)); |
9fb86720 | 5935 | |
af9d16e1 | 5936 | if (dual_timestamp_is_set(&s->exit_timestamp)) |
9fb86720 LP |
5937 | fprintf(f, |
5938 | "%sExit Timestamp: %s\n" | |
5939 | "%sExit Code: %s\n" | |
5940 | "%sExit Status: %i\n", | |
63983207 | 5941 | prefix, format_timestamp(buf, sizeof(buf), s->exit_timestamp.realtime), |
9fb86720 LP |
5942 | prefix, sigchld_code_to_string(s->code), |
5943 | prefix, s->status); | |
5cb5a6ff | 5944 | } |
44d8db9e | 5945 | |
34cf6c43 | 5946 | static char *exec_command_line(char **argv) { |
44d8db9e LP |
5947 | size_t k; |
5948 | char *n, *p, **a; | |
5949 | bool first = true; | |
5950 | ||
9e2f7c11 | 5951 | assert(argv); |
44d8db9e | 5952 | |
9164977d | 5953 | k = 1; |
9e2f7c11 | 5954 | STRV_FOREACH(a, argv) |
44d8db9e LP |
5955 | k += strlen(*a)+3; |
5956 | ||
5cd9cd35 LP |
5957 | n = new(char, k); |
5958 | if (!n) | |
44d8db9e LP |
5959 | return NULL; |
5960 | ||
5961 | p = n; | |
9e2f7c11 | 5962 | STRV_FOREACH(a, argv) { |
44d8db9e LP |
5963 | |
5964 | if (!first) | |
5965 | *(p++) = ' '; | |
5966 | else | |
5967 | first = false; | |
5968 | ||
5969 | if (strpbrk(*a, WHITESPACE)) { | |
5970 | *(p++) = '\''; | |
5971 | p = stpcpy(p, *a); | |
5972 | *(p++) = '\''; | |
5973 | } else | |
5974 | p = stpcpy(p, *a); | |
5975 | ||
5976 | } | |
5977 | ||
9164977d LP |
5978 | *p = 0; |
5979 | ||
44d8db9e LP |
5980 | /* FIXME: this doesn't really handle arguments that have |
5981 | * spaces and ticks in them */ | |
5982 | ||
5983 | return n; | |
5984 | } | |
5985 | ||
34cf6c43 | 5986 | static void exec_command_dump(ExecCommand *c, FILE *f, const char *prefix) { |
e1d75803 | 5987 | _cleanup_free_ char *cmd = NULL; |
4c940960 | 5988 | const char *prefix2; |
44d8db9e LP |
5989 | |
5990 | assert(c); | |
5991 | assert(f); | |
5992 | ||
4c940960 | 5993 | prefix = strempty(prefix); |
63c372cb | 5994 | prefix2 = strjoina(prefix, "\t"); |
44d8db9e | 5995 | |
9e2f7c11 | 5996 | cmd = exec_command_line(c->argv); |
44d8db9e LP |
5997 | fprintf(f, |
5998 | "%sCommand Line: %s\n", | |
4bbccb02 | 5999 | prefix, cmd ? cmd : strerror_safe(ENOMEM)); |
44d8db9e | 6000 | |
9fb86720 | 6001 | exec_status_dump(&c->exec_status, f, prefix2); |
44d8db9e LP |
6002 | } |
6003 | ||
6004 | void exec_command_dump_list(ExecCommand *c, FILE *f, const char *prefix) { | |
6005 | assert(f); | |
6006 | ||
4c940960 | 6007 | prefix = strempty(prefix); |
44d8db9e LP |
6008 | |
6009 | LIST_FOREACH(command, c, c) | |
6010 | exec_command_dump(c, f, prefix); | |
6011 | } | |
94f04347 | 6012 | |
a6a80b4f LP |
6013 | void exec_command_append_list(ExecCommand **l, ExecCommand *e) { |
6014 | ExecCommand *end; | |
6015 | ||
6016 | assert(l); | |
6017 | assert(e); | |
6018 | ||
6019 | if (*l) { | |
35b8ca3a | 6020 | /* It's kind of important, that we keep the order here */ |
71fda00f LP |
6021 | LIST_FIND_TAIL(command, *l, end); |
6022 | LIST_INSERT_AFTER(command, *l, end, e); | |
a6a80b4f LP |
6023 | } else |
6024 | *l = e; | |
6025 | } | |
6026 | ||
26fd040d LP |
6027 | int exec_command_set(ExecCommand *c, const char *path, ...) { |
6028 | va_list ap; | |
6029 | char **l, *p; | |
6030 | ||
6031 | assert(c); | |
6032 | assert(path); | |
6033 | ||
6034 | va_start(ap, path); | |
6035 | l = strv_new_ap(path, ap); | |
6036 | va_end(ap); | |
6037 | ||
6038 | if (!l) | |
6039 | return -ENOMEM; | |
6040 | ||
250a918d LP |
6041 | p = strdup(path); |
6042 | if (!p) { | |
26fd040d LP |
6043 | strv_free(l); |
6044 | return -ENOMEM; | |
6045 | } | |
6046 | ||
6897dfe8 | 6047 | free_and_replace(c->path, p); |
26fd040d | 6048 | |
130d3d22 | 6049 | return strv_free_and_replace(c->argv, l); |
26fd040d LP |
6050 | } |
6051 | ||
86b23b07 | 6052 | int exec_command_append(ExecCommand *c, const char *path, ...) { |
e63ff941 | 6053 | _cleanup_strv_free_ char **l = NULL; |
86b23b07 | 6054 | va_list ap; |
86b23b07 JS |
6055 | int r; |
6056 | ||
6057 | assert(c); | |
6058 | assert(path); | |
6059 | ||
6060 | va_start(ap, path); | |
6061 | l = strv_new_ap(path, ap); | |
6062 | va_end(ap); | |
6063 | ||
6064 | if (!l) | |
6065 | return -ENOMEM; | |
6066 | ||
e287086b | 6067 | r = strv_extend_strv(&c->argv, l, false); |
e63ff941 | 6068 | if (r < 0) |
86b23b07 | 6069 | return r; |
86b23b07 JS |
6070 | |
6071 | return 0; | |
6072 | } | |
6073 | ||
e8a565cb YW |
6074 | static void *remove_tmpdir_thread(void *p) { |
6075 | _cleanup_free_ char *path = p; | |
86b23b07 | 6076 | |
e8a565cb YW |
6077 | (void) rm_rf(path, REMOVE_ROOT|REMOVE_PHYSICAL); |
6078 | return NULL; | |
6079 | } | |
6080 | ||
6081 | static ExecRuntime* exec_runtime_free(ExecRuntime *rt, bool destroy) { | |
6082 | int r; | |
6083 | ||
6084 | if (!rt) | |
6085 | return NULL; | |
6086 | ||
6087 | if (rt->manager) | |
6088 | (void) hashmap_remove(rt->manager->exec_runtime_by_id, rt->id); | |
6089 | ||
6090 | /* When destroy is true, then rm_rf tmp_dir and var_tmp_dir. */ | |
56a13a49 ZJS |
6091 | |
6092 | if (destroy && rt->tmp_dir && !streq(rt->tmp_dir, RUN_SYSTEMD_EMPTY)) { | |
e8a565cb YW |
6093 | log_debug("Spawning thread to nuke %s", rt->tmp_dir); |
6094 | ||
6095 | r = asynchronous_job(remove_tmpdir_thread, rt->tmp_dir); | |
56a13a49 | 6096 | if (r < 0) |
e8a565cb | 6097 | log_warning_errno(r, "Failed to nuke %s: %m", rt->tmp_dir); |
56a13a49 ZJS |
6098 | else |
6099 | rt->tmp_dir = NULL; | |
e8a565cb | 6100 | } |
613b411c | 6101 | |
56a13a49 | 6102 | if (destroy && rt->var_tmp_dir && !streq(rt->var_tmp_dir, RUN_SYSTEMD_EMPTY)) { |
e8a565cb YW |
6103 | log_debug("Spawning thread to nuke %s", rt->var_tmp_dir); |
6104 | ||
6105 | r = asynchronous_job(remove_tmpdir_thread, rt->var_tmp_dir); | |
56a13a49 | 6106 | if (r < 0) |
e8a565cb | 6107 | log_warning_errno(r, "Failed to nuke %s: %m", rt->var_tmp_dir); |
56a13a49 ZJS |
6108 | else |
6109 | rt->var_tmp_dir = NULL; | |
e8a565cb YW |
6110 | } |
6111 | ||
6112 | rt->id = mfree(rt->id); | |
6113 | rt->tmp_dir = mfree(rt->tmp_dir); | |
6114 | rt->var_tmp_dir = mfree(rt->var_tmp_dir); | |
6115 | safe_close_pair(rt->netns_storage_socket); | |
a70581ff | 6116 | safe_close_pair(rt->ipcns_storage_socket); |
e8a565cb YW |
6117 | return mfree(rt); |
6118 | } | |
6119 | ||
6120 | static void exec_runtime_freep(ExecRuntime **rt) { | |
da6bc6ed | 6121 | (void) exec_runtime_free(*rt, false); |
e8a565cb YW |
6122 | } |
6123 | ||
56a13a49 ZJS |
6124 | static int exec_runtime_allocate(ExecRuntime **ret, const char *id) { |
6125 | _cleanup_free_ char *id_copy = NULL; | |
8e8009dc | 6126 | ExecRuntime *n; |
613b411c | 6127 | |
8e8009dc | 6128 | assert(ret); |
613b411c | 6129 | |
56a13a49 ZJS |
6130 | id_copy = strdup(id); |
6131 | if (!id_copy) | |
6132 | return -ENOMEM; | |
6133 | ||
8e8009dc LP |
6134 | n = new(ExecRuntime, 1); |
6135 | if (!n) | |
613b411c LP |
6136 | return -ENOMEM; |
6137 | ||
8e8009dc | 6138 | *n = (ExecRuntime) { |
56a13a49 | 6139 | .id = TAKE_PTR(id_copy), |
8e8009dc | 6140 | .netns_storage_socket = { -1, -1 }, |
a70581ff | 6141 | .ipcns_storage_socket = { -1, -1 }, |
8e8009dc LP |
6142 | }; |
6143 | ||
6144 | *ret = n; | |
613b411c LP |
6145 | return 0; |
6146 | } | |
6147 | ||
e8a565cb YW |
6148 | static int exec_runtime_add( |
6149 | Manager *m, | |
6150 | const char *id, | |
56a13a49 ZJS |
6151 | char **tmp_dir, |
6152 | char **var_tmp_dir, | |
6153 | int netns_storage_socket[2], | |
a70581ff | 6154 | int ipcns_storage_socket[2], |
e8a565cb YW |
6155 | ExecRuntime **ret) { |
6156 | ||
6157 | _cleanup_(exec_runtime_freep) ExecRuntime *rt = NULL; | |
613b411c LP |
6158 | int r; |
6159 | ||
e8a565cb | 6160 | assert(m); |
613b411c LP |
6161 | assert(id); |
6162 | ||
a70581ff | 6163 | /* tmp_dir, var_tmp_dir, {net,ipc}ns_storage_socket fds are donated on success */ |
56a13a49 | 6164 | |
56a13a49 | 6165 | r = exec_runtime_allocate(&rt, id); |
613b411c LP |
6166 | if (r < 0) |
6167 | return r; | |
6168 | ||
63083706 | 6169 | r = hashmap_ensure_put(&m->exec_runtime_by_id, &string_hash_ops, rt->id, rt); |
56a13a49 ZJS |
6170 | if (r < 0) |
6171 | return r; | |
e8a565cb | 6172 | |
56a13a49 ZJS |
6173 | assert(!!rt->tmp_dir == !!rt->var_tmp_dir); /* We require both to be set together */ |
6174 | rt->tmp_dir = TAKE_PTR(*tmp_dir); | |
6175 | rt->var_tmp_dir = TAKE_PTR(*var_tmp_dir); | |
e8a565cb YW |
6176 | |
6177 | if (netns_storage_socket) { | |
56a13a49 ZJS |
6178 | rt->netns_storage_socket[0] = TAKE_FD(netns_storage_socket[0]); |
6179 | rt->netns_storage_socket[1] = TAKE_FD(netns_storage_socket[1]); | |
613b411c LP |
6180 | } |
6181 | ||
a70581ff XR |
6182 | if (ipcns_storage_socket) { |
6183 | rt->ipcns_storage_socket[0] = TAKE_FD(ipcns_storage_socket[0]); | |
6184 | rt->ipcns_storage_socket[1] = TAKE_FD(ipcns_storage_socket[1]); | |
6185 | } | |
6186 | ||
e8a565cb YW |
6187 | rt->manager = m; |
6188 | ||
6189 | if (ret) | |
6190 | *ret = rt; | |
e8a565cb | 6191 | /* do not remove created ExecRuntime object when the operation succeeds. */ |
56a13a49 | 6192 | TAKE_PTR(rt); |
e8a565cb YW |
6193 | return 0; |
6194 | } | |
6195 | ||
74aaf59b LP |
6196 | static int exec_runtime_make( |
6197 | Manager *m, | |
6198 | const ExecContext *c, | |
6199 | const char *id, | |
6200 | ExecRuntime **ret) { | |
6201 | ||
56a13a49 | 6202 | _cleanup_(namespace_cleanup_tmpdirp) char *tmp_dir = NULL, *var_tmp_dir = NULL; |
a70581ff | 6203 | _cleanup_close_pair_ int netns_storage_socket[2] = { -1, -1 }, ipcns_storage_socket[2] = { -1, -1 }; |
e8a565cb YW |
6204 | int r; |
6205 | ||
6206 | assert(m); | |
6207 | assert(c); | |
6208 | assert(id); | |
6209 | ||
6210 | /* It is not necessary to create ExecRuntime object. */ | |
a70581ff | 6211 | if (!c->private_network && !c->private_ipc && !c->private_tmp && !c->network_namespace_path) { |
74aaf59b | 6212 | *ret = NULL; |
e8a565cb | 6213 | return 0; |
74aaf59b | 6214 | } |
e8a565cb | 6215 | |
efa2f3a1 TM |
6216 | if (c->private_tmp && |
6217 | !(prefixed_path_strv_contains(c->inaccessible_paths, "/tmp") && | |
6218 | (prefixed_path_strv_contains(c->inaccessible_paths, "/var/tmp") || | |
6219 | prefixed_path_strv_contains(c->inaccessible_paths, "/var")))) { | |
e8a565cb | 6220 | r = setup_tmp_dirs(id, &tmp_dir, &var_tmp_dir); |
613b411c LP |
6221 | if (r < 0) |
6222 | return r; | |
6223 | } | |
6224 | ||
a8d08f39 | 6225 | if (c->private_network || c->network_namespace_path) { |
e8a565cb YW |
6226 | if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, netns_storage_socket) < 0) |
6227 | return -errno; | |
6228 | } | |
6229 | ||
a70581ff XR |
6230 | if (c->private_ipc || c->ipc_namespace_path) { |
6231 | if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, ipcns_storage_socket) < 0) | |
6232 | return -errno; | |
6233 | } | |
6234 | ||
6235 | r = exec_runtime_add(m, id, &tmp_dir, &var_tmp_dir, netns_storage_socket, ipcns_storage_socket, ret); | |
e8a565cb YW |
6236 | if (r < 0) |
6237 | return r; | |
6238 | ||
613b411c LP |
6239 | return 1; |
6240 | } | |
6241 | ||
e8a565cb YW |
6242 | int exec_runtime_acquire(Manager *m, const ExecContext *c, const char *id, bool create, ExecRuntime **ret) { |
6243 | ExecRuntime *rt; | |
6244 | int r; | |
613b411c | 6245 | |
e8a565cb YW |
6246 | assert(m); |
6247 | assert(id); | |
6248 | assert(ret); | |
6249 | ||
6250 | rt = hashmap_get(m->exec_runtime_by_id, id); | |
6251 | if (rt) | |
6252 | /* We already have a ExecRuntime object, let's increase the ref count and reuse it */ | |
6253 | goto ref; | |
6254 | ||
74aaf59b LP |
6255 | if (!create) { |
6256 | *ret = NULL; | |
e8a565cb | 6257 | return 0; |
74aaf59b | 6258 | } |
e8a565cb YW |
6259 | |
6260 | /* If not found, then create a new object. */ | |
6261 | r = exec_runtime_make(m, c, id, &rt); | |
74aaf59b | 6262 | if (r < 0) |
e8a565cb | 6263 | return r; |
74aaf59b LP |
6264 | if (r == 0) { |
6265 | /* When r == 0, it is not necessary to create ExecRuntime object. */ | |
6266 | *ret = NULL; | |
6267 | return 0; | |
6268 | } | |
613b411c | 6269 | |
e8a565cb YW |
6270 | ref: |
6271 | /* increment reference counter. */ | |
6272 | rt->n_ref++; | |
6273 | *ret = rt; | |
6274 | return 1; | |
6275 | } | |
613b411c | 6276 | |
e8a565cb YW |
6277 | ExecRuntime *exec_runtime_unref(ExecRuntime *rt, bool destroy) { |
6278 | if (!rt) | |
613b411c LP |
6279 | return NULL; |
6280 | ||
e8a565cb | 6281 | assert(rt->n_ref > 0); |
613b411c | 6282 | |
e8a565cb YW |
6283 | rt->n_ref--; |
6284 | if (rt->n_ref > 0) | |
f2341e0a LP |
6285 | return NULL; |
6286 | ||
e8a565cb | 6287 | return exec_runtime_free(rt, destroy); |
613b411c LP |
6288 | } |
6289 | ||
e8a565cb YW |
6290 | int exec_runtime_serialize(const Manager *m, FILE *f, FDSet *fds) { |
6291 | ExecRuntime *rt; | |
e8a565cb YW |
6292 | |
6293 | assert(m); | |
613b411c LP |
6294 | assert(f); |
6295 | assert(fds); | |
6296 | ||
90e74a66 | 6297 | HASHMAP_FOREACH(rt, m->exec_runtime_by_id) { |
e8a565cb | 6298 | fprintf(f, "exec-runtime=%s", rt->id); |
613b411c | 6299 | |
e8a565cb YW |
6300 | if (rt->tmp_dir) |
6301 | fprintf(f, " tmp-dir=%s", rt->tmp_dir); | |
613b411c | 6302 | |
e8a565cb YW |
6303 | if (rt->var_tmp_dir) |
6304 | fprintf(f, " var-tmp-dir=%s", rt->var_tmp_dir); | |
613b411c | 6305 | |
e8a565cb YW |
6306 | if (rt->netns_storage_socket[0] >= 0) { |
6307 | int copy; | |
613b411c | 6308 | |
e8a565cb YW |
6309 | copy = fdset_put_dup(fds, rt->netns_storage_socket[0]); |
6310 | if (copy < 0) | |
6311 | return copy; | |
613b411c | 6312 | |
e8a565cb YW |
6313 | fprintf(f, " netns-socket-0=%i", copy); |
6314 | } | |
613b411c | 6315 | |
e8a565cb YW |
6316 | if (rt->netns_storage_socket[1] >= 0) { |
6317 | int copy; | |
613b411c | 6318 | |
e8a565cb YW |
6319 | copy = fdset_put_dup(fds, rt->netns_storage_socket[1]); |
6320 | if (copy < 0) | |
6321 | return copy; | |
613b411c | 6322 | |
e8a565cb YW |
6323 | fprintf(f, " netns-socket-1=%i", copy); |
6324 | } | |
6325 | ||
a70581ff XR |
6326 | if (rt->ipcns_storage_socket[0] >= 0) { |
6327 | int copy; | |
6328 | ||
6329 | copy = fdset_put_dup(fds, rt->ipcns_storage_socket[0]); | |
6330 | if (copy < 0) | |
6331 | return copy; | |
6332 | ||
6333 | fprintf(f, " ipcns-socket-0=%i", copy); | |
6334 | } | |
6335 | ||
6336 | if (rt->ipcns_storage_socket[1] >= 0) { | |
6337 | int copy; | |
6338 | ||
6339 | copy = fdset_put_dup(fds, rt->ipcns_storage_socket[1]); | |
6340 | if (copy < 0) | |
6341 | return copy; | |
6342 | ||
6343 | fprintf(f, " ipcns-socket-1=%i", copy); | |
6344 | } | |
6345 | ||
e8a565cb | 6346 | fputc('\n', f); |
613b411c LP |
6347 | } |
6348 | ||
6349 | return 0; | |
6350 | } | |
6351 | ||
e8a565cb YW |
6352 | int exec_runtime_deserialize_compat(Unit *u, const char *key, const char *value, FDSet *fds) { |
6353 | _cleanup_(exec_runtime_freep) ExecRuntime *rt_create = NULL; | |
6354 | ExecRuntime *rt; | |
613b411c LP |
6355 | int r; |
6356 | ||
e8a565cb YW |
6357 | /* This is for the migration from old (v237 or earlier) deserialization text. |
6358 | * Due to the bug #7790, this may not work with the units that use JoinsNamespaceOf=. | |
6359 | * Even if the ExecRuntime object originally created by the other unit, we cannot judge | |
6360 | * so or not from the serialized text, then we always creates a new object owned by this. */ | |
6361 | ||
6362 | assert(u); | |
613b411c LP |
6363 | assert(key); |
6364 | assert(value); | |
6365 | ||
e8a565cb YW |
6366 | /* Manager manages ExecRuntime objects by the unit id. |
6367 | * So, we omit the serialized text when the unit does not have id (yet?)... */ | |
6368 | if (isempty(u->id)) { | |
6369 | log_unit_debug(u, "Invocation ID not found. Dropping runtime parameter."); | |
6370 | return 0; | |
6371 | } | |
613b411c | 6372 | |
e8a565cb YW |
6373 | r = hashmap_ensure_allocated(&u->manager->exec_runtime_by_id, &string_hash_ops); |
6374 | if (r < 0) { | |
6375 | log_unit_debug_errno(u, r, "Failed to allocate storage for runtime parameter: %m"); | |
6376 | return 0; | |
6377 | } | |
6378 | ||
6379 | rt = hashmap_get(u->manager->exec_runtime_by_id, u->id); | |
6380 | if (!rt) { | |
56a13a49 | 6381 | r = exec_runtime_allocate(&rt_create, u->id); |
613b411c | 6382 | if (r < 0) |
f2341e0a | 6383 | return log_oom(); |
613b411c | 6384 | |
e8a565cb YW |
6385 | rt = rt_create; |
6386 | } | |
6387 | ||
6388 | if (streq(key, "tmp-dir")) { | |
6389 | char *copy; | |
6390 | ||
613b411c LP |
6391 | copy = strdup(value); |
6392 | if (!copy) | |
6393 | return log_oom(); | |
6394 | ||
e8a565cb | 6395 | free_and_replace(rt->tmp_dir, copy); |
613b411c LP |
6396 | |
6397 | } else if (streq(key, "var-tmp-dir")) { | |
6398 | char *copy; | |
6399 | ||
613b411c LP |
6400 | copy = strdup(value); |
6401 | if (!copy) | |
6402 | return log_oom(); | |
6403 | ||
e8a565cb | 6404 | free_and_replace(rt->var_tmp_dir, copy); |
613b411c LP |
6405 | |
6406 | } else if (streq(key, "netns-socket-0")) { | |
6407 | int fd; | |
6408 | ||
e8a565cb | 6409 | if (safe_atoi(value, &fd) < 0 || !fdset_contains(fds, fd)) { |
f2341e0a | 6410 | log_unit_debug(u, "Failed to parse netns socket value: %s", value); |
e8a565cb | 6411 | return 0; |
613b411c | 6412 | } |
e8a565cb YW |
6413 | |
6414 | safe_close(rt->netns_storage_socket[0]); | |
6415 | rt->netns_storage_socket[0] = fdset_remove(fds, fd); | |
6416 | ||
613b411c LP |
6417 | } else if (streq(key, "netns-socket-1")) { |
6418 | int fd; | |
6419 | ||
e8a565cb | 6420 | if (safe_atoi(value, &fd) < 0 || !fdset_contains(fds, fd)) { |
f2341e0a | 6421 | log_unit_debug(u, "Failed to parse netns socket value: %s", value); |
e8a565cb | 6422 | return 0; |
613b411c | 6423 | } |
e8a565cb YW |
6424 | |
6425 | safe_close(rt->netns_storage_socket[1]); | |
6426 | rt->netns_storage_socket[1] = fdset_remove(fds, fd); | |
a70581ff XR |
6427 | |
6428 | } else if (streq(key, "ipcns-socket-0")) { | |
6429 | int fd; | |
6430 | ||
6431 | if (safe_atoi(value, &fd) < 0 || !fdset_contains(fds, fd)) { | |
6432 | log_unit_debug(u, "Failed to parse ipcns socket value: %s", value); | |
6433 | return 0; | |
6434 | } | |
6435 | ||
6436 | safe_close(rt->ipcns_storage_socket[0]); | |
6437 | rt->ipcns_storage_socket[0] = fdset_remove(fds, fd); | |
6438 | ||
6439 | } else if (streq(key, "ipcns-socket-1")) { | |
6440 | int fd; | |
6441 | ||
6442 | if (safe_atoi(value, &fd) < 0 || !fdset_contains(fds, fd)) { | |
6443 | log_unit_debug(u, "Failed to parse ipcns socket value: %s", value); | |
6444 | return 0; | |
6445 | } | |
6446 | ||
6447 | safe_close(rt->ipcns_storage_socket[1]); | |
6448 | rt->ipcns_storage_socket[1] = fdset_remove(fds, fd); | |
613b411c LP |
6449 | } else |
6450 | return 0; | |
6451 | ||
e8a565cb YW |
6452 | /* If the object is newly created, then put it to the hashmap which manages ExecRuntime objects. */ |
6453 | if (rt_create) { | |
6454 | r = hashmap_put(u->manager->exec_runtime_by_id, rt_create->id, rt_create); | |
6455 | if (r < 0) { | |
3fe91079 | 6456 | log_unit_debug_errno(u, r, "Failed to put runtime parameter to manager's storage: %m"); |
e8a565cb YW |
6457 | return 0; |
6458 | } | |
613b411c | 6459 | |
e8a565cb | 6460 | rt_create->manager = u->manager; |
613b411c | 6461 | |
e8a565cb | 6462 | /* Avoid cleanup */ |
56a13a49 | 6463 | TAKE_PTR(rt_create); |
e8a565cb | 6464 | } |
98b47d54 | 6465 | |
e8a565cb YW |
6466 | return 1; |
6467 | } | |
613b411c | 6468 | |
56a13a49 ZJS |
6469 | int exec_runtime_deserialize_one(Manager *m, const char *value, FDSet *fds) { |
6470 | _cleanup_free_ char *tmp_dir = NULL, *var_tmp_dir = NULL; | |
6471 | char *id = NULL; | |
a70581ff | 6472 | int r, netns_fdpair[] = {-1, -1}, ipcns_fdpair[] = {-1, -1}; |
e8a565cb YW |
6473 | const char *p, *v = value; |
6474 | size_t n; | |
613b411c | 6475 | |
e8a565cb YW |
6476 | assert(m); |
6477 | assert(value); | |
6478 | assert(fds); | |
98b47d54 | 6479 | |
e8a565cb YW |
6480 | n = strcspn(v, " "); |
6481 | id = strndupa(v, n); | |
6482 | if (v[n] != ' ') | |
6483 | goto finalize; | |
6484 | p = v + n + 1; | |
6485 | ||
6486 | v = startswith(p, "tmp-dir="); | |
6487 | if (v) { | |
6488 | n = strcspn(v, " "); | |
56a13a49 ZJS |
6489 | tmp_dir = strndup(v, n); |
6490 | if (!tmp_dir) | |
6491 | return log_oom(); | |
e8a565cb YW |
6492 | if (v[n] != ' ') |
6493 | goto finalize; | |
6494 | p = v + n + 1; | |
6495 | } | |
6496 | ||
6497 | v = startswith(p, "var-tmp-dir="); | |
6498 | if (v) { | |
6499 | n = strcspn(v, " "); | |
56a13a49 ZJS |
6500 | var_tmp_dir = strndup(v, n); |
6501 | if (!var_tmp_dir) | |
6502 | return log_oom(); | |
e8a565cb YW |
6503 | if (v[n] != ' ') |
6504 | goto finalize; | |
6505 | p = v + n + 1; | |
6506 | } | |
6507 | ||
6508 | v = startswith(p, "netns-socket-0="); | |
6509 | if (v) { | |
6510 | char *buf; | |
6511 | ||
6512 | n = strcspn(v, " "); | |
6513 | buf = strndupa(v, n); | |
c413bb28 | 6514 | |
a70581ff | 6515 | r = safe_atoi(buf, &netns_fdpair[0]); |
c413bb28 ZJS |
6516 | if (r < 0) |
6517 | return log_debug_errno(r, "Unable to parse exec-runtime specification netns-socket-0=%s: %m", buf); | |
a70581ff | 6518 | if (!fdset_contains(fds, netns_fdpair[0])) |
c413bb28 | 6519 | return log_debug_errno(SYNTHETIC_ERRNO(EBADF), |
a70581ff XR |
6520 | "exec-runtime specification netns-socket-0= refers to unknown fd %d: %m", netns_fdpair[0]); |
6521 | netns_fdpair[0] = fdset_remove(fds, netns_fdpair[0]); | |
e8a565cb YW |
6522 | if (v[n] != ' ') |
6523 | goto finalize; | |
6524 | p = v + n + 1; | |
613b411c LP |
6525 | } |
6526 | ||
e8a565cb YW |
6527 | v = startswith(p, "netns-socket-1="); |
6528 | if (v) { | |
6529 | char *buf; | |
98b47d54 | 6530 | |
e8a565cb YW |
6531 | n = strcspn(v, " "); |
6532 | buf = strndupa(v, n); | |
a70581ff XR |
6533 | |
6534 | r = safe_atoi(buf, &netns_fdpair[1]); | |
c413bb28 ZJS |
6535 | if (r < 0) |
6536 | return log_debug_errno(r, "Unable to parse exec-runtime specification netns-socket-1=%s: %m", buf); | |
a70581ff XR |
6537 | if (!fdset_contains(fds, netns_fdpair[1])) |
6538 | return log_debug_errno(SYNTHETIC_ERRNO(EBADF), | |
6539 | "exec-runtime specification netns-socket-1= refers to unknown fd %d: %m", netns_fdpair[1]); | |
6540 | netns_fdpair[1] = fdset_remove(fds, netns_fdpair[1]); | |
6541 | if (v[n] != ' ') | |
6542 | goto finalize; | |
6543 | p = v + n + 1; | |
6544 | } | |
6545 | ||
6546 | v = startswith(p, "ipcns-socket-0="); | |
6547 | if (v) { | |
6548 | char *buf; | |
6549 | ||
6550 | n = strcspn(v, " "); | |
6551 | buf = strndupa(v, n); | |
6552 | ||
6553 | r = safe_atoi(buf, &ipcns_fdpair[0]); | |
6554 | if (r < 0) | |
6555 | return log_debug_errno(r, "Unable to parse exec-runtime specification ipcns-socket-0=%s: %m", buf); | |
6556 | if (!fdset_contains(fds, ipcns_fdpair[0])) | |
6557 | return log_debug_errno(SYNTHETIC_ERRNO(EBADF), | |
6558 | "exec-runtime specification ipcns-socket-0= refers to unknown fd %d: %m", ipcns_fdpair[0]); | |
6559 | ipcns_fdpair[0] = fdset_remove(fds, ipcns_fdpair[0]); | |
6560 | if (v[n] != ' ') | |
6561 | goto finalize; | |
6562 | p = v + n + 1; | |
6563 | } | |
6564 | ||
6565 | v = startswith(p, "ipcns-socket-1="); | |
6566 | if (v) { | |
6567 | char *buf; | |
6568 | ||
6569 | n = strcspn(v, " "); | |
6570 | buf = strndupa(v, n); | |
6571 | ||
6572 | r = safe_atoi(buf, &ipcns_fdpair[1]); | |
6573 | if (r < 0) | |
6574 | return log_debug_errno(r, "Unable to parse exec-runtime specification ipcns-socket-1=%s: %m", buf); | |
6575 | if (!fdset_contains(fds, ipcns_fdpair[1])) | |
c413bb28 | 6576 | return log_debug_errno(SYNTHETIC_ERRNO(EBADF), |
a70581ff XR |
6577 | "exec-runtime specification ipcns-socket-1= refers to unknown fd %d: %m", ipcns_fdpair[1]); |
6578 | ipcns_fdpair[1] = fdset_remove(fds, ipcns_fdpair[1]); | |
e8a565cb | 6579 | } |
98b47d54 | 6580 | |
e8a565cb | 6581 | finalize: |
a70581ff | 6582 | r = exec_runtime_add(m, id, &tmp_dir, &var_tmp_dir, netns_fdpair, ipcns_fdpair, NULL); |
7d853ca6 | 6583 | if (r < 0) |
56a13a49 ZJS |
6584 | return log_debug_errno(r, "Failed to add exec-runtime: %m"); |
6585 | return 0; | |
e8a565cb | 6586 | } |
613b411c | 6587 | |
e8a565cb YW |
6588 | void exec_runtime_vacuum(Manager *m) { |
6589 | ExecRuntime *rt; | |
e8a565cb YW |
6590 | |
6591 | assert(m); | |
6592 | ||
6593 | /* Free unreferenced ExecRuntime objects. This is used after manager deserialization process. */ | |
6594 | ||
90e74a66 | 6595 | HASHMAP_FOREACH(rt, m->exec_runtime_by_id) { |
e8a565cb YW |
6596 | if (rt->n_ref > 0) |
6597 | continue; | |
6598 | ||
6599 | (void) exec_runtime_free(rt, false); | |
6600 | } | |
613b411c LP |
6601 | } |
6602 | ||
b9c04eaf YW |
6603 | void exec_params_clear(ExecParameters *p) { |
6604 | if (!p) | |
6605 | return; | |
6606 | ||
c3f8a065 LP |
6607 | p->environment = strv_free(p->environment); |
6608 | p->fd_names = strv_free(p->fd_names); | |
6609 | p->fds = mfree(p->fds); | |
6610 | p->exec_fd = safe_close(p->exec_fd); | |
b9c04eaf YW |
6611 | } |
6612 | ||
bb0c0d6f LP |
6613 | ExecSetCredential *exec_set_credential_free(ExecSetCredential *sc) { |
6614 | if (!sc) | |
6615 | return NULL; | |
6616 | ||
6617 | free(sc->id); | |
6618 | free(sc->data); | |
6619 | return mfree(sc); | |
6620 | } | |
6621 | ||
6622 | DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(exec_set_credential_hash_ops, char, string_hash_func, string_compare_func, ExecSetCredential, exec_set_credential_free); | |
6623 | ||
80876c20 LP |
6624 | static const char* const exec_input_table[_EXEC_INPUT_MAX] = { |
6625 | [EXEC_INPUT_NULL] = "null", | |
6626 | [EXEC_INPUT_TTY] = "tty", | |
6627 | [EXEC_INPUT_TTY_FORCE] = "tty-force", | |
4f2d528d | 6628 | [EXEC_INPUT_TTY_FAIL] = "tty-fail", |
52c239d7 LB |
6629 | [EXEC_INPUT_SOCKET] = "socket", |
6630 | [EXEC_INPUT_NAMED_FD] = "fd", | |
08f3be7a | 6631 | [EXEC_INPUT_DATA] = "data", |
2038c3f5 | 6632 | [EXEC_INPUT_FILE] = "file", |
80876c20 LP |
6633 | }; |
6634 | ||
8a0867d6 LP |
6635 | DEFINE_STRING_TABLE_LOOKUP(exec_input, ExecInput); |
6636 | ||
94f04347 | 6637 | static const char* const exec_output_table[_EXEC_OUTPUT_MAX] = { |
80876c20 | 6638 | [EXEC_OUTPUT_INHERIT] = "inherit", |
94f04347 | 6639 | [EXEC_OUTPUT_NULL] = "null", |
80876c20 | 6640 | [EXEC_OUTPUT_TTY] = "tty", |
9a6bca7a | 6641 | [EXEC_OUTPUT_KMSG] = "kmsg", |
28dbc1e8 | 6642 | [EXEC_OUTPUT_KMSG_AND_CONSOLE] = "kmsg+console", |
706343f4 LP |
6643 | [EXEC_OUTPUT_JOURNAL] = "journal", |
6644 | [EXEC_OUTPUT_JOURNAL_AND_CONSOLE] = "journal+console", | |
52c239d7 LB |
6645 | [EXEC_OUTPUT_SOCKET] = "socket", |
6646 | [EXEC_OUTPUT_NAMED_FD] = "fd", | |
2038c3f5 | 6647 | [EXEC_OUTPUT_FILE] = "file", |
566b7d23 | 6648 | [EXEC_OUTPUT_FILE_APPEND] = "append", |
8d7dab1f | 6649 | [EXEC_OUTPUT_FILE_TRUNCATE] = "truncate", |
94f04347 LP |
6650 | }; |
6651 | ||
6652 | DEFINE_STRING_TABLE_LOOKUP(exec_output, ExecOutput); | |
023a4f67 LP |
6653 | |
6654 | static const char* const exec_utmp_mode_table[_EXEC_UTMP_MODE_MAX] = { | |
6655 | [EXEC_UTMP_INIT] = "init", | |
6656 | [EXEC_UTMP_LOGIN] = "login", | |
6657 | [EXEC_UTMP_USER] = "user", | |
6658 | }; | |
6659 | ||
6660 | DEFINE_STRING_TABLE_LOOKUP(exec_utmp_mode, ExecUtmpMode); | |
53f47dfc YW |
6661 | |
6662 | static const char* const exec_preserve_mode_table[_EXEC_PRESERVE_MODE_MAX] = { | |
6663 | [EXEC_PRESERVE_NO] = "no", | |
6664 | [EXEC_PRESERVE_YES] = "yes", | |
6665 | [EXEC_PRESERVE_RESTART] = "restart", | |
6666 | }; | |
6667 | ||
6668 | DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(exec_preserve_mode, ExecPreserveMode, EXEC_PRESERVE_YES); | |
3536f49e | 6669 | |
6b7b2ed9 | 6670 | /* This table maps ExecDirectoryType to the setting it is configured with in the unit */ |
72fd1768 | 6671 | static const char* const exec_directory_type_table[_EXEC_DIRECTORY_TYPE_MAX] = { |
3536f49e YW |
6672 | [EXEC_DIRECTORY_RUNTIME] = "RuntimeDirectory", |
6673 | [EXEC_DIRECTORY_STATE] = "StateDirectory", | |
6674 | [EXEC_DIRECTORY_CACHE] = "CacheDirectory", | |
6675 | [EXEC_DIRECTORY_LOGS] = "LogsDirectory", | |
6676 | [EXEC_DIRECTORY_CONFIGURATION] = "ConfigurationDirectory", | |
6677 | }; | |
6678 | ||
6679 | DEFINE_STRING_TABLE_LOOKUP(exec_directory_type, ExecDirectoryType); | |
b1edf445 | 6680 | |
6b7b2ed9 LP |
6681 | /* And this table maps ExecDirectoryType too, but to a generic term identifying the type of resource. This |
6682 | * one is supposed to be generic enough to be used for unit types that don't use ExecContext and per-unit | |
6683 | * directories, specifically .timer units with their timestamp touch file. */ | |
6684 | static const char* const exec_resource_type_table[_EXEC_DIRECTORY_TYPE_MAX] = { | |
6685 | [EXEC_DIRECTORY_RUNTIME] = "runtime", | |
6686 | [EXEC_DIRECTORY_STATE] = "state", | |
6687 | [EXEC_DIRECTORY_CACHE] = "cache", | |
6688 | [EXEC_DIRECTORY_LOGS] = "logs", | |
6689 | [EXEC_DIRECTORY_CONFIGURATION] = "configuration", | |
6690 | }; | |
6691 | ||
6692 | DEFINE_STRING_TABLE_LOOKUP(exec_resource_type, ExecDirectoryType); | |
6693 | ||
6694 | /* And this table also maps ExecDirectoryType, to the environment variable we pass the selected directory to | |
6695 | * the service payload in. */ | |
fb2042dd YW |
6696 | static const char* const exec_directory_env_name_table[_EXEC_DIRECTORY_TYPE_MAX] = { |
6697 | [EXEC_DIRECTORY_RUNTIME] = "RUNTIME_DIRECTORY", | |
6698 | [EXEC_DIRECTORY_STATE] = "STATE_DIRECTORY", | |
6699 | [EXEC_DIRECTORY_CACHE] = "CACHE_DIRECTORY", | |
6700 | [EXEC_DIRECTORY_LOGS] = "LOGS_DIRECTORY", | |
6701 | [EXEC_DIRECTORY_CONFIGURATION] = "CONFIGURATION_DIRECTORY", | |
6702 | }; | |
6703 | ||
6704 | DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(exec_directory_env_name, ExecDirectoryType); | |
6705 | ||
b1edf445 LP |
6706 | static const char* const exec_keyring_mode_table[_EXEC_KEYRING_MODE_MAX] = { |
6707 | [EXEC_KEYRING_INHERIT] = "inherit", | |
6708 | [EXEC_KEYRING_PRIVATE] = "private", | |
6709 | [EXEC_KEYRING_SHARED] = "shared", | |
6710 | }; | |
6711 | ||
6712 | DEFINE_STRING_TABLE_LOOKUP(exec_keyring_mode, ExecKeyringMode); |