X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fcore%2Fexecute.c;h=a0d63a41f9a521b82b806537d4db1e19505da468;hp=6aa0083bc019f1ef17b3f0a91f2bbb3ffefac15b;hb=486cd82c8f7642016895b72bcc09a1bfe885a783;hpb=ebf4fb3d368732d9f41cb40e3084182c04e731b2 diff --git a/src/core/execute.c b/src/core/execute.c index 6aa0083bc..a0d63a41f 100644 --- a/src/core/execute.c +++ b/src/core/execute.c @@ -55,20 +55,21 @@ #include "sd-messages.h" #include "ioprio.h" #include "securebits.h" -#include "cgroup.h" #include "namespace.h" #include "tcpwrap.h" #include "exit-status.h" #include "missing.h" #include "utmp-wtmp.h" #include "def.h" -#include "loopback-setup.h" #include "path-util.h" #include "syscall-list.h" #include "env-util.h" #include "fileio.h" +#include "unit.h" +#include "async.h" #define IDLE_TIMEOUT_USEC (5*USEC_PER_SEC) +#define IDLE_TIMEOUT2_USEC (1*USEC_PER_SEC) /* This assumes there is a 'tty' group */ #define TTY_MODE 0620 @@ -144,7 +145,7 @@ static int flags_fds(const int fds[], unsigned n_fds, bool nonblock) { return 0; } -static const char *tty_path(const ExecContext *context) { +_pure_ static const char *tty_path(const ExecContext *context) { assert(context); if (context->tty_path) @@ -153,7 +154,7 @@ static const char *tty_path(const ExecContext *context) { return "/dev/console"; } -void exec_context_tty_reset(const ExecContext *context) { +static void exec_context_tty_reset(const ExecContext *context) { assert(context); if (context->tty_vhangup) @@ -174,24 +175,13 @@ static bool is_terminal_output(ExecOutput o) { o == EXEC_OUTPUT_JOURNAL_AND_CONSOLE; } -void exec_context_serialize(const ExecContext *context, Unit *u, FILE *f) { - assert(context); - assert(u); - assert(f); - - if (context->tmp_dir) - unit_serialize_item(u, f, "tmp-dir", context->tmp_dir); - - if (context->var_tmp_dir) - unit_serialize_item(u, f, "var-tmp-dir", context->var_tmp_dir); -} - static int open_null_as(int flags, int nfd) { int fd, r; assert(nfd >= 0); - if ((fd = open("/dev/null", flags|O_NOCTTY)) < 0) + fd = open("/dev/null", flags|O_NOCTTY); + if (fd < 0) return -errno; if (fd != nfd) { @@ -205,7 +195,10 @@ static int open_null_as(int flags, int nfd) { static int connect_logger_as(const ExecContext *context, ExecOutput output, const char *ident, const char *unit_id, int nfd) { int fd, r; - union sockaddr_union sa; + union sockaddr_union sa = { + .un.sun_family = AF_UNIX, + .un.sun_path = "/run/systemd/journal/stdout", + }; assert(context); assert(output < _EXEC_OUTPUT_MAX); @@ -216,10 +209,6 @@ static int connect_logger_as(const ExecContext *context, ExecOutput output, cons if (fd < 0) return -errno; - zero(sa); - sa.un.sun_family = AF_UNIX; - strncpy(sa.un.sun_path, "/run/systemd/journal/stdout", sizeof(sa.un.sun_path)); - r = connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path)); if (r < 0) { close_nointr_nofail(fd); @@ -316,12 +305,12 @@ static int setup_input(const ExecContext *context, int socket_fd, bool apply_tty case EXEC_INPUT_TTY_FAIL: { int fd, r; - if ((fd = acquire_terminal( - tty_path(context), - i == EXEC_INPUT_TTY_FAIL, - i == EXEC_INPUT_TTY_FORCE, - false, - (usec_t) -1)) < 0) + fd = acquire_terminal(tty_path(context), + i == EXEC_INPUT_TTY_FAIL, + i == EXEC_INPUT_TTY_FORCE, + false, + (usec_t) -1); + if (fd < 0) return fd; if (fd != STDIN_FILENO) { @@ -510,7 +499,7 @@ fail: return r; } -static int write_confirm_message(const char *format, ...) { +_printf_(1, 2) static int write_confirm_message(const char *format, ...) { int fd; va_list ap; @@ -671,9 +660,9 @@ static int enforce_user(const ExecContext *context, uid_t uid) { /* First step: If we need to keep capabilities but * drop privileges we need to make sure we keep our - * caps, whiel we drop privileges. */ + * caps, while we drop privileges. */ if (uid != 0) { - int sb = context->secure_bits|SECURE_KEEP_CAPS; + int sb = context->secure_bits | 1<= 0) + close_nointr_nofail(idle_pipe[1]); + if (idle_pipe[2] >= 0) + close_nointr_nofail(idle_pipe[2]); + + if (idle_pipe[0] >= 0) { + int r; + + r = fd_wait_for_event(idle_pipe[0], POLLHUP, IDLE_TIMEOUT_USEC); + + if (idle_pipe[3] >= 0 && r == 0 /* timeout */) { + /* Signal systemd that we are bored and want to continue. */ + write(idle_pipe[3], "x", 1); + + /* Wait for systemd to react to the signal above. */ + fd_wait_for_event(idle_pipe[0], POLLHUP, IDLE_TIMEOUT2_USEC); + } + + close_nointr_nofail(idle_pipe[0]); + + } + + if (idle_pipe[3] >= 0) + close_nointr_nofail(idle_pipe[3]); +} + int exec_spawn(ExecCommand *command, char **argv, ExecContext *context, @@ -988,18 +1021,18 @@ int exec_spawn(ExecCommand *command, bool apply_chroot, bool apply_tty_stdin, bool confirm_spawn, - CGroupBonding *cgroup_bondings, - CGroupAttribute *cgroup_attributes, - const char *cgroup_suffix, + CGroupControllerMask cgroup_supported, + const char *cgroup_path, const char *unit_id, - int idle_pipe[2], + int idle_pipe[4], + ExecRuntime *runtime, pid_t *ret) { + _cleanup_strv_free_ char **files_env = NULL; + int socket_fd; + char *line; pid_t pid; int r; - char *line; - int socket_fd; - char _cleanup_strv_free_ **files_env = NULL; assert(command); assert(context); @@ -1038,37 +1071,25 @@ int exec_spawn(ExecCommand *command, return log_oom(); log_struct_unit(LOG_DEBUG, - unit_id, - "MESSAGE=About to execute %s", line, - NULL); + unit_id, + "EXECUTABLE=%s", command->path, + "MESSAGE=About to execute: %s", line, + NULL); free(line); - r = cgroup_bonding_realize_list(cgroup_bondings); - if (r < 0) - return r; - - cgroup_attribute_apply_list(cgroup_attributes, cgroup_bondings); - - if (context->private_tmp && !context->tmp_dir && !context->var_tmp_dir) { - r = setup_tmpdirs(&context->tmp_dir, &context->var_tmp_dir); - if (r < 0) - return r; - } - pid = fork(); if (pid < 0) return -errno; if (pid == 0) { - int i, err; - sigset_t ss; - const char *username = NULL, *home = NULL; + _cleanup_strv_free_ char **our_env = NULL, **pam_env = NULL, **final_env = NULL, **final_argv = NULL; + const char *username = NULL, *home = NULL, *shell = NULL; + unsigned n_dont_close = 0, n_env = 0; + int dont_close[n_fds + 3]; uid_t uid = (uid_t) -1; gid_t gid = (gid_t) -1; - char _cleanup_strv_free_ **our_env = NULL, **pam_env = NULL, - **final_env = NULL, **final_argv = NULL; - unsigned n_env = 0; - bool set_access = false; + sigset_t ss; + int i, err; /* child */ @@ -1092,21 +1113,28 @@ int exec_spawn(ExecCommand *command, goto fail_child; } - if (idle_pipe) { - if (idle_pipe[1] >= 0) - close_nointr_nofail(idle_pipe[1]); - if (idle_pipe[0] >= 0) { - fd_wait_for_event(idle_pipe[0], POLLHUP, IDLE_TIMEOUT_USEC); - close_nointr_nofail(idle_pipe[0]); - } - } + if (idle_pipe) + do_idle_pipe_dance(idle_pipe); /* Close sockets very early to make sure we don't * block init reexecution because it cannot bind its * sockets */ log_forget_fds(); - err = close_all_fds(socket_fd >= 0 ? &socket_fd : fds, - socket_fd >= 0 ? 1 : n_fds); + + if (socket_fd >= 0) + dont_close[n_dont_close++] = socket_fd; + if (n_fds > 0) { + memcpy(dont_close + n_dont_close, fds, sizeof(int) * n_fds); + n_dont_close += n_fds; + } + if (runtime) { + if (runtime->netns_storage_socket[0] >= 0) + dont_close[n_dont_close++] = runtime->netns_storage_socket[0]; + if (runtime->netns_storage_socket[1] >= 0) + dont_close[n_dont_close++] = runtime->netns_storage_socket[1]; + } + + err = close_all_fds(dont_close, n_dont_close); if (err < 0) { r = EXIT_FDS; goto fail_child; @@ -1181,8 +1209,8 @@ int exec_spawn(ExecCommand *command, goto fail_child; } - if (cgroup_bondings) { - err = cgroup_bonding_install_list(cgroup_bondings, 0, cgroup_suffix); + if (cgroup_path) { + err = cg_attach_everywhere(cgroup_supported, cgroup_path, 0); if (err < 0) { r = EXIT_CGROUP; goto fail_child; @@ -1195,7 +1223,7 @@ int exec_spawn(ExecCommand *command, snprintf(t, sizeof(t), "%i", context->oom_score_adjust); char_array_0(t); - if (write_one_line_file("/proc/self/oom_score_adj", t) < 0) { + if (write_string_file("/proc/self/oom_score_adj", t) < 0) { err = -errno; r = EXIT_OOM_ADJUST; goto fail_child; @@ -1210,13 +1238,16 @@ int exec_spawn(ExecCommand *command, } if (context->cpu_sched_set) { - struct sched_param param; - - zero(param); - param.sched_priority = context->cpu_sched_priority; + struct sched_param param = { + .sched_priority = context->cpu_sched_priority, + }; - if (sched_setscheduler(0, context->cpu_sched_policy | - (context->cpu_sched_reset_on_fork ? SCHED_RESET_ON_FORK : 0), ¶m) < 0) { + r = sched_setscheduler(0, + context->cpu_sched_policy | + (context->cpu_sched_reset_on_fork ? + SCHED_RESET_ON_FORK : 0), + ¶m); + if (r < 0) { err = -errno; r = EXIT_SETSCHEDULER; goto fail_child; @@ -1249,7 +1280,7 @@ int exec_spawn(ExecCommand *command, if (context->user) { username = context->user; - err = get_user_creds(&username, &uid, &gid, &home, NULL); + err = get_user_creds(&username, &uid, &gid, &home, &shell); if (err < 0) { r = EXIT_USER; goto fail_child; @@ -1262,27 +1293,24 @@ int exec_spawn(ExecCommand *command, goto fail_child; } } + } - if (cgroup_bondings && context->control_group_modify) { - err = cgroup_bonding_set_group_access_list(cgroup_bondings, 0755, uid, gid); - if (err >= 0) - err = cgroup_bonding_set_task_access_list(cgroup_bondings, 0644, uid, gid, context->control_group_persistent); - if (err < 0) { - r = EXIT_CGROUP; - goto fail_child; - } - - set_access = true; +#ifdef HAVE_PAM + if (cgroup_path && context->user && context->pam_name) { + err = cg_set_task_access(SYSTEMD_CGROUP_CONTROLLER, cgroup_path, 0644, uid, gid); + if (err < 0) { + r = EXIT_CGROUP; + goto fail_child; } - } - if (cgroup_bondings && !set_access && context->control_group_persistent >= 0) { - err = cgroup_bonding_set_task_access_list(cgroup_bondings, (mode_t) -1, (uid_t) -1, (uid_t) -1, context->control_group_persistent); + + err = cg_set_group_access(SYSTEMD_CGROUP_CONTROLLER, cgroup_path, 0755, uid, gid); if (err < 0) { r = EXIT_CGROUP; goto fail_child; } } +#endif if (apply_permissions) { err = enforce_groups(context, username, gid); @@ -1303,28 +1331,43 @@ int exec_spawn(ExecCommand *command, } } #endif - if (context->private_network) { - if (unshare(CLONE_NEWNET) < 0) { - err = -errno; + if (context->private_network && runtime && runtime->netns_storage_socket[0] >= 0) { + err = setup_netns(runtime->netns_storage_socket); + if (err < 0) { r = EXIT_NETWORK; goto fail_child; } - - loopback_setup(); } - if (strv_length(context->read_write_dirs) > 0 || - strv_length(context->read_only_dirs) > 0 || - strv_length(context->inaccessible_dirs) > 0 || + if (!strv_isempty(context->read_write_dirs) || + !strv_isempty(context->read_only_dirs) || + !strv_isempty(context->inaccessible_dirs) || context->mount_flags != 0 || - context->private_tmp) { - err = setup_namespace(context->read_write_dirs, - context->read_only_dirs, - context->inaccessible_dirs, - context->tmp_dir, - context->var_tmp_dir, - context->private_tmp, - context->mount_flags); + (context->private_tmp && runtime && (runtime->tmp_dir || runtime->var_tmp_dir))) { + + char *tmp = NULL, *var = NULL; + + /* The runtime struct only contains the parent + * of the private /tmp, which is + * non-accessible to world users. Inside of it + * there's a /tmp that is sticky, and that's + * the one we want to use here. */ + + if (context->private_tmp && runtime) { + if (runtime->tmp_dir) + tmp = strappenda(runtime->tmp_dir, "/tmp"); + if (runtime->var_tmp_dir) + var = strappenda(runtime->var_tmp_dir, "/tmp"); + } + + err = setup_namespace( + context->read_write_dirs, + context->read_only_dirs, + context->inaccessible_dirs, + tmp, + var, + context->mount_flags); + if (err < 0) { r = EXIT_NAMESPACE; goto fail_child; @@ -1345,7 +1388,7 @@ int exec_spawn(ExecCommand *command, goto fail_child; } } else { - char _cleanup_free_ *d = NULL; + _cleanup_free_ char *d = NULL; if (asprintf(&d, "%s/%s", context->root_directory ? context->root_directory : "", @@ -1437,60 +1480,44 @@ int exec_spawn(ExecCommand *command, } } - if (!(our_env = new0(char*, 7))) { + our_env = new(char*, 8); + if (!our_env || + (n_fds > 0 && ( + asprintf(our_env + n_env++, "LISTEN_PID=%lu", (unsigned long) getpid()) < 0 || + asprintf(our_env + n_env++, "LISTEN_FDS=%u", n_fds) < 0)) || + (home && asprintf(our_env + n_env++, "HOME=%s", home) < 0) || + (username && ( + asprintf(our_env + n_env++, "LOGNAME=%s", username) < 0 || + asprintf(our_env + n_env++, "USER=%s", username) < 0)) || + (shell && asprintf(our_env + n_env++, "SHELL=%s", shell) < 0) || + ((is_terminal_input(context->std_input) || + context->std_output == EXEC_OUTPUT_TTY || + context->std_error == EXEC_OUTPUT_TTY) && ( + !(our_env[n_env++] = strdup(default_term_for_tty(tty_path(context))))))) { + err = -ENOMEM; r = EXIT_MEMORY; goto fail_child; } - if (n_fds > 0) - if (asprintf(our_env + n_env++, "LISTEN_PID=%lu", (unsigned long) getpid()) < 0 || - asprintf(our_env + n_env++, "LISTEN_FDS=%u", n_fds) < 0) { - err = -ENOMEM; - r = EXIT_MEMORY; - goto fail_child; - } - - if (home) - if (asprintf(our_env + n_env++, "HOME=%s", home) < 0) { - err = -ENOMEM; - r = EXIT_MEMORY; - goto fail_child; - } - - if (username) - if (asprintf(our_env + n_env++, "LOGNAME=%s", username) < 0 || - asprintf(our_env + n_env++, "USER=%s", username) < 0) { - err = -ENOMEM; - r = EXIT_MEMORY; - goto fail_child; - } - - if (is_terminal_input(context->std_input) || - context->std_output == EXEC_OUTPUT_TTY || - context->std_error == EXEC_OUTPUT_TTY) - if (!(our_env[n_env++] = strdup(default_term_for_tty(tty_path(context))))) { - err = -ENOMEM; - r = EXIT_MEMORY; - goto fail_child; - } - - assert(n_env <= 7); - - if (!(final_env = strv_env_merge( - 5, - environment, - our_env, - context->environment, - files_env, - pam_env, - NULL))) { + our_env[n_env++] = NULL; + assert(n_env <= 8); + + final_env = strv_env_merge(5, + environment, + our_env, + context->environment, + files_env, + pam_env, + NULL); + if (!final_env) { err = -ENOMEM; r = EXIT_MEMORY; goto fail_child; } - if (!(final_argv = replace_env_argv(argv, final_env))) { + final_argv = replace_env_argv(argv, final_env); + if (!final_argv) { err = -ENOMEM; r = EXIT_MEMORY; goto fail_child; @@ -1498,6 +1525,20 @@ int exec_spawn(ExecCommand *command, final_env = strv_env_clean(final_env); + if (_unlikely_(log_get_max_level() >= LOG_PRI(LOG_DEBUG))) { + line = exec_command_line(final_argv); + if (line) { + log_open(); + log_struct_unit(LOG_DEBUG, + unit_id, + "EXECUTABLE=%s", command->path, + "MESSAGE=Executing: %s", line, + NULL); + log_close(); + free(line); + line = NULL; + } + } execve(command->path, final_argv, final_env); err = -errno; r = EXIT_EXEC; @@ -1519,18 +1560,18 @@ int exec_spawn(ExecCommand *command, } log_struct_unit(LOG_DEBUG, - unit_id, - "MESSAGE=Forked %s as %lu", - command->path, (unsigned long) pid, - NULL); + unit_id, + "MESSAGE=Forked %s as %lu", + command->path, (unsigned long) pid, + NULL); /* We add the new process to the cgroup both in the child (so * that we can be sure that no user code is ever executed * outside of the cgroup) and in the parent (so that we can be * sure that when we kill the cgroup the process will be * killed too). */ - if (cgroup_bondings) - cgroup_bonding_install_list(cgroup_bondings, pid, cgroup_suffix); + if (cgroup_path) + cg_attach(SYSTEMD_CGROUP_CONTROLLER, cgroup_path, pid); exec_status_start(&command->exec_status, pid); @@ -1546,40 +1587,11 @@ void exec_context_init(ExecContext *c) { c->cpu_sched_policy = SCHED_OTHER; c->syslog_priority = LOG_DAEMON|LOG_INFO; c->syslog_level_prefix = true; - c->control_group_persistent = -1; c->ignore_sigpipe = true; c->timer_slack_nsec = (nsec_t) -1; } -void exec_context_tmp_dirs_done(ExecContext *c) { - char* dirs[] = {c->tmp_dir ? c->tmp_dir : c->var_tmp_dir, - c->tmp_dir ? c->var_tmp_dir : NULL, - NULL}; - char **dirp; - - for(dirp = dirs; *dirp; dirp++) { - char *dir; - int r; - - r = rm_rf_dangerous(*dirp, false, true, false); - dir = dirname(*dirp); - if (r < 0) - log_warning("Failed to remove content of temporary directory %s: %s", - dir, strerror(-r)); - else { - r = rmdir(dir); - if (r < 0) - log_warning("Failed to remove temporary directory %s: %s", - dir, strerror(-r)); - } - - free(*dirp); - } - - c->tmp_dir = c->var_tmp_dir = NULL; -} - -void exec_context_done(ExecContext *c, bool reloading_or_reexecuting) { +void exec_context_done(ExecContext *c) { unsigned l; assert(c); @@ -1643,9 +1655,6 @@ void exec_context_done(ExecContext *c, bool reloading_or_reexecuting) { free(c->syscall_filter); c->syscall_filter = NULL; - - if (!reloading_or_reexecuting) - exec_context_tmp_dirs_done(c); } void exec_command_done(ExecCommand *c) { @@ -1669,7 +1678,7 @@ void exec_command_free_list(ExecCommand *c) { ExecCommand *i; while ((i = c)) { - LIST_REMOVE(ExecCommand, command, c, i); + LIST_REMOVE(command, c, i); exec_command_done(i); free(i); } @@ -1695,7 +1704,7 @@ int exec_context_load_environment(const ExecContext *c, char ***l) { int k; bool ignore = false; char **p; - glob_t pglob; + _cleanup_globfree_ glob_t pglob = {}; int count, n; fn = *i; @@ -1706,7 +1715,6 @@ int exec_context_load_environment(const ExecContext *c, char ***l) { } if (!path_is_absolute(fn)) { - if (ignore) continue; @@ -1715,10 +1723,8 @@ int exec_context_load_environment(const ExecContext *c, char ***l) { } /* Filename supports globbing, take all matching files */ - zero(pglob); errno = 0; if (glob(fn, 0, NULL, &pglob) != 0) { - globfree(&pglob); if (ignore) continue; @@ -1727,7 +1733,6 @@ int exec_context_load_environment(const ExecContext *c, char ***l) { } count = pglob.gl_pathc; if (count == 0) { - globfree(&pglob); if (ignore) continue; @@ -1735,15 +1740,17 @@ int exec_context_load_environment(const ExecContext *c, char ***l) { return -EINVAL; } for (n = 0; n < count; n++) { - k = load_env_file(pglob.gl_pathv[n], &p); + k = load_env_file(pglob.gl_pathv[n], NULL, &p); if (k < 0) { if (ignore) continue; strv_free(r); - globfree(&pglob); return k; - } + } + /* Log invalid environment variables with filename */ + if (p) + p = strv_env_clean_log(p, pglob.gl_pathv[n]); if (r == NULL) r = p; @@ -1753,16 +1760,12 @@ int exec_context_load_environment(const ExecContext *c, char ***l) { m = strv_env_merge(2, r, p); strv_free(r); strv_free(p); - - if (!m) { - globfree(&pglob); + if (!m) return -ENOMEM; - } r = m; } } - globfree(&pglob); } *l = r; @@ -1811,14 +1814,13 @@ static void strv_fprintf(FILE *f, char **l) { } void exec_context_dump(ExecContext *c, FILE* f, const char *prefix) { - char ** e; + char **e; unsigned i; assert(c); assert(f); - if (!prefix) - prefix = ""; + prefix = strempty(prefix); fprintf(f, "%sUMask: %04o\n" @@ -1826,8 +1828,6 @@ void exec_context_dump(ExecContext *c, FILE* f, const char *prefix) { "%sRootDirectory: %s\n" "%sNonBlocking: %s\n" "%sPrivateTmp: %s\n" - "%sControlGroupModify: %s\n" - "%sControlGroupPersistent: %s\n" "%sPrivateNetwork: %s\n" "%sIgnoreSIGPIPE: %s\n", prefix, c->umask, @@ -1835,8 +1835,6 @@ void exec_context_dump(ExecContext *c, FILE* f, const char *prefix) { prefix, c->root_directory ? c->root_directory : "/", prefix, yes_no(c->non_blocking), prefix, yes_no(c->private_tmp), - prefix, yes_no(c->control_group_modify), - prefix, yes_no(c->control_group_persistent), prefix, yes_no(c->private_network), prefix, yes_no(c->ignore_sigpipe)); @@ -1963,12 +1961,12 @@ void exec_context_dump(ExecContext *c, FILE* f, const char *prefix) { if (c->secure_bits) fprintf(f, "%sSecure Bits:%s%s%s%s%s%s\n", prefix, - (c->secure_bits & SECURE_KEEP_CAPS) ? " keep-caps" : "", - (c->secure_bits & SECURE_KEEP_CAPS_LOCKED) ? " keep-caps-locked" : "", - (c->secure_bits & SECURE_NO_SETUID_FIXUP) ? " no-setuid-fixup" : "", - (c->secure_bits & SECURE_NO_SETUID_FIXUP_LOCKED) ? " no-setuid-fixup-locked" : "", - (c->secure_bits & SECURE_NOROOT) ? " noroot" : "", - (c->secure_bits & SECURE_NOROOT_LOCKED) ? "noroot-locked" : ""); + (c->secure_bits & 1<secure_bits & 1<secure_bits & 1<secure_bits & 1<secure_bits & 1<secure_bits & 1<capability_bounding_set_drop) { unsigned long l; @@ -2168,8 +2166,8 @@ void exec_command_append_list(ExecCommand **l, ExecCommand *e) { if (*l) { /* It's kind of important, that we keep the order here */ - LIST_FIND_TAIL(ExecCommand, command, *l, end); - LIST_INSERT_AFTER(ExecCommand, command, *l, end, e); + LIST_FIND_TAIL(command, *l, end); + LIST_INSERT_AFTER(command, *l, end, e); } else *l = e; } @@ -2188,7 +2186,8 @@ int exec_command_set(ExecCommand *c, const char *path, ...) { if (!l) return -ENOMEM; - if (!(p = strdup(path))) { + p = strdup(path); + if (!p) { strv_free(l); return -ENOMEM; } @@ -2202,6 +2201,216 @@ int exec_command_set(ExecCommand *c, const char *path, ...) { return 0; } +static int exec_runtime_allocate(ExecRuntime **rt) { + + if (*rt) + return 0; + + *rt = new0(ExecRuntime, 1); + if (!rt) + return -ENOMEM; + + (*rt)->n_ref = 1; + (*rt)->netns_storage_socket[0] = (*rt)->netns_storage_socket[1] = -1; + + return 0; +} + +int exec_runtime_make(ExecRuntime **rt, ExecContext *c, const char *id) { + int r; + + assert(rt); + assert(c); + assert(id); + + if (*rt) + return 1; + + if (!c->private_network && !c->private_tmp) + return 0; + + r = exec_runtime_allocate(rt); + if (r < 0) + return r; + + if (c->private_network && (*rt)->netns_storage_socket[0] < 0) { + if (socketpair(AF_UNIX, SOCK_DGRAM, 0, (*rt)->netns_storage_socket) < 0) + return -errno; + } + + if (c->private_tmp && !(*rt)->tmp_dir) { + r = setup_tmp_dirs(id, &(*rt)->tmp_dir, &(*rt)->var_tmp_dir); + if (r < 0) + return r; + } + + return 1; +} + +ExecRuntime *exec_runtime_ref(ExecRuntime *r) { + assert(r); + assert(r->n_ref > 0); + + r->n_ref++; + return r; +} + +ExecRuntime *exec_runtime_unref(ExecRuntime *r) { + + if (!r) + return NULL; + + assert(r->n_ref > 0); + + r->n_ref--; + if (r->n_ref <= 0) { + free(r->tmp_dir); + free(r->var_tmp_dir); + close_pipe(r->netns_storage_socket); + free(r); + } + + return NULL; +} + +int exec_runtime_serialize(ExecRuntime *rt, Unit *u, FILE *f, FDSet *fds) { + assert(u); + assert(f); + assert(fds); + + if (!rt) + return 0; + + if (rt->tmp_dir) + unit_serialize_item(u, f, "tmp-dir", rt->tmp_dir); + + if (rt->var_tmp_dir) + unit_serialize_item(u, f, "var-tmp-dir", rt->var_tmp_dir); + + if (rt->netns_storage_socket[0] >= 0) { + int copy; + + copy = fdset_put_dup(fds, rt->netns_storage_socket[0]); + if (copy < 0) + return copy; + + unit_serialize_item_format(u, f, "netns-socket-0", "%i", copy); + } + + if (rt->netns_storage_socket[1] >= 0) { + int copy; + + copy = fdset_put_dup(fds, rt->netns_storage_socket[1]); + if (copy < 0) + return copy; + + unit_serialize_item_format(u, f, "netns-socket-1", "%i", copy); + } + + return 0; +} + +int exec_runtime_deserialize_item(ExecRuntime **rt, Unit *u, const char *key, const char *value, FDSet *fds) { + int r; + + assert(rt); + assert(key); + assert(value); + + if (streq(key, "tmp-dir")) { + char *copy; + + r = exec_runtime_allocate(rt); + if (r < 0) + return r; + + copy = strdup(value); + if (!copy) + return log_oom(); + + free((*rt)->tmp_dir); + (*rt)->tmp_dir = copy; + + } else if (streq(key, "var-tmp-dir")) { + char *copy; + + r = exec_runtime_allocate(rt); + if (r < 0) + return r; + + copy = strdup(value); + if (!copy) + return log_oom(); + + free((*rt)->var_tmp_dir); + (*rt)->var_tmp_dir = copy; + + } else if (streq(key, "netns-socket-0")) { + int fd; + + r = exec_runtime_allocate(rt); + if (r < 0) + return r; + + if (safe_atoi(value, &fd) < 0 || !fdset_contains(fds, fd)) + log_debug_unit(u->id, "Failed to parse netns socket value %s", value); + else { + if ((*rt)->netns_storage_socket[0] >= 0) + close_nointr_nofail((*rt)->netns_storage_socket[0]); + + (*rt)->netns_storage_socket[0] = fdset_remove(fds, fd); + } + } else if (streq(key, "netns-socket-1")) { + int fd; + + r = exec_runtime_allocate(rt); + if (r < 0) + return r; + + if (safe_atoi(value, &fd) < 0 || !fdset_contains(fds, fd)) + log_debug_unit(u->id, "Failed to parse netns socket value %s", value); + else { + if ((*rt)->netns_storage_socket[1] >= 0) + close_nointr_nofail((*rt)->netns_storage_socket[1]); + + (*rt)->netns_storage_socket[1] = fdset_remove(fds, fd); + } + } else + return 0; + + return 1; +} + +static void *remove_tmpdir_thread(void *p) { + _cleanup_free_ char *path = p; + + rm_rf_dangerous(path, false, true, false); + return NULL; +} + +void exec_runtime_destroy(ExecRuntime *rt) { + if (!rt) + return; + + /* If there are multiple users of this, let's leave the stuff around */ + if (rt->n_ref > 1) + return; + + if (rt->tmp_dir) { + log_debug("Spawning thread to nuke %s", rt->tmp_dir); + asynchronous_job(remove_tmpdir_thread, rt->tmp_dir); + rt->tmp_dir = NULL; + } + + if (rt->var_tmp_dir) { + log_debug("Spawning thread to nuke %s", rt->var_tmp_dir); + asynchronous_job(remove_tmpdir_thread, rt->var_tmp_dir); + rt->var_tmp_dir = NULL; + } + + close_pipe(rt->netns_storage_socket); +} + static const char* const exec_input_table[_EXEC_INPUT_MAX] = { [EXEC_INPUT_NULL] = "null", [EXEC_INPUT_TTY] = "tty",