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

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

#include <assert.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>

#include "execute.h"
#include "strv.h"
#include "macro.h"
#include "util.h"
#include "log.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;
}

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;
                char t[16];
                sigset_t ss;

                /* child */

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

                umask(context->umask);

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

                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 (setpriority(PRIO_PROCESS, 0, context->nice) < 0) {
                        r = EXIT_NICE;
                        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 (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;
        cap_clear(c->capabilities);
        c->oom_adjust = 0;
        c->nice = 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->directory);
        c->directory = NULL;

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

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

        strv_free(c->supplementary_groups);
        c->supplementary_groups = 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) {
        assert(c);
        assert(f);

        if (!prefix)
                prefix = "";

        fprintf(f,
                "%sUmask: %04o\n"
                "%sDirectory: %s\n"
                "%sNice: %i\n"
                "%sOOMAdjust: %i\n",
                prefix, c->umask,
                prefix, c->directory ? c->directory : "/",
                prefix, c->nice,
                prefix, c->oom_adjust);
}

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);
}
Commit	Line	Data
5cb5a6ff LP	1	/-- Mode: C; c-basic-offset: 8 --/
	2
	3	#include <assert.h>
034c6ed7 LP	4	#include <dirent.h>
	5	#include <errno.h>
	6	#include <fcntl.h>
	7	#include <unistd.h>
44d8db9e	8	#include <string.h>
309bff19	9	#include <signal.h>
5cb5a6ff LP	10
	11	#include "execute.h"
	12	#include "strv.h"
	13	#include "macro.h"
	14	#include "util.h"
acbb0225	15	#include "log.h"
5cb5a6ff	16
034c6ed7 LP	17	static int close_fds(int except[], unsigned n_except) {
	18	DIR *d;
	19	struct dirent *de;
	20	int r = 0;
	21
	22	/* Modifies the fds array! (sorts it) */
	23
	24	if (!(d = opendir("/proc/self/fd")))
	25	return -errno;
	26
	27	while ((de = readdir(d))) {
	28	int fd;
	29
	30	if (de->d_name[0] == '.')
	31	continue;
	32
	33	if ((r = safe_atoi(de->d_name, &fd)) < 0)
	34	goto finish;
	35
	36	if (fd < 3)
	37	continue;
	38
	39	if (fd == dirfd(d))
	40	continue;
	41
	42	if (except) {
	43	bool found;
	44	unsigned i;
	45
	46	found = false;
	47	for (i = 0; i < n_except; i++)
	48	if (except[i] == fd) {
	49	found = true;
	50	break;
	51	}
	52
	53	if (found)
	54	continue;
	55	}
	56
	57	if ((r = close_nointr(fd)) < 0)
	58	goto finish;
	59	}
	60
	61	finish:
	62	closedir(d);
	63	return r;
	64	}
	65
	66	static int shift_fds(int fds[], unsigned n_fds) {
	67	int start, restart_from;
	68
	69	if (n_fds <= 0)
	70	return 0;
	71
	72	assert(fds);
	73
	74	start = 0;
	75	for (;;) {
	76	int i;
	77
	78	restart_from = -1;
	79
	80	for (i = start; i < (int) n_fds; i++) {
81	int nfd;
82
83	/* Already at right index? */
84	if (fds[i] == i+3)
85	continue;
86
87	if ((nfd = fcntl(fds[i], F_DUPFD, i+3)) < 0)
88	return -errno;
89
2da3263a	90	assert_se(close_nointr(fds[i]) == 0);
034c6ed7 LP	91	fds[i] = nfd;
	92
	93	/* Hmm, the fd we wanted isn't free? Then
	94	* let's remember that and try again from here*/
	95	if (nfd != i+3 && restart_from < 0)
	96	restart_from = i;
	97	}
	98
	99	if (restart_from < 0)
	100	break;
	101
	102	start = restart_from;
	103	}
	104
	105	return 0;
	106	}
	107
47a71eed LP	108	static int flags_fds(int fds[], unsigned n_fds) {
	109	unsigned i;
	110
	111	if (n_fds <= 0)
	112	return 0;
	113
	114	assert(fds);
	115
	116	/* Drops O_NONBLOCK and FD_CLOEXEC from the file flags */
	117
	118	for (i = 0; i < n_fds; i++) {
	119	int flags;
	120
	121	if ((flags = fcntl(fds[i], F_GETFL, 0)) < 0)
	122	return -errno;
	123
	124	/* Since we are at it, let's make sure that nobody
	125	* forgot setting O_NONBLOCK for all our fds */
	126
	127	if (fcntl(fds[i], F_SETFL, flags &~O_NONBLOCK) < 0)
	128	return -errno;
	129
	130	if ((flags = fcntl(fds[i], F_GETFD, 0)) < 0)
	131	return -errno;
	132
	133	/* Also make sure nobody forgot O_CLOEXEC for all our
	134	* fds */
	135	if (fcntl(fds[i], F_SETFD, flags &~FD_CLOEXEC) < 0)
	136	return -errno;
	137	}
	138
	139	return 0;
	140	}
	141
034c6ed7 LP	142	int exec_spawn(const ExecCommand command, const ExecContext context, int fds, unsigned n_fds, pid_t ret) {
	143	pid_t pid;
	144
5cb5a6ff LP	145	assert(command);
	146	assert(context);
	147	assert(ret);
034c6ed7 LP	148	assert(fds \|\| n_fds <= 0);
034c6ed7 LP	149
2da3263a	150	log_debug("about to execute %s", command->path);
acbb0225	151
034c6ed7 LP	152	if ((pid = fork()) < 0)
	153	return -errno;
	154
	155	if (pid == 0) {
	156	char e, f = NULL;
	157	int i, r;
	158	char t[16];
309bff19 LP	159	sigset_t ss;
309bff19 LP	160
034c6ed7	161	/* child */
5cb5a6ff	162
309bff19 LP	163	if (sigemptyset(&ss) < 0 \|\|
	164	sigprocmask(SIG_SETMASK, &ss, NULL) < 0) {
	165	r = EXIT_SIGNAL_MASK;
	166	goto fail;
	167	}
	168
034c6ed7 LP	169	umask(context->umask);
	170
	171	if (chdir(context->directory ? context->directory : "/") < 0) {
	172	r = EXIT_CHDIR;
	173	goto fail;
	174	}
	175
	176	snprintf(t, sizeof(t), "%i", context->oom_adjust);
	177	char_array_0(t);
	178
	179	if (write_one_line_file("/proc/self/oom_adj", t) < 0) {
	180	r = EXIT_OOM_ADJUST;
	181	goto fail;
	182	}
	183
	184	if (setpriority(PRIO_PROCESS, 0, context->nice) < 0) {
	185	r = EXIT_NICE;
	186	goto fail;
	187	}
	188
	189	if (close_fds(fds, n_fds) < 0 \|\|
47a71eed LP	190	shift_fds(fds, n_fds) < 0 \|\|
47a71eed LP	191	flags_fds(fds, n_fds) < 0) {
034c6ed7 LP	192	r = EXIT_FDS;
	193	goto fail;
	194	}
	195
	196	for (i = 0; i < RLIMIT_NLIMITS; i++) {
	197	if (!context->rlimit[i])
	198	continue;
	199
	200	if (setrlimit(i, context->rlimit[i]) < 0) {
	201	r = EXIT_LIMITS;
	202	goto fail;
	203	}
	204	}
	205
	206	if (n_fds > 0) {
	207	char a[64], b[64];
	208	char *listen_env[3] = {
	209	a,
	210	b,
	211	NULL
	212	};
	213
	214	snprintf(a, sizeof(a), "LISTEN_PID=%llu", (unsigned long long) getpid());
	215	snprintf(b, sizeof(b), "LISTEN_FDS=%u", n_fds);
	216
	217	a[sizeof(a)-1] = 0;
	218	b[sizeof(b)-1] = 0;
	219
	220	if (context->environment) {
	221	if (!(f = strv_merge(listen_env, context->environment))) {
	222	r = EXIT_MEMORY;
	223	goto fail;
	224	}
	225	e = f;
	226	} else
	227	e = listen_env;
	228
	229	} else
	230	e = context->environment;
	231
	232	execve(command->path, command->argv, e);
	233	r = EXIT_EXEC;
	234
	235	fail:
	236	strv_free(f);
	237	_exit(r);
	238	}
	239
2da3263a LP	240
	241	log_debug("executed %s as %llu", command->path, (unsigned long long) pid);
	242
034c6ed7	243	*ret = pid;
5cb5a6ff LP	244	return 0;
	245	}
	246
034c6ed7 LP	247	void exec_context_init(ExecContext *c) {
	248	assert(c);
	249
	250	c->umask = 0002;
	251	cap_clear(c->capabilities);
	252	c->oom_adjust = 0;
	253	c->nice = 0;
	254	}
	255
	256	void exec_context_done(ExecContext *c) {
5cb5a6ff LP	257	unsigned l;
	258
	259	assert(c);
	260
	261	strv_free(c->environment);
034c6ed7	262	c->environment = NULL;
5cb5a6ff	263
034c6ed7	264	for (l = 0; l < ELEMENTSOF(c->rlimit); l++) {
5cb5a6ff	265	free(c->rlimit[l]);
034c6ed7 LP	266	c->rlimit[l] = NULL;
	267	}
	268
	269	free(c->directory);
	270	c->directory = NULL;
5cb5a6ff	271
5cb5a6ff	272	free(c->user);
034c6ed7 LP	273	c->user = NULL;
034c6ed7 LP	274
5cb5a6ff	275	free(c->group);
034c6ed7 LP	276	c->group = NULL;
	277
	278	strv_free(c->supplementary_groups);
	279	c->supplementary_groups = NULL;
5cb5a6ff LP	280	}
	281
	282	void exec_command_free_list(ExecCommand *c) {
	283	ExecCommand *i;
	284
	285	while ((i = c)) {
034c6ed7	286	LIST_REMOVE(ExecCommand, command, c, i);
5cb5a6ff LP	287
5cb5a6ff LP	288	free(i->path);
44d8db9e	289	strv_free(i->argv);
5cb5a6ff LP	290	free(i);
	291	}
	292	}
	293
034c6ed7 LP	294	void exec_command_free_array(ExecCommand **c, unsigned n) {
	295	unsigned i;
	296
	297	for (i = 0; i < n; i++) {
	298	exec_command_free_list(c[i]);
	299	c[i] = NULL;
	300	}
	301	}
	302
5cb5a6ff LP	303	void exec_context_dump(ExecContext c, FILE f, const char *prefix) {
	304	assert(c);
	305	assert(f);
	306
	307	if (!prefix)
	308	prefix = "";
	309
	310	fprintf(f,
	311	"%sUmask: %04o\n"
034c6ed7 LP	312	"%sDirectory: %s\n"
	313	"%sNice: %i\n"
	314	"%sOOMAdjust: %i\n",
5cb5a6ff	315	prefix, c->umask,
034c6ed7 LP	316	prefix, c->directory ? c->directory : "/",
	317	prefix, c->nice,
	318	prefix, c->oom_adjust);
5cb5a6ff LP	319	}
5cb5a6ff LP	320
034c6ed7 LP	321	void exec_status_fill(ExecStatus *s, pid_t pid, int code, int status) {
034c6ed7 LP	322	assert(s);
5cb5a6ff	323
034c6ed7 LP	324	s->pid = pid;
	325	s->code = code;
	326	s->status = status;
	327	s->timestamp = now(CLOCK_REALTIME);
5cb5a6ff	328	}
44d8db9e LP	329
	330	char exec_command_line(ExecCommand c) {
	331	size_t k;
	332	char n, p, **a;
	333	bool first = true;
	334
	335	assert(c);
	336	assert(c->argv);
	337
9164977d	338	k = 1;
44d8db9e LP	339	STRV_FOREACH(a, c->argv)
	340	k += strlen(*a)+3;
	341
	342	if (!(n = new(char, k)))
	343	return NULL;
	344
	345	p = n;
	346	STRV_FOREACH(a, c->argv) {
	347
	348	if (!first)
	349	*(p++) = ' ';
	350	else
	351	first = false;
	352
	353	if (strpbrk(*a, WHITESPACE)) {
	354	*(p++) = '\'';
	355	p = stpcpy(p, *a);
	356	*(p++) = '\'';
	357	} else
	358	p = stpcpy(p, *a);
	359
	360	}
	361
9164977d LP	362	*p = 0;
9164977d LP	363
44d8db9e LP	364	/* FIXME: this doesn't really handle arguments that have
	365	* spaces and ticks in them */
	366
	367	return n;
	368	}
	369
	370	void exec_command_dump(ExecCommand c, FILE f, const char *prefix) {
	371	char *cmd;
	372
	373	assert(c);
	374	assert(f);
	375
	376	if (!prefix)
	377	prefix = "";
	378
	379	cmd = exec_command_line(c);
	380
	381	fprintf(f,
	382	"%sCommand Line: %s\n",
	383	prefix, cmd ? cmd : strerror(ENOMEM));
	384
	385	free(cmd);
	386	}
	387
	388	void exec_command_dump_list(ExecCommand c, FILE f, const char *prefix) {
	389	assert(f);
	390
	391	if (!prefix)
	392	prefix = "";
	393
	394	LIST_FOREACH(command, c, c)
	395	exec_command_dump(c, f, prefix);
	396	}