[people/ms/systemd.git] / execute.c

/*-*- Mode: C; c-basic-offset: 8 -*-*/

#pragma GCC diagnostic ignored "-Wattributes"

#include <assert.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/prctl.h>
#include <linux/sched.h>

#include "execute.h"
#include "strv.h"
#include "macro.h"
#include "util.h"
#include "log.h"
#include "ioprio.h"
#include "securebits.h"

static int close_fds(int except[], unsigned n_except) {
        DIR *d;
        struct dirent *de;
        int r = 0;

        /* Modifies the fds array! (sorts it) */

        if (!(d = opendir("/proc/self/fd")))
                return -errno;

        while ((de = readdir(d))) {
                int fd;

                if (de->d_name[0] == '.')
                        continue;

                if ((r = safe_atoi(de->d_name, &fd)) < 0)
                        goto finish;

                if (fd < 3)
                        continue;

                if (fd == dirfd(d))
                        continue;

                if (except) {
                        bool found;
                        unsigned i;

                        found = false;
                        for (i = 0; i < n_except; i++)
                                if (except[i] == fd) {
                                        found = true;
                                        break;
                                }

                        if (found)
                                continue;
                }

                if ((r = close_nointr(fd)) < 0)
                        goto finish;
        }

finish:
        closedir(d);
        return r;
}

static int shift_fds(int fds[], unsigned n_fds) {
        int start, restart_from;

        if (n_fds <= 0)
                return 0;

        assert(fds);

        start = 0;
        for (;;) {
                int i;

                restart_from = -1;

                for (i = start; i < (int) n_fds; i++) {
                        int nfd;

                        /* Already at right index? */
                        if (fds[i] == i+3)
                                continue;

                        if ((nfd = fcntl(fds[i], F_DUPFD, i+3)) < 0)
                                return -errno;

                        assert_se(close_nointr(fds[i]) == 0);
                        fds[i] = nfd;

                        /* Hmm, the fd we wanted isn't free? Then
                         * let's remember that and try again from here*/
                        if (nfd != i+3 && restart_from < 0)
                                restart_from = i;
                }

                if (restart_from < 0)
                        break;

                start = restart_from;
        }

        return 0;
}

static int flags_fds(int fds[], unsigned n_fds) {
        unsigned i;

        if (n_fds <= 0)
                return 0;

        assert(fds);

        /* Drops O_NONBLOCK and FD_CLOEXEC from the file flags */

        for (i = 0; i < n_fds; i++) {
                int flags;

                if ((flags = fcntl(fds[i], F_GETFL, 0)) < 0)
                        return -errno;

                /* Since we are at it, let's make sure that nobody
                 * forgot setting O_NONBLOCK for all our fds */

                if (fcntl(fds[i], F_SETFL, flags &~O_NONBLOCK) < 0)
                        return -errno;

                if ((flags = fcntl(fds[i], F_GETFD, 0)) < 0)
                        return -errno;

                /* Also make sure nobody forgot O_CLOEXEC for all our
                 * fds */
                if (fcntl(fds[i], F_SETFD, flags &~FD_CLOEXEC) < 0)
                        return -errno;
        }

        return 0;
}

static int replace_null_fd(int fd, int flags) {
        int nfd;
        assert(fd >= 0);

        close_nointr(fd);

        if ((nfd = open("/dev/null", flags|O_NOCTTY)) < 0)
                return -errno;

        if (nfd != fd) {
                close_nointr_nofail(nfd);
                return -EIO;
        }

        return 0;
}

static int setup_output(const ExecContext *context, const char *ident) {
        int r;

        assert(context);

        switch (context->output) {

        case EXEC_OUTPUT_CONSOLE:
                return 0;

        case EXEC_OUTPUT_NULL:

                if ((r = replace_null_fd(STDOUT_FILENO, O_WRONLY)) < 0 ||
                    (r = replace_null_fd(STDERR_FILENO, O_WRONLY)) < 0)
                        return r;

                return 0;

        case EXEC_OUTPUT_KERNEL:
        case EXEC_OUTPUT_SYSLOG: {

                int fd;
                union {
                        struct sockaddr sa;
                        struct sockaddr_un un;
                } sa;

                close_nointr(STDOUT_FILENO);
                close_nointr(STDERR_FILENO);

                if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
                        return -errno;

                if (fd != STDOUT_FILENO) {
                        close_nointr_nofail(fd);
                        return -EIO;
                }

                zero(sa);
                sa.sa.sa_family = AF_UNIX;
                strncpy(sa.un.sun_path+1, LOGGER_SOCKET, sizeof(sa.un.sun_path)-1);

                if (connect(fd, &sa.sa, sizeof(sa)) < 0) {
                        close_nointr_nofail(fd);
                        return -errno;
                }

                if (shutdown(fd, SHUT_RD) < 0) {
                        close_nointr_nofail(fd);
                        return -errno;
                }

                if ((fd = dup(fd)) < 0) {
                        close_nointr_nofail(fd);
                        return -errno;
                }

                if (fd != STDERR_FILENO) {
                        close_nointr_nofail(fd);
                        return -EIO;
                }

                /* We speak a very simple protocol between log server
                 * and client: one line for the log destination (kmsg
                 * or syslog), followed by the priority field,
                 * followed by the process name. Since we replaced
                 * stdin/stderr we simple use stdio to write to
                 * it. Note that we use stderr, to minimize buffer
                 * flushing issues. */

                fprintf(stderr,
                        "%s\n"
                        "%i\n"
                        "%s\n",
                        context->output == EXEC_OUTPUT_KERNEL ? "kmsg" : "syslog",
                        context->syslog_priority,
                        context->syslog_identifier ? context->syslog_identifier : ident);

                return 0;
        }

        default:
                assert_not_reached("Unknown output type");
        }
}

int setup_input(const ExecContext *context) {
        int r;

        assert(context);

        switch (context->input) {

        case EXEC_INPUT_CONSOLE:
                return 0;

        case EXEC_INPUT_NULL:
                if ((r = replace_null_fd(STDIN_FILENO, O_RDONLY)) < 0)
                        return r;

                return 0;

        default:
                assert_not_reached("Unknown input type");
        }
}

int exec_spawn(const ExecCommand *command, const ExecContext *context, int *fds, unsigned n_fds, pid_t *ret) {
        pid_t pid;

        assert(command);
        assert(context);
        assert(ret);
        assert(fds || n_fds <= 0);

        log_debug("about to execute %s", command->path);

        if ((pid = fork()) < 0)
                return -errno;

        if (pid == 0) {
                char **e, **f = NULL;
                int i, r;
                sigset_t ss;

                /* child */

                if (sigemptyset(&ss) < 0 ||
                    sigprocmask(SIG_SETMASK, &ss, NULL) < 0) {
                        r = EXIT_SIGNAL_MASK;
                        goto fail;
                }

                if (setpgid(0, 0) < 0) {
                        r = EXIT_PGID;
                        goto fail;
                }

                umask(context->umask);

                if (setup_input(context) < 0) {
                        r = EXIT_INPUT;
                        goto fail;
                }

                if (setup_output(context, file_name_from_path(command->path)) < 0) {
                        r = EXIT_OUTPUT;
                        goto fail;
                }

                if (context->oom_adjust_set) {
                        char t[16];

                        snprintf(t, sizeof(t), "%i", context->oom_adjust);
                        char_array_0(t);

                        if (write_one_line_file("/proc/self/oom_adj", t) < 0) {
                                r = EXIT_OOM_ADJUST;
                                goto fail;
                        }
                }

                if (context->root_directory)
                        if (chroot(context->root_directory) < 0) {
                                r = EXIT_CHROOT;
                                goto fail;
                        }

                if (chdir(context->working_directory ? context->working_directory : "/") < 0) {
                        r = EXIT_CHDIR;
                        goto fail;
                }

                if (context->nice_set)
                        if (setpriority(PRIO_PROCESS, 0, context->nice) < 0) {
                                r = EXIT_NICE;
                                goto fail;
                        }

                if (context->cpu_sched_set) {
                        struct sched_param param;

                        zero(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), &param) < 0) {
                                r = EXIT_SETSCHEDULER;
                                goto fail;
                        }
                }

                if (context->cpu_affinity_set)
                        if (sched_setaffinity(0, sizeof(context->cpu_affinity), &context->cpu_affinity) < 0) {
                                r = EXIT_CPUAFFINITY;
                                goto fail;
                        }

                if (context->ioprio_set)
                        if (ioprio_set(IOPRIO_WHO_PROCESS, 0, context->ioprio) < 0) {
                                r = EXIT_IOPRIO;
                                goto fail;
                        }

                if (context->timer_slack_ns_set)
                        if (prctl(PR_SET_TIMERSLACK, context->timer_slack_ns_set) < 0) {
                                r = EXIT_TIMERSLACK;
                                goto fail;
                        }

                if (close_fds(fds, n_fds) < 0 ||
                    shift_fds(fds, n_fds) < 0 ||
                    flags_fds(fds, n_fds) < 0) {
                        r = EXIT_FDS;
                        goto fail;
                }

                for (i = 0; i < RLIMIT_NLIMITS; i++) {
                        if (!context->rlimit[i])
                                continue;

                        if (setrlimit(i, context->rlimit[i]) < 0) {
                                r = EXIT_LIMITS;
                                goto fail;
                        }
                }

                if (context->secure_bits) {
                        if (prctl(PR_SET_SECUREBITS, context->secure_bits) < 0) {
                                r = EXIT_SECUREBITS;
                                goto fail;
                        }
                }

                if (n_fds > 0) {
                        char a[64], b[64];
                        char *listen_env[3] = {
                                a,
                                b,
                                NULL
                        };

                        snprintf(a, sizeof(a), "LISTEN_PID=%llu", (unsigned long long) getpid());
                        snprintf(b, sizeof(b), "LISTEN_FDS=%u", n_fds);

                        a[sizeof(a)-1] = 0;
                        b[sizeof(b)-1] = 0;

                        if (context->environment) {
                                if (!(f = strv_merge(listen_env, context->environment))) {
                                        r = EXIT_MEMORY;
                                        goto fail;
                                }
                                e = f;
                        } else
                                e = listen_env;

                } else
                        e = context->environment;

                execve(command->path, command->argv, e);
                r = EXIT_EXEC;

        fail:
                strv_free(f);
                _exit(r);
        }


        log_debug("executed %s as %llu", command->path, (unsigned long long) pid);

        *ret = pid;
        return 0;
}

void exec_context_init(ExecContext *c) {
        assert(c);

        c->umask = 0002;
        c->oom_adjust = 0;
        c->oom_adjust_set = false;
        c->nice = 0;
        c->nice_set = false;
        c->ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 0);
        c->ioprio_set = false;
        c->cpu_sched_policy = SCHED_OTHER;
        c->cpu_sched_priority = 0;
        c->cpu_sched_set = false;
        CPU_ZERO(&c->cpu_affinity);
        c->cpu_affinity_set = false;

        c->input = 0;
        c->output = 0;
        c->syslog_priority = LOG_DAEMON|LOG_INFO;

        c->secure_bits = 0;
        c->capability_bounding_set_drop = 0;
}

void exec_context_done(ExecContext *c) {
        unsigned l;

        assert(c);

        strv_free(c->environment);
        c->environment = NULL;

        for (l = 0; l < ELEMENTSOF(c->rlimit); l++) {
                free(c->rlimit[l]);
                c->rlimit[l] = NULL;
        }

        free(c->working_directory);
        c->working_directory = NULL;
        free(c->root_directory);
        c->root_directory = NULL;

        free(c->syslog_identifier);
        c->syslog_identifier = NULL;

        free(c->user);
        c->user = NULL;

        free(c->group);
        c->group = NULL;

        strv_free(c->supplementary_groups);
        c->supplementary_groups = NULL;

        if (c->capabilities) {
                cap_free(c->capabilities);
                c->capabilities = NULL;
        }
}

void exec_command_free_list(ExecCommand *c) {
        ExecCommand *i;

        while ((i = c)) {
                LIST_REMOVE(ExecCommand, command, c, i);

                free(i->path);
                strv_free(i->argv);
                free(i);
        }
}

void exec_command_free_array(ExecCommand **c, unsigned n) {
        unsigned i;

        for (i = 0; i < n; i++) {
                exec_command_free_list(c[i]);
                c[i] = NULL;
        }
}

void exec_context_dump(ExecContext *c, FILE* f, const char *prefix) {
        char ** e;
        unsigned i;

        assert(c);
        assert(f);

        if (!prefix)
                prefix = "";

        fprintf(f,
                "%sUMask: %04o\n"
                "%sWorkingDirectory: %s\n"
                "%sRootDirectory: %s\n",
                prefix, c->umask,
                prefix, c->working_directory ? c->working_directory : "/",
                prefix, c->root_directory ? c->root_directory : "/");

        if (c->environment)
                for (e = c->environment; *e; e++)
                        fprintf(f, "%sEnvironment: %s\n", prefix, *e);

        if (c->nice_set)
                fprintf(f,
                        "%sNice: %i\n",
                        prefix, c->nice);

        if (c->oom_adjust_set)
                fprintf(f,
                        "%sOOMAdjust: %i\n",
                        prefix, c->oom_adjust);

        for (i = 0; i < RLIM_NLIMITS; i++)
                if (c->rlimit[i])
                        fprintf(f, "%s%s: %llu\n", prefix, rlimit_to_string(i), (unsigned long long) c->rlimit[i]->rlim_max);

        if (c->ioprio_set)
                fprintf(f,
                        "%sIOSchedulingClass: %s\n"
                        "%sIOPriority: %i\n",
                        prefix, ioprio_class_to_string(IOPRIO_PRIO_CLASS(c->ioprio)),
                        prefix, (int) IOPRIO_PRIO_DATA(c->ioprio));

        if (c->cpu_sched_set)
                fprintf(f,
                        "%sCPUSchedulingPolicy: %s\n"
                        "%sCPUSchedulingPriority: %i\n"
                        "%sCPUSchedulingResetOnFork: %s\n",
                        prefix, sched_policy_to_string(c->cpu_sched_policy),
                        prefix, c->cpu_sched_priority,
                        prefix, yes_no(c->cpu_sched_reset_on_fork));

        if (c->cpu_affinity_set) {
                fprintf(f, "%sCPUAffinity:", prefix);
                for (i = 0; i < CPU_SETSIZE; i++)
                        if (CPU_ISSET(i, &c->cpu_affinity))
                                fprintf(f, " %i", i);
                fputs("\n", f);
        }

        if (c->timer_slack_ns_set)
                fprintf(f, "%sTimerSlackNS: %lu\n", prefix, c->timer_slack_ns);

        fprintf(f,
                "%sInput: %s\n"
                "%sOutput: %s\n",
                prefix, exec_input_to_string(c->input),
                prefix, exec_output_to_string(c->output));

        if (c->output == EXEC_OUTPUT_SYSLOG || c->output == EXEC_OUTPUT_KERNEL)
                fprintf(f,
                        "%sSyslogFacility: %s\n"
                        "%sSyslogLevel: %s\n",
                        prefix, log_facility_to_string(LOG_FAC(c->syslog_priority)),
                        prefix, log_level_to_string(LOG_PRI(c->syslog_priority)));

        if (c->capabilities) {
                char *t;
                if ((t = cap_to_text(c->capabilities, NULL))) {
                        fprintf(f, "%sCapabilities: %s\n",
                                prefix, t);
                        cap_free(t);
                }
        }

        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" : "");

        if (c->capability_bounding_set_drop) {
                fprintf(f, "%sCapabilityBoundingSetDrop:", prefix);

                for (i = 0; i <= CAP_LAST_CAP; i++)
                        if (c->capability_bounding_set_drop & (1 << i)) {
                                char *t;

                                if ((t = cap_to_name(i))) {
                                        fprintf(f, " %s", t);
                                        free(t);
                                }
                        }

                fputs("\n", f);
        }

        if (c->user)
                fprintf(f, "%sUser: %s", prefix, c->user);
        if (c->group)
                fprintf(f, "%sGroup: %s", prefix, c->group);

        if (c->supplementary_groups) {
                char **g;

                fprintf(f, "%sSupplementaryGroups:", prefix);

                STRV_FOREACH(g, c->supplementary_groups)
                        fprintf(f, " %s", *g);

                fputs("\n", f);
        }
}

void exec_status_fill(ExecStatus *s, pid_t pid, int code, int status) {
        assert(s);

        s->pid = pid;
        s->code = code;
        s->status = status;
        s->timestamp = now(CLOCK_REALTIME);
}

char *exec_command_line(ExecCommand *c) {
        size_t k;
        char *n, *p, **a;
        bool first = true;

        assert(c);
        assert(c->argv);

        k = 1;
        STRV_FOREACH(a, c->argv)
                k += strlen(*a)+3;

        if (!(n = new(char, k)))
                return NULL;

        p = n;
        STRV_FOREACH(a, c->argv) {

                if (!first)
                        *(p++) = ' ';
                else
                        first = false;

                if (strpbrk(*a, WHITESPACE)) {
                        *(p++) = '\'';
                        p = stpcpy(p, *a);
                        *(p++) = '\'';
                } else
                        p = stpcpy(p, *a);

        }

        *p = 0;

        /* FIXME: this doesn't really handle arguments that have
         * spaces and ticks in them */

        return n;
}

void exec_command_dump(ExecCommand *c, FILE *f, const char *prefix) {
        char *cmd;

        assert(c);
        assert(f);

        if (!prefix)
                prefix = "";

        cmd = exec_command_line(c);

        fprintf(f,
                "%sCommand Line: %s\n",
                prefix, cmd ? cmd : strerror(ENOMEM));

        free(cmd);
}

void exec_command_dump_list(ExecCommand *c, FILE *f, const char *prefix) {
        assert(f);

        if (!prefix)
                prefix = "";

        LIST_FOREACH(command, c, c)
                exec_command_dump(c, f, prefix);
}

static const char* const exec_output_table[_EXEC_OUTPUT_MAX] = {
        [EXEC_OUTPUT_CONSOLE] = "console",
        [EXEC_OUTPUT_NULL] = "null",
        [EXEC_OUTPUT_SYSLOG] = "syslog",
        [EXEC_OUTPUT_KERNEL] = "kernel"
};

DEFINE_STRING_TABLE_LOOKUP(exec_output, ExecOutput);

static const char* const exec_input_table[_EXEC_INPUT_MAX] = {
        [EXEC_INPUT_NULL] = "null",
        [EXEC_INPUT_CONSOLE] = "console"
};

DEFINE_STRING_TABLE_LOOKUP(exec_input, ExecInput);
Commit	Line	Data
5cb5a6ff LP	1	/-- Mode: C; c-basic-offset: 8 --/
5cb5a6ff LP	2
cc13a98b LP	3	#pragma GCC diagnostic ignored "-Wattributes"
cc13a98b LP	4
5cb5a6ff	5	#include <assert.h>
034c6ed7 LP	6	#include <dirent.h>
	7	#include <errno.h>
	8	#include <fcntl.h>
	9	#include <unistd.h>
44d8db9e	10	#include <string.h>
309bff19	11	#include <signal.h>
071830ff LP	12	#include <sys/socket.h>
071830ff LP	13	#include <sys/un.h>
94f04347	14	#include <sys/prctl.h>
66ee3769	15	#include <linux/sched.h>
5cb5a6ff LP	16
	17	#include "execute.h"
	18	#include "strv.h"
	19	#include "macro.h"
	20	#include "util.h"
acbb0225	21	#include "log.h"
9eba9da4	22	#include "ioprio.h"
94f04347	23	#include "securebits.h"
5cb5a6ff	24
034c6ed7 LP	25	static int close_fds(int except[], unsigned n_except) {
	26	DIR *d;
	27	struct dirent *de;
	28	int r = 0;
	29
	30	/* Modifies the fds array! (sorts it) */
	31
	32	if (!(d = opendir("/proc/self/fd")))
	33	return -errno;
	34
	35	while ((de = readdir(d))) {
	36	int fd;
	37
	38	if (de->d_name[0] == '.')
	39	continue;
	40
	41	if ((r = safe_atoi(de->d_name, &fd)) < 0)
	42	goto finish;
	43
	44	if (fd < 3)
	45	continue;
	46
	47	if (fd == dirfd(d))
	48	continue;
	49
	50	if (except) {
	51	bool found;
	52	unsigned i;
	53
	54	found = false;
	55	for (i = 0; i < n_except; i++)
	56	if (except[i] == fd) {
	57	found = true;
	58	break;
	59	}
	60
	61	if (found)
	62	continue;
	63	}
	64
	65	if ((r = close_nointr(fd)) < 0)
	66	goto finish;
	67	}
	68
	69	finish:
	70	closedir(d);
	71	return r;
	72	}
	73
	74	static int shift_fds(int fds[], unsigned n_fds) {
	75	int start, restart_from;
	76
	77	if (n_fds <= 0)
	78	return 0;
	79
	80	assert(fds);
	81
	82	start = 0;
	83	for (;;) {
	84	int i;
	85
	86	restart_from = -1;
	87
	88	for (i = start; i < (int) n_fds; i++) {
89	int nfd;
90
91	/* Already at right index? */
92	if (fds[i] == i+3)
93	continue;
94
95	if ((nfd = fcntl(fds[i], F_DUPFD, i+3)) < 0)
96	return -errno;
97
2da3263a	98	assert_se(close_nointr(fds[i]) == 0);
034c6ed7 LP	99	fds[i] = nfd;
	100
	101	/* Hmm, the fd we wanted isn't free? Then
	102	* let's remember that and try again from here*/
	103	if (nfd != i+3 && restart_from < 0)
	104	restart_from = i;
	105	}
	106
	107	if (restart_from < 0)
	108	break;
	109
	110	start = restart_from;
	111	}
	112
	113	return 0;
	114	}
	115
47a71eed LP	116	static int flags_fds(int fds[], unsigned n_fds) {
	117	unsigned i;
	118
	119	if (n_fds <= 0)
	120	return 0;
	121
	122	assert(fds);
	123
	124	/* Drops O_NONBLOCK and FD_CLOEXEC from the file flags */
	125
	126	for (i = 0; i < n_fds; i++) {
	127	int flags;
	128
	129	if ((flags = fcntl(fds[i], F_GETFL, 0)) < 0)
	130	return -errno;
	131
	132	/* Since we are at it, let's make sure that nobody
	133	* forgot setting O_NONBLOCK for all our fds */
	134
	135	if (fcntl(fds[i], F_SETFL, flags &~O_NONBLOCK) < 0)
	136	return -errno;
	137
	138	if ((flags = fcntl(fds[i], F_GETFD, 0)) < 0)
	139	return -errno;
	140
	141	/* Also make sure nobody forgot O_CLOEXEC for all our
	142	* fds */
	143	if (fcntl(fds[i], F_SETFD, flags &~FD_CLOEXEC) < 0)
	144	return -errno;
	145	}
	146
	147	return 0;
	148	}
	149
071830ff LP	150	static int replace_null_fd(int fd, int flags) {
	151	int nfd;
	152	assert(fd >= 0);
	153
	154	close_nointr(fd);
	155
	156	if ((nfd = open("/dev/null", flags\|O_NOCTTY)) < 0)
	157	return -errno;
	158
	159	if (nfd != fd) {
	160	close_nointr_nofail(nfd);
	161	return -EIO;
	162	}
	163
	164	return 0;
	165	}
	166
	167	static int setup_output(const ExecContext context, const char ident) {
	168	int r;
	169
	170	assert(context);
	171
	172	switch (context->output) {
	173
94f04347	174	case EXEC_OUTPUT_CONSOLE:
071830ff LP	175	return 0;
071830ff LP	176
94f04347	177	case EXEC_OUTPUT_NULL:
071830ff	178
94f04347	179	if ((r = replace_null_fd(STDOUT_FILENO, O_WRONLY)) < 0 \|\|
071830ff LP	180	(r = replace_null_fd(STDERR_FILENO, O_WRONLY)) < 0)
	181	return r;
	182
	183	return 0;
	184
94f04347 LP	185	case EXEC_OUTPUT_KERNEL:
94f04347 LP	186	case EXEC_OUTPUT_SYSLOG: {
071830ff LP	187
	188	int fd;
	189	union {
	190	struct sockaddr sa;
	191	struct sockaddr_un un;
	192	} sa;
	193
071830ff LP	194	close_nointr(STDOUT_FILENO);
	195	close_nointr(STDERR_FILENO);
	196
	197	if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
	198	return -errno;
	199
	200	if (fd != STDOUT_FILENO) {
	201	close_nointr_nofail(fd);
	202	return -EIO;
	203	}
	204
	205	zero(sa);
	206	sa.sa.sa_family = AF_UNIX;
	207	strncpy(sa.un.sun_path+1, LOGGER_SOCKET, sizeof(sa.un.sun_path)-1);
	208
	209	if (connect(fd, &sa.sa, sizeof(sa)) < 0) {
	210	close_nointr_nofail(fd);
	211	return -errno;
	212	}
	213
	214	if (shutdown(fd, SHUT_RD) < 0) {
	215	close_nointr_nofail(fd);
	216	return -errno;
	217	}
	218
	219	if ((fd = dup(fd)) < 0) {
	220	close_nointr_nofail(fd);
	221	return -errno;
	222	}
	223
	224	if (fd != STDERR_FILENO) {
	225	close_nointr_nofail(fd);
	226	return -EIO;
	227	}
	228
	229	/* We speak a very simple protocol between log server
	230	* and client: one line for the log destination (kmsg
	231	* or syslog), followed by the priority field,
	232	* followed by the process name. Since we replaced
	233	* stdin/stderr we simple use stdio to write to
	234	* it. Note that we use stderr, to minimize buffer
	235	* flushing issues. */
	236
	237	fprintf(stderr,
	238	"%s\n"
	239	"%i\n"
	240	"%s\n",
94f04347	241	context->output == EXEC_OUTPUT_KERNEL ? "kmsg" : "syslog",
071830ff LP	242	context->syslog_priority,
	243	context->syslog_identifier ? context->syslog_identifier : ident);
	244
	245	return 0;
	246	}
94f04347 LP	247
	248	default:
	249	assert_not_reached("Unknown output type");
071830ff	250	}
94f04347 LP	251	}
	252
	253	int setup_input(const ExecContext *context) {
	254	int r;
	255
	256	assert(context);
071830ff	257
94f04347 LP	258	switch (context->input) {
	259
	260	case EXEC_INPUT_CONSOLE:
	261	return 0;
	262
	263	case EXEC_INPUT_NULL:
	264	if ((r = replace_null_fd(STDIN_FILENO, O_RDONLY)) < 0)
	265	return r;
	266
	267	return 0;
	268
	269	default:
	270	assert_not_reached("Unknown input type");
	271	}
071830ff LP	272	}
071830ff LP	273
034c6ed7 LP	274	int exec_spawn(const ExecCommand command, const ExecContext context, int fds, unsigned n_fds, pid_t ret) {
	275	pid_t pid;
	276
5cb5a6ff LP	277	assert(command);
	278	assert(context);
	279	assert(ret);
034c6ed7 LP	280	assert(fds \|\| n_fds <= 0);
034c6ed7 LP	281
2da3263a	282	log_debug("about to execute %s", command->path);
acbb0225	283
034c6ed7 LP	284	if ((pid = fork()) < 0)
	285	return -errno;
	286
	287	if (pid == 0) {
	288	char e, f = NULL;
	289	int i, r;
309bff19 LP	290	sigset_t ss;
309bff19 LP	291
034c6ed7	292	/* child */
5cb5a6ff	293
309bff19 LP	294	if (sigemptyset(&ss) < 0 \|\|
	295	sigprocmask(SIG_SETMASK, &ss, NULL) < 0) {
	296	r = EXIT_SIGNAL_MASK;
	297	goto fail;
	298	}
	299
9eba9da4 LP	300	if (setpgid(0, 0) < 0) {
9eba9da4 LP	301	r = EXIT_PGID;
034c6ed7 LP	302	goto fail;
	303	}
	304
9eba9da4 LP	305	umask(context->umask);
9eba9da4 LP	306
94f04347 LP	307	if (setup_input(context) < 0) {
	308	r = EXIT_INPUT;
	309	goto fail;
	310	}
	311
071830ff LP	312	if (setup_output(context, file_name_from_path(command->path)) < 0) {
	313	r = EXIT_OUTPUT;
	314	goto fail;
	315	}
	316
fb33a393 LP	317	if (context->oom_adjust_set) {
fb33a393 LP	318	char t[16];
034c6ed7	319
fb33a393 LP	320	snprintf(t, sizeof(t), "%i", context->oom_adjust);
fb33a393 LP	321	char_array_0(t);
034c6ed7	322
fb33a393 LP	323	if (write_one_line_file("/proc/self/oom_adj", t) < 0) {
	324	r = EXIT_OOM_ADJUST;
	325	goto fail;
	326	}
034c6ed7 LP	327	}
034c6ed7 LP	328
9eba9da4 LP	329	if (context->root_directory)
	330	if (chroot(context->root_directory) < 0) {
	331	r = EXIT_CHROOT;
	332	goto fail;
	333	}
	334
	335	if (chdir(context->working_directory ? context->working_directory : "/") < 0) {
	336	r = EXIT_CHDIR;
	337	goto fail;
	338	}
	339
fb33a393 LP	340	if (context->nice_set)
	341	if (setpriority(PRIO_PROCESS, 0, context->nice) < 0) {
	342	r = EXIT_NICE;
	343	goto fail;
	344	}
	345
94f04347 LP	346	if (context->cpu_sched_set) {
	347	struct sched_param param;
	348
	349	zero(param);
	350	param.sched_priority = context->cpu_sched_priority;
	351
38b48754 LP	352	if (sched_setscheduler(0, context->cpu_sched_policy \|
38b48754 LP	353	(context->cpu_sched_reset_on_fork ? SCHED_RESET_ON_FORK : 0), &param) < 0) {
94f04347 LP	354	r = EXIT_SETSCHEDULER;
	355	goto fail;
	356	}
	357	}
	358
	359	if (context->cpu_affinity_set)
	360	if (sched_setaffinity(0, sizeof(context->cpu_affinity), &context->cpu_affinity) < 0) {
	361	r = EXIT_CPUAFFINITY;
	362	goto fail;
	363	}
	364
9eba9da4 LP	365	if (context->ioprio_set)
	366	if (ioprio_set(IOPRIO_WHO_PROCESS, 0, context->ioprio) < 0) {
	367	r = EXIT_IOPRIO;
	368	goto fail;
	369	}
	370
94f04347 LP	371	if (context->timer_slack_ns_set)
	372	if (prctl(PR_SET_TIMERSLACK, context->timer_slack_ns_set) < 0) {
	373	r = EXIT_TIMERSLACK;
	374	goto fail;
	375	}
	376
034c6ed7	377	if (close_fds(fds, n_fds) < 0 \|\|
47a71eed LP	378	shift_fds(fds, n_fds) < 0 \|\|
47a71eed LP	379	flags_fds(fds, n_fds) < 0) {
034c6ed7 LP	380	r = EXIT_FDS;
	381	goto fail;
	382	}
	383
	384	for (i = 0; i < RLIMIT_NLIMITS; i++) {
	385	if (!context->rlimit[i])
	386	continue;
	387
	388	if (setrlimit(i, context->rlimit[i]) < 0) {
	389	r = EXIT_LIMITS;
	390	goto fail;
	391	}
	392	}
	393
94f04347 LP	394	if (context->secure_bits) {
	395	if (prctl(PR_SET_SECUREBITS, context->secure_bits) < 0) {
	396	r = EXIT_SECUREBITS;
	397	goto fail;
	398	}
	399	}
	400
034c6ed7 LP	401	if (n_fds > 0) {
	402	char a[64], b[64];
	403	char *listen_env[3] = {
	404	a,
	405	b,
	406	NULL
	407	};
	408
	409	snprintf(a, sizeof(a), "LISTEN_PID=%llu", (unsigned long long) getpid());
	410	snprintf(b, sizeof(b), "LISTEN_FDS=%u", n_fds);
	411
	412	a[sizeof(a)-1] = 0;
	413	b[sizeof(b)-1] = 0;
	414
	415	if (context->environment) {
	416	if (!(f = strv_merge(listen_env, context->environment))) {
	417	r = EXIT_MEMORY;
	418	goto fail;
	419	}
	420	e = f;
	421	} else
	422	e = listen_env;
	423
	424	} else
	425	e = context->environment;
	426
	427	execve(command->path, command->argv, e);
	428	r = EXIT_EXEC;
	429
	430	fail:
	431	strv_free(f);
	432	_exit(r);
	433	}
	434
2da3263a LP	435
	436	log_debug("executed %s as %llu", command->path, (unsigned long long) pid);
	437
034c6ed7	438	*ret = pid;
5cb5a6ff LP	439	return 0;
	440	}
	441
034c6ed7 LP	442	void exec_context_init(ExecContext *c) {
	443	assert(c);
	444
	445	c->umask = 0002;
034c6ed7	446	c->oom_adjust = 0;
9eba9da4	447	c->oom_adjust_set = false;
034c6ed7	448	c->nice = 0;
9eba9da4 LP	449	c->nice_set = false;
	450	c->ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 0);
	451	c->ioprio_set = false;
94f04347 LP	452	c->cpu_sched_policy = SCHED_OTHER;
	453	c->cpu_sched_priority = 0;
	454	c->cpu_sched_set = false;
	455	CPU_ZERO(&c->cpu_affinity);
	456	c->cpu_affinity_set = false;
071830ff	457
94f04347	458	c->input = 0;
071830ff LP	459	c->output = 0;
071830ff LP	460	c->syslog_priority = LOG_DAEMON\|LOG_INFO;
94f04347 LP	461
	462	c->secure_bits = 0;
	463	c->capability_bounding_set_drop = 0;
034c6ed7 LP	464	}
	465
	466	void exec_context_done(ExecContext *c) {
5cb5a6ff LP	467	unsigned l;
	468
	469	assert(c);
	470
	471	strv_free(c->environment);
034c6ed7	472	c->environment = NULL;
5cb5a6ff	473
034c6ed7	474	for (l = 0; l < ELEMENTSOF(c->rlimit); l++) {
5cb5a6ff	475	free(c->rlimit[l]);
034c6ed7 LP	476	c->rlimit[l] = NULL;
	477	}
	478
9eba9da4 LP	479	free(c->working_directory);
	480	c->working_directory = NULL;
	481	free(c->root_directory);
	482	c->root_directory = NULL;
5cb5a6ff	483
071830ff LP	484	free(c->syslog_identifier);
	485	c->syslog_identifier = NULL;
	486
5cb5a6ff	487	free(c->user);
034c6ed7 LP	488	c->user = NULL;
034c6ed7 LP	489
5cb5a6ff	490	free(c->group);
034c6ed7 LP	491	c->group = NULL;
	492
	493	strv_free(c->supplementary_groups);
	494	c->supplementary_groups = NULL;
94f04347 LP	495
	496	if (c->capabilities) {
	497	cap_free(c->capabilities);
	498	c->capabilities = NULL;
	499	}
5cb5a6ff LP	500	}
	501
	502	void exec_command_free_list(ExecCommand *c) {
	503	ExecCommand *i;
	504
	505	while ((i = c)) {
034c6ed7	506	LIST_REMOVE(ExecCommand, command, c, i);
5cb5a6ff LP	507
5cb5a6ff LP	508	free(i->path);
44d8db9e	509	strv_free(i->argv);
5cb5a6ff LP	510	free(i);
	511	}
	512	}
	513
034c6ed7 LP	514	void exec_command_free_array(ExecCommand **c, unsigned n) {
	515	unsigned i;
	516
	517	for (i = 0; i < n; i++) {
	518	exec_command_free_list(c[i]);
	519	c[i] = NULL;
	520	}
	521	}
	522
5cb5a6ff	523	void exec_context_dump(ExecContext c, FILE f, const char *prefix) {
94f04347 LP	524	char ** e;
94f04347 LP	525	unsigned i;
9eba9da4	526
5cb5a6ff LP	527	assert(c);
	528	assert(f);
	529
	530	if (!prefix)
	531	prefix = "";
	532
	533	fprintf(f,
94f04347 LP	534	"%sUMask: %04o\n"
	535	"%sWorkingDirectory: %s\n"
	536	"%sRootDirectory: %s\n",
5cb5a6ff	537	prefix, c->umask,
9eba9da4 LP	538	prefix, c->working_directory ? c->working_directory : "/",
9eba9da4 LP	539	prefix, c->root_directory ? c->root_directory : "/");
fb33a393	540
94f04347 LP	541	if (c->environment)
	542	for (e = c->environment; *e; e++)
	543	fprintf(f, "%sEnvironment: %s\n", prefix, *e);
	544
fb33a393 LP	545	if (c->nice_set)
	546	fprintf(f,
	547	"%sNice: %i\n",
	548	prefix, c->nice);
	549
	550	if (c->oom_adjust_set)
	551	fprintf(f,
	552	"%sOOMAdjust: %i\n",
	553	prefix, c->oom_adjust);
9eba9da4	554
94f04347 LP	555	for (i = 0; i < RLIM_NLIMITS; i++)
94f04347 LP	556	if (c->rlimit[i])
ea430986	557	fprintf(f, "%s%s: %llu\n", prefix, rlimit_to_string(i), (unsigned long long) c->rlimit[i]->rlim_max);
94f04347	558
9eba9da4 LP	559	if (c->ioprio_set)
	560	fprintf(f,
	561	"%sIOSchedulingClass: %s\n"
	562	"%sIOPriority: %i\n",
94f04347	563	prefix, ioprio_class_to_string(IOPRIO_PRIO_CLASS(c->ioprio)),
9eba9da4	564	prefix, (int) IOPRIO_PRIO_DATA(c->ioprio));
94f04347 LP	565
	566	if (c->cpu_sched_set)
	567	fprintf(f,
	568	"%sCPUSchedulingPolicy: %s\n"
38b48754 LP	569	"%sCPUSchedulingPriority: %i\n"
38b48754 LP	570	"%sCPUSchedulingResetOnFork: %s\n",
94f04347	571	prefix, sched_policy_to_string(c->cpu_sched_policy),
38b48754 LP	572	prefix, c->cpu_sched_priority,
38b48754 LP	573	prefix, yes_no(c->cpu_sched_reset_on_fork));
94f04347 LP	574
	575	if (c->cpu_affinity_set) {
	576	fprintf(f, "%sCPUAffinity:", prefix);
	577	for (i = 0; i < CPU_SETSIZE; i++)
	578	if (CPU_ISSET(i, &c->cpu_affinity))
	579	fprintf(f, " %i", i);
	580	fputs("\n", f);
	581	}
	582
	583	if (c->timer_slack_ns_set)
	584	fprintf(f, "%sTimerSlackNS: %lu\n", prefix, c->timer_slack_ns);
	585
	586	fprintf(f,
	587	"%sInput: %s\n"
	588	"%sOutput: %s\n",
	589	prefix, exec_input_to_string(c->input),
	590	prefix, exec_output_to_string(c->output));
	591
	592	if (c->output == EXEC_OUTPUT_SYSLOG \|\| c->output == EXEC_OUTPUT_KERNEL)
	593	fprintf(f,
	594	"%sSyslogFacility: %s\n"
	595	"%sSyslogLevel: %s\n",
	596	prefix, log_facility_to_string(LOG_FAC(c->syslog_priority)),
	597	prefix, log_level_to_string(LOG_PRI(c->syslog_priority)));
	598
	599	if (c->capabilities) {
	600	char *t;
	601	if ((t = cap_to_text(c->capabilities, NULL))) {
	602	fprintf(f, "%sCapabilities: %s\n",
	603	prefix, t);
	604	cap_free(t);
	605	}
	606	}
	607
	608	if (c->secure_bits)
	609	fprintf(f, "%sSecure Bits:%s%s%s%s%s%s\n",
	610	prefix,
	611	(c->secure_bits & SECURE_KEEP_CAPS) ? " keep-caps" : "",
	612	(c->secure_bits & SECURE_KEEP_CAPS_LOCKED) ? " keep-caps-locked" : "",
	613	(c->secure_bits & SECURE_NO_SETUID_FIXUP) ? " no-setuid-fixup" : "",
	614	(c->secure_bits & SECURE_NO_SETUID_FIXUP_LOCKED) ? " no-setuid-fixup-locked" : "",
	615	(c->secure_bits & SECURE_NOROOT) ? " noroot" : "",
	616	(c->secure_bits & SECURE_NOROOT_LOCKED) ? "noroot-locked" : "");
	617
	618	if (c->capability_bounding_set_drop) {
	619	fprintf(f, "%sCapabilityBoundingSetDrop:", prefix);
	620
	621	for (i = 0; i <= CAP_LAST_CAP; i++)
	622	if (c->capability_bounding_set_drop & (1 << i)) {
	623	char *t;
	624
	625	if ((t = cap_to_name(i))) {
	626	fprintf(f, " %s", t);
	627	free(t);
	628	}
	629	}
	630
	631	fputs("\n", f);
	632	}
	633
	634	if (c->user)
	635	fprintf(f, "%sUser: %s", prefix, c->user);
	636	if (c->group)
	637	fprintf(f, "%sGroup: %s", prefix, c->group);
638
639	if (c->supplementary_groups) {
640	char **g;
641
642	fprintf(f, "%sSupplementaryGroups:", prefix);
643
644	STRV_FOREACH(g, c->supplementary_groups)
645	fprintf(f, " %s", *g);
646
647	fputs("\n", f);
648	}
5cb5a6ff LP	649	}
5cb5a6ff LP	650
034c6ed7 LP	651	void exec_status_fill(ExecStatus *s, pid_t pid, int code, int status) {
034c6ed7 LP	652	assert(s);
5cb5a6ff	653
034c6ed7 LP	654	s->pid = pid;
	655	s->code = code;
	656	s->status = status;
	657	s->timestamp = now(CLOCK_REALTIME);
5cb5a6ff	658	}
44d8db9e LP	659
	660	char exec_command_line(ExecCommand c) {
	661	size_t k;
	662	char n, p, **a;
	663	bool first = true;
	664
	665	assert(c);
	666	assert(c->argv);
	667
9164977d	668	k = 1;
44d8db9e LP	669	STRV_FOREACH(a, c->argv)
	670	k += strlen(*a)+3;
	671
	672	if (!(n = new(char, k)))
	673	return NULL;
	674
	675	p = n;
	676	STRV_FOREACH(a, c->argv) {
	677
	678	if (!first)
	679	*(p++) = ' ';
	680	else
	681	first = false;
	682
	683	if (strpbrk(*a, WHITESPACE)) {
	684	*(p++) = '\'';
	685	p = stpcpy(p, *a);
	686	*(p++) = '\'';
	687	} else
	688	p = stpcpy(p, *a);
	689
	690	}
	691
9164977d LP	692	*p = 0;
9164977d LP	693
44d8db9e LP	694	/* FIXME: this doesn't really handle arguments that have
	695	* spaces and ticks in them */
	696
	697	return n;
	698	}
	699
	700	void exec_command_dump(ExecCommand c, FILE f, const char *prefix) {
	701	char *cmd;
	702
	703	assert(c);
	704	assert(f);
	705
	706	if (!prefix)
	707	prefix = "";
	708
	709	cmd = exec_command_line(c);
	710
	711	fprintf(f,
	712	"%sCommand Line: %s\n",
	713	prefix, cmd ? cmd : strerror(ENOMEM));
	714
	715	free(cmd);
	716	}
	717
	718	void exec_command_dump_list(ExecCommand c, FILE f, const char *prefix) {
	719	assert(f);
	720
	721	if (!prefix)
	722	prefix = "";
	723
	724	LIST_FOREACH(command, c, c)
	725	exec_command_dump(c, f, prefix);
	726	}
94f04347 LP	727
	728	static const char* const exec_output_table[_EXEC_OUTPUT_MAX] = {
	729	[EXEC_OUTPUT_CONSOLE] = "console",
	730	[EXEC_OUTPUT_NULL] = "null",
	731	[EXEC_OUTPUT_SYSLOG] = "syslog",
	732	[EXEC_OUTPUT_KERNEL] = "kernel"
	733	};
	734
	735	DEFINE_STRING_TABLE_LOOKUP(exec_output, ExecOutput);
	736
	737	static const char* const exec_input_table[_EXEC_INPUT_MAX] = {
	738	[EXEC_INPUT_NULL] = "null",
	739	[EXEC_INPUT_CONSOLE] = "console"
	740	};
	741
	742	DEFINE_STRING_TABLE_LOOKUP(exec_input, ExecInput);