[thirdparty/systemd.git] / src / core / dbus-execute.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <sys/prctl.h>

#include "bus-util.h"
#include "missing.h"
#include "ioprio.h"
#include "strv.h"
#include "syscall-list.h"
#include "fileio.h"
#include "execute.h"
#include "dbus-execute.h"
#include "capability.h"

BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_exec_output, exec_output, ExecOutput);

static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exec_input, exec_input, ExecInput);

static int property_get_environment_files(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        ExecContext *c = userdata;
        char **j;
        int r;

        assert(bus);
        assert(reply);
        assert(c);

        r = sd_bus_message_open_container(reply, 'a', "(sb)");
        if (r < 0)
                return r;

        STRV_FOREACH(j, c->environment_files) {
                const char *fn = *j;

                r = sd_bus_message_append(reply, "(sb)", fn[0] == '-' ? fn + 1 : fn, fn[0] == '-');
                if (r < 0)
                        return r;
        }

        return sd_bus_message_close_container(reply);
}

static int property_get_rlimit(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        struct rlimit *rl;
        uint64_t u;

        assert(bus);
        assert(reply);
        assert(userdata);

        rl = *(struct rlimit**) userdata;
        if (rl)
                u = (uint64_t) rl->rlim_max;
        else {
                struct rlimit buf = {};
                int z;

                z = rlimit_from_string(property);
                assert(z >= 0);

                getrlimit(z, &buf);

                u = (uint64_t) buf.rlim_max;
        }

        return sd_bus_message_append(reply, "t", u);
}

static int property_get_oom_score_adjust(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {


        ExecContext *c = userdata;
        int32_t n;

        assert(bus);
        assert(reply);
        assert(c);

        if (c->oom_score_adjust_set)
                n = c->oom_score_adjust;
        else {
                _cleanup_free_ char *t = NULL;

                n = 0;
                if (read_one_line_file("/proc/self/oom_score_adj", &t) >= 0)
                        safe_atoi(t, &n);
        }

        return sd_bus_message_append(reply, "i", n);
}

static int property_get_nice(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {


        ExecContext *c = userdata;
        int32_t n;

        assert(bus);
        assert(reply);
        assert(c);

        if (c->nice_set)
                n = c->nice;
        else {
                errno = 0;
                n = getpriority(PRIO_PROCESS, 0);
                if (errno != 0)
                        n = 0;
        }

        return sd_bus_message_append(reply, "i", n);
}

static int property_get_ioprio(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {


        ExecContext *c = userdata;
        int32_t n;

        assert(bus);
        assert(reply);
        assert(c);

        if (c->ioprio_set)
                n = c->ioprio;
        else {
                n = ioprio_get(IOPRIO_WHO_PROCESS, 0);
                if (n < 0)
                        n = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 4);
        }

        return sd_bus_message_append(reply, "i", n);
}

static int property_get_cpu_sched_policy(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        ExecContext *c = userdata;
        int32_t n;

        assert(bus);
        assert(reply);
        assert(c);

        if (c->cpu_sched_set)
                n = c->cpu_sched_policy;
        else {
                n = sched_getscheduler(0);
                if (n < 0)
                        n = SCHED_OTHER;
        }

        return sd_bus_message_append(reply, "i", n);
}

static int property_get_cpu_sched_priority(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        ExecContext *c = userdata;
        int32_t n;

        assert(bus);
        assert(reply);
        assert(c);

        if (c->cpu_sched_set)
                n = c->cpu_sched_priority;
        else {
                struct sched_param p = {};

                if (sched_getparam(0, &p) >= 0)
                        n = p.sched_priority;
                else
                        n = 0;
        }

        return sd_bus_message_append(reply, "i", n);
}

static int property_get_cpu_affinity(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        ExecContext *c = userdata;

        assert(bus);
        assert(reply);
        assert(c);

        if (c->cpuset)
                return sd_bus_message_append_array(reply, 'y', c->cpuset, CPU_ALLOC_SIZE(c->cpuset_ncpus));
        else
                return sd_bus_message_append_array(reply, 'y', NULL, 0);
}

static int property_get_timer_slack_nsec(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        ExecContext *c = userdata;
        uint64_t u;

        assert(bus);
        assert(reply);
        assert(c);

        if (c->timer_slack_nsec != (nsec_t) -1)
                u = (uint64_t) c->timer_slack_nsec;
        else
                u = (uint64_t) prctl(PR_GET_TIMERSLACK);

        return sd_bus_message_append(reply, "t", u);
}

static int property_get_capability_bounding_set(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        ExecContext *c = userdata;

        assert(bus);
        assert(reply);
        assert(c);

        /* We store this negated internally, to match the kernel, but
         * we expose it normalized. */
        return sd_bus_message_append(reply, "t", ~c->capability_bounding_set_drop);
}

static int property_get_capabilities(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        ExecContext *c = userdata;
        _cleanup_cap_free_charp_ char *t = NULL;
        const char *s;

        assert(bus);
        assert(reply);
        assert(c);

        if (c->capabilities)
                s = t = cap_to_text(c->capabilities, NULL);
        else
                s = "";

        if (!s)
                return -ENOMEM;

        return sd_bus_message_append(reply, "s", s);
}

static int property_get_syscall_filter(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        ExecContext *c = userdata;

        assert(bus);
        assert(reply);
        assert(c);

        if (c->syscall_filter)
                return sd_bus_message_append_array(reply, 'u', c->syscall_filter, (syscall_max() + 31) >> 4);
        else
                return sd_bus_message_append_array(reply, 'u', NULL, 0);
}

const sd_bus_vtable bus_exec_vtable[] = {
        SD_BUS_VTABLE_START(0),
        SD_BUS_PROPERTY("Environment", "as", NULL, offsetof(ExecContext, environment), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("EnvironmentFiles", "a(sb)", property_get_environment_files, 0, SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("UMask", "u", bus_property_get_mode, offsetof(ExecContext, umask), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("LimitCPU", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("LimitFSIZE", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("LimitDATA", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("LimitSTACK", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("LimitCORE", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("LimitRSS", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("LimitNOFILE", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("LimitAS", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("LimitNPROC", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("LimitMEMLOCK", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("LimitLOCKS", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("LimitSIGPENDING", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("LimitMSGQUEUE", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("LimitNICE", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("LimitRTPRIO", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("LimitRTTIME", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("WorkingDirectory", "s", NULL, offsetof(ExecContext, working_directory), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("RootDirectory", "s", NULL, offsetof(ExecContext, root_directory), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("OOMScoreAdjust", "i", property_get_oom_score_adjust, 0, SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("Nice", "i", property_get_nice, 0, SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("IOScheduling", "i", property_get_ioprio, 0, SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("CPUSchedulingPolicy", "i", property_get_cpu_sched_policy, 0, SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("CPUSchedulingPriority", "i", property_get_cpu_sched_priority, 0, SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("CPUAffinity", "ay", property_get_cpu_affinity, 0, SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec, 0, SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("CPUSchedulingResetOnFork", "b", bus_property_get_bool, offsetof(ExecContext, cpu_sched_reset_on_fork), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("NonBlocking", "b", bus_property_get_bool, offsetof(ExecContext, non_blocking), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("StandardInput", "s", property_get_exec_input, offsetof(ExecContext, std_input), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("StandardOutput", "s", bus_property_get_exec_output, offsetof(ExecContext, std_output), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("StandardError", "s", bus_property_get_exec_output, offsetof(ExecContext, std_error), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("TTYPath", "s", NULL, offsetof(ExecContext, tty_path), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("TTYReset", "b", bus_property_get_bool, offsetof(ExecContext, tty_reset), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("TTYVHangup", "b", bus_property_get_bool, offsetof(ExecContext, tty_vhangup), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("TTYVTDisallocate", "b", bus_property_get_bool, offsetof(ExecContext, tty_vt_disallocate), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("SyslogPriority", "i", bus_property_get_int, offsetof(ExecContext, syslog_priority), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("SyslogIdentifier", "s", NULL, offsetof(ExecContext, syslog_identifier), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("SyslogLevelPrefix", "b", bus_property_get_bool, offsetof(ExecContext, syslog_level_prefix), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("Capabilities", "s", property_get_capabilities, 0, SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("SecureBits", "i", bus_property_get_int, offsetof(ExecContext, secure_bits), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("CapabilityBoundingSet", "t", property_get_capability_bounding_set, 0, SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("User", "s", NULL, offsetof(ExecContext, user), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("Group", "s", NULL, offsetof(ExecContext, group), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("SupplementaryGroups", "as", NULL, offsetof(ExecContext, supplementary_groups), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("TCPWrapName", "s", NULL, offsetof(ExecContext, tcpwrap_name), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("PAMName", "s", NULL, offsetof(ExecContext, pam_name), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("ReadWriteDirectories", "as", NULL, offsetof(ExecContext, read_write_dirs), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("ReadOnlyDirectories", "as", NULL, offsetof(ExecContext, read_only_dirs), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("InaccessibleDirectories", "as", NULL, offsetof(ExecContext, inaccessible_dirs), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("MountFlags", "t", bus_property_get_ulong, offsetof(ExecContext, mount_flags), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("PrivateTmp", "b", bus_property_get_bool, offsetof(ExecContext, private_tmp), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("PrivateNetwork", "b", bus_property_get_bool, offsetof(ExecContext, private_network), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("PrivateDevices", "b", bus_property_get_bool, offsetof(ExecContext, private_devices), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("SameProcessGroup", "b", bus_property_get_bool, offsetof(ExecContext, same_pgrp), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("UtmpIdentifier", "s", NULL, offsetof(ExecContext, utmp_id), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("IgnoreSIGPIPE", "b", bus_property_get_bool, offsetof(ExecContext, ignore_sigpipe), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("NoNewPrivileges", "b", bus_property_get_bool, offsetof(ExecContext, no_new_privileges), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("SystemCallFilter", "au", property_get_syscall_filter, 0, SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_VTABLE_END
};

static int append_exec_command(sd_bus_message *reply, ExecCommand *c) {
        int r;

        assert(reply);
        assert(c);

        if (!c->path)
                return 0;

        r = sd_bus_message_open_container(reply, 'r', "sasbttttuii");
        if (r < 0)
                return r;

        r = sd_bus_message_append(reply, "s", c->path);
        if (r < 0)
                return r;

        r = sd_bus_message_append_strv(reply, c->argv);
        if (r < 0)
                return r;

        r = sd_bus_message_append(reply, "bttttuii",
                                  c->ignore,
                                  c->exec_status.start_timestamp.realtime,
                                  c->exec_status.start_timestamp.monotonic,
                                  c->exec_status.exit_timestamp.realtime,
                                  c->exec_status.exit_timestamp.monotonic,
                                  (uint32_t) c->exec_status.pid,
                                  (int32_t) c->exec_status.code,
                                  (int32_t) c->exec_status.status);
        if (r < 0)
                return r;

        return sd_bus_message_close_container(reply);
}

int bus_property_get_exec_command(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *ret_error) {

        ExecCommand *c = (ExecCommand*) userdata;
        int r;

        assert(bus);
        assert(reply);

        r = sd_bus_message_open_container(reply, 'a', "(sasbttttuii)");
        if (r < 0)
                return r;

        r = append_exec_command(reply, c);
        if (r < 0)
                return r;

        return sd_bus_message_close_container(reply);
}

int bus_property_get_exec_command_list(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *ret_error) {

        ExecCommand *c = *(ExecCommand**) userdata;
        int r;

        assert(bus);
        assert(reply);

        r = sd_bus_message_open_container(reply, 'a', "(sasbttttuii)");
        if (r < 0)
                return r;

        LIST_FOREACH(command, c, c) {
                r = append_exec_command(reply, c);
                if (r < 0)
                        return r;
        }

        return sd_bus_message_close_container(reply);
}
Commit	Line	Data
d6c9574f	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
4139c1b2 LP	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2010 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
5430f7f2 LP	9	under the terms of the GNU Lesser General Public License as published by
5430f7f2 LP	10	the Free Software Foundation; either version 2.1 of the License, or
4139c1b2 LP	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
5430f7f2	16	Lesser General Public License for more details.
4139c1b2	17
5430f7f2	18	You should have received a copy of the GNU Lesser General Public License
4139c1b2 LP	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
82c121a4	22	#include <sys/prctl.h>
4139c1b2	23
718db961	24	#include "bus-util.h"
82c121a4 LP	25	#include "missing.h"
82c121a4 LP	26	#include "ioprio.h"
fe68089d	27	#include "strv.h"
8351ceae	28	#include "syscall-list.h"
a5c32cff	29	#include "fileio.h"
718db961 LP	30	#include "execute.h"
718db961 LP	31	#include "dbus-execute.h"
5ce70e5b	32	#include "capability.h"
4139c1b2	33
718db961	34	BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_exec_output, exec_output, ExecOutput);
82c121a4	35
718db961	36	static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exec_input, exec_input, ExecInput);
8c7be95e	37
718db961 LP	38	static int property_get_environment_files(
	39	sd_bus *bus,
	40	const char *path,
	41	const char *interface,
	42	const char *property,
	43	sd_bus_message *reply,
ebcf1f97 LP	44	void *userdata,
ebcf1f97 LP	45	sd_bus_error *error) {
8c7be95e	46
718db961 LP	47	ExecContext *c = userdata;
	48	char **j;
	49	int r;
8c7be95e	50
718db961 LP	51	assert(bus);
	52	assert(reply);
	53	assert(c);
	54
	55	r = sd_bus_message_open_container(reply, 'a', "(sb)");
	56	if (r < 0)
	57	return r;
8c7be95e	58
718db961 LP	59	STRV_FOREACH(j, c->environment_files) {
718db961 LP	60	const char fn = j;
8c7be95e	61
718db961 LP	62	r = sd_bus_message_append(reply, "(sb)", fn[0] == '-' ? fn + 1 : fn, fn[0] == '-');
	63	if (r < 0)
	64	return r;
8c7be95e LP	65	}
8c7be95e LP	66
718db961 LP	67	return sd_bus_message_close_container(reply);
	68	}
	69
	70	static int property_get_rlimit(
	71	sd_bus *bus,
	72	const char *path,
	73	const char *interface,
	74	const char *property,
	75	sd_bus_message *reply,
ebcf1f97 LP	76	void *userdata,
ebcf1f97 LP	77	sd_bus_error *error) {
718db961 LP	78
	79	struct rlimit *rl;
	80	uint64_t u;
	81
	82	assert(bus);
	83	assert(reply);
	84	assert(userdata);
8c7be95e	85
718db961 LP	86	rl = (struct rlimit*) userdata;
	87	if (rl)
	88	u = (uint64_t) rl->rlim_max;
	89	else {
	90	struct rlimit buf = {};
	91	int z;
	92
	93	z = rlimit_from_string(property);
	94	assert(z >= 0);
	95
	96	getrlimit(z, &buf);
	97
	98	u = (uint64_t) buf.rlim_max;
	99	}
	100
	101	return sd_bus_message_append(reply, "t", u);
8c7be95e LP	102	}
8c7be95e LP	103
718db961 LP	104	static int property_get_oom_score_adjust(
	105	sd_bus *bus,
	106	const char *path,
	107	const char *interface,
	108	const char *property,
	109	sd_bus_message *reply,
ebcf1f97 LP	110	void *userdata,
ebcf1f97 LP	111	sd_bus_error *error) {
718db961 LP	112
	113
	114	ExecContext *c = userdata;
82c121a4 LP	115	int32_t n;
82c121a4 LP	116
718db961 LP	117	assert(bus);
718db961 LP	118	assert(reply);
82c121a4 LP	119	assert(c);
82c121a4 LP	120
dd6c17b1 LP	121	if (c->oom_score_adjust_set)
dd6c17b1 LP	122	n = c->oom_score_adjust;
82c121a4	123	else {
68eda4bd	124	_cleanup_free_ char *t = NULL;
82c121a4 LP	125
82c121a4 LP	126	n = 0;
718db961	127	if (read_one_line_file("/proc/self/oom_score_adj", &t) >= 0)
82c121a4	128	safe_atoi(t, &n);
82c121a4 LP	129	}
82c121a4 LP	130
718db961	131	return sd_bus_message_append(reply, "i", n);
82c121a4 LP	132	}
82c121a4 LP	133
718db961 LP	134	static int property_get_nice(
	135	sd_bus *bus,
	136	const char *path,
	137	const char *interface,
	138	const char *property,
	139	sd_bus_message *reply,
ebcf1f97 LP	140	void *userdata,
ebcf1f97 LP	141	sd_bus_error *error) {
718db961 LP	142
	143
	144	ExecContext *c = userdata;
82c121a4 LP	145	int32_t n;
82c121a4 LP	146
718db961 LP	147	assert(bus);
718db961 LP	148	assert(reply);
82c121a4 LP	149	assert(c);
	150
	151	if (c->nice_set)
	152	n = c->nice;
718db961 LP	153	else {
718db961 LP	154	errno = 0;
82c121a4	155	n = getpriority(PRIO_PROCESS, 0);
718db961 LP	156	if (errno != 0)
	157	n = 0;
	158	}
82c121a4	159
718db961	160	return sd_bus_message_append(reply, "i", n);
82c121a4 LP	161	}
82c121a4 LP	162
718db961 LP	163	static int property_get_ioprio(
	164	sd_bus *bus,
	165	const char *path,
	166	const char *interface,
	167	const char *property,
	168	sd_bus_message *reply,
ebcf1f97 LP	169	void *userdata,
ebcf1f97 LP	170	sd_bus_error *error) {
718db961 LP	171
	172
	173	ExecContext *c = userdata;
82c121a4 LP	174	int32_t n;
82c121a4 LP	175
718db961 LP	176	assert(bus);
718db961 LP	177	assert(reply);
82c121a4 LP	178	assert(c);
	179
	180	if (c->ioprio_set)
	181	n = c->ioprio;
718db961	182	else {
82c121a4	183	n = ioprio_get(IOPRIO_WHO_PROCESS, 0);
718db961 LP	184	if (n < 0)
	185	n = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 4);
	186	}
82c121a4	187
718db961	188	return sd_bus_message_append(reply, "i", n);
82c121a4 LP	189	}
82c121a4 LP	190
718db961 LP	191	static int property_get_cpu_sched_policy(
	192	sd_bus *bus,
	193	const char *path,
	194	const char *interface,
	195	const char *property,
	196	sd_bus_message *reply,
ebcf1f97 LP	197	void *userdata,
ebcf1f97 LP	198	sd_bus_error *error) {
718db961 LP	199
718db961 LP	200	ExecContext *c = userdata;
82c121a4 LP	201	int32_t n;
82c121a4 LP	202
718db961 LP	203	assert(bus);
718db961 LP	204	assert(reply);
82c121a4 LP	205	assert(c);
	206
	207	if (c->cpu_sched_set)
	208	n = c->cpu_sched_policy;
718db961	209	else {
82c121a4	210	n = sched_getscheduler(0);
718db961 LP	211	if (n < 0)
	212	n = SCHED_OTHER;
	213	}
82c121a4	214
718db961	215	return sd_bus_message_append(reply, "i", n);
82c121a4 LP	216	}
82c121a4 LP	217
718db961 LP	218	static int property_get_cpu_sched_priority(
	219	sd_bus *bus,
	220	const char *path,
	221	const char *interface,
	222	const char *property,
	223	sd_bus_message *reply,
ebcf1f97 LP	224	void *userdata,
ebcf1f97 LP	225	sd_bus_error *error) {
718db961 LP	226
718db961 LP	227	ExecContext *c = userdata;
82c121a4 LP	228	int32_t n;
82c121a4 LP	229
718db961 LP	230	assert(bus);
718db961 LP	231	assert(reply);
82c121a4 LP	232	assert(c);
	233
	234	if (c->cpu_sched_set)
	235	n = c->cpu_sched_priority;
	236	else {
b92bea5d	237	struct sched_param p = {};
82c121a4	238
82c121a4 LP	239	if (sched_getparam(0, &p) >= 0)
82c121a4 LP	240	n = p.sched_priority;
e62d8c39 ZJS	241	else
e62d8c39 ZJS	242	n = 0;
82c121a4 LP	243	}
82c121a4 LP	244
718db961	245	return sd_bus_message_append(reply, "i", n);
82c121a4 LP	246	}
82c121a4 LP	247
718db961 LP	248	static int property_get_cpu_affinity(
	249	sd_bus *bus,
	250	const char *path,
	251	const char *interface,
	252	const char *property,
	253	sd_bus_message *reply,
ebcf1f97 LP	254	void *userdata,
ebcf1f97 LP	255	sd_bus_error *error) {
82c121a4	256
718db961	257	ExecContext *c = userdata;
82c121a4	258
718db961 LP	259	assert(bus);
	260	assert(reply);
	261	assert(c);
82c121a4 LP	262
82c121a4 LP	263	if (c->cpuset)
718db961	264	return sd_bus_message_append_array(reply, 'y', c->cpuset, CPU_ALLOC_SIZE(c->cpuset_ncpus));
82c121a4	265	else
718db961	266	return sd_bus_message_append_array(reply, 'y', NULL, 0);
82c121a4 LP	267	}
82c121a4 LP	268
718db961 LP	269	static int property_get_timer_slack_nsec(
	270	sd_bus *bus,
	271	const char *path,
	272	const char *interface,
	273	const char *property,
	274	sd_bus_message *reply,
ebcf1f97 LP	275	void *userdata,
ebcf1f97 LP	276	sd_bus_error *error) {
718db961 LP	277
718db961 LP	278	ExecContext *c = userdata;
82c121a4 LP	279	uint64_t u;
82c121a4 LP	280
718db961 LP	281	assert(bus);
718db961 LP	282	assert(reply);
82c121a4 LP	283	assert(c);
82c121a4 LP	284
d88a251b	285	if (c->timer_slack_nsec != (nsec_t) -1)
03fae018	286	u = (uint64_t) c->timer_slack_nsec;
82c121a4 LP	287	else
	288	u = (uint64_t) prctl(PR_GET_TIMERSLACK);
	289
718db961	290	return sd_bus_message_append(reply, "t", u);
82c121a4 LP	291	}
82c121a4 LP	292
718db961 LP	293	static int property_get_capability_bounding_set(
	294	sd_bus *bus,
	295	const char *path,
	296	const char *interface,
	297	const char *property,
	298	sd_bus_message *reply,
ebcf1f97 LP	299	void *userdata,
ebcf1f97 LP	300	sd_bus_error *error) {
260abb78	301
718db961 LP	302	ExecContext *c = userdata;
	303
	304	assert(bus);
	305	assert(reply);
260abb78 LP	306	assert(c);
260abb78 LP	307
7c3d67ef	308	/* We store this negated internally, to match the kernel, but
260abb78	309	* we expose it normalized. */
718db961	310	return sd_bus_message_append(reply, "t", ~c->capability_bounding_set_drop);
260abb78 LP	311	}
260abb78 LP	312
718db961 LP	313	static int property_get_capabilities(
	314	sd_bus *bus,
	315	const char *path,
	316	const char *interface,
	317	const char *property,
	318	sd_bus_message *reply,
ebcf1f97 LP	319	void *userdata,
ebcf1f97 LP	320	sd_bus_error *error) {
718db961 LP	321
718db961 LP	322	ExecContext *c = userdata;
5ce70e5b	323	_cleanup_cap_free_charp_ char *t = NULL;
82c121a4	324	const char *s;
82c121a4	325
718db961 LP	326	assert(bus);
718db961 LP	327	assert(reply);
82c121a4 LP	328	assert(c);
	329
	330	if (c->capabilities)
	331	s = t = cap_to_text(c->capabilities, NULL);
	332	else
	333	s = "";
	334
674cdd19	335	if (!s)
82c121a4 LP	336	return -ENOMEM;
82c121a4 LP	337
5ce70e5b	338	return sd_bus_message_append(reply, "s", s);
82c121a4 LP	339	}
82c121a4 LP	340
718db961 LP	341	static int property_get_syscall_filter(
	342	sd_bus *bus,
	343	const char *path,
	344	const char *interface,
	345	const char *property,
	346	sd_bus_message *reply,
ebcf1f97 LP	347	void *userdata,
ebcf1f97 LP	348	sd_bus_error *error) {
82c121a4	349
718db961	350	ExecContext *c = userdata;
82c121a4	351
718db961 LP	352	assert(bus);
	353	assert(reply);
	354	assert(c);
82c121a4	355
718db961 LP	356	if (c->syscall_filter)
	357	return sd_bus_message_append_array(reply, 'u', c->syscall_filter, (syscall_max() + 31) >> 4);
	358	else
	359	return sd_bus_message_append_array(reply, 'u', NULL, 0);
	360	}
82c121a4	361
718db961 LP	362	const sd_bus_vtable bus_exec_vtable[] = {
718db961 LP	363	SD_BUS_VTABLE_START(0),
556089dc LP	364	SD_BUS_PROPERTY("Environment", "as", NULL, offsetof(ExecContext, environment), SD_BUS_VTABLE_PROPERTY_CONST),
	365	SD_BUS_PROPERTY("EnvironmentFiles", "a(sb)", property_get_environment_files, 0, SD_BUS_VTABLE_PROPERTY_CONST),
	366	SD_BUS_PROPERTY("UMask", "u", bus_property_get_mode, offsetof(ExecContext, umask), SD_BUS_VTABLE_PROPERTY_CONST),
	367	SD_BUS_PROPERTY("LimitCPU", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
	368	SD_BUS_PROPERTY("LimitFSIZE", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
	369	SD_BUS_PROPERTY("LimitDATA", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
	370	SD_BUS_PROPERTY("LimitSTACK", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
	371	SD_BUS_PROPERTY("LimitCORE", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
	372	SD_BUS_PROPERTY("LimitRSS", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
	373	SD_BUS_PROPERTY("LimitNOFILE", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
	374	SD_BUS_PROPERTY("LimitAS", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
	375	SD_BUS_PROPERTY("LimitNPROC", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
	376	SD_BUS_PROPERTY("LimitMEMLOCK", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
	377	SD_BUS_PROPERTY("LimitLOCKS", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
	378	SD_BUS_PROPERTY("LimitSIGPENDING", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
	379	SD_BUS_PROPERTY("LimitMSGQUEUE", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
	380	SD_BUS_PROPERTY("LimitNICE", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
	381	SD_BUS_PROPERTY("LimitRTPRIO", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
	382	SD_BUS_PROPERTY("LimitRTTIME", "t", property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
	383	SD_BUS_PROPERTY("WorkingDirectory", "s", NULL, offsetof(ExecContext, working_directory), SD_BUS_VTABLE_PROPERTY_CONST),
	384	SD_BUS_PROPERTY("RootDirectory", "s", NULL, offsetof(ExecContext, root_directory), SD_BUS_VTABLE_PROPERTY_CONST),
	385	SD_BUS_PROPERTY("OOMScoreAdjust", "i", property_get_oom_score_adjust, 0, SD_BUS_VTABLE_PROPERTY_CONST),
	386	SD_BUS_PROPERTY("Nice", "i", property_get_nice, 0, SD_BUS_VTABLE_PROPERTY_CONST),
	387	SD_BUS_PROPERTY("IOScheduling", "i", property_get_ioprio, 0, SD_BUS_VTABLE_PROPERTY_CONST),
	388	SD_BUS_PROPERTY("CPUSchedulingPolicy", "i", property_get_cpu_sched_policy, 0, SD_BUS_VTABLE_PROPERTY_CONST),
	389	SD_BUS_PROPERTY("CPUSchedulingPriority", "i", property_get_cpu_sched_priority, 0, SD_BUS_VTABLE_PROPERTY_CONST),
	390	SD_BUS_PROPERTY("CPUAffinity", "ay", property_get_cpu_affinity, 0, SD_BUS_VTABLE_PROPERTY_CONST),
	391	SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec, 0, SD_BUS_VTABLE_PROPERTY_CONST),
	392	SD_BUS_PROPERTY("CPUSchedulingResetOnFork", "b", bus_property_get_bool, offsetof(ExecContext, cpu_sched_reset_on_fork), SD_BUS_VTABLE_PROPERTY_CONST),
	393	SD_BUS_PROPERTY("NonBlocking", "b", bus_property_get_bool, offsetof(ExecContext, non_blocking), SD_BUS_VTABLE_PROPERTY_CONST),
	394	SD_BUS_PROPERTY("StandardInput", "s", property_get_exec_input, offsetof(ExecContext, std_input), SD_BUS_VTABLE_PROPERTY_CONST),
	395	SD_BUS_PROPERTY("StandardOutput", "s", bus_property_get_exec_output, offsetof(ExecContext, std_output), SD_BUS_VTABLE_PROPERTY_CONST),
	396	SD_BUS_PROPERTY("StandardError", "s", bus_property_get_exec_output, offsetof(ExecContext, std_error), SD_BUS_VTABLE_PROPERTY_CONST),
	397	SD_BUS_PROPERTY("TTYPath", "s", NULL, offsetof(ExecContext, tty_path), SD_BUS_VTABLE_PROPERTY_CONST),
	398	SD_BUS_PROPERTY("TTYReset", "b", bus_property_get_bool, offsetof(ExecContext, tty_reset), SD_BUS_VTABLE_PROPERTY_CONST),
	399	SD_BUS_PROPERTY("TTYVHangup", "b", bus_property_get_bool, offsetof(ExecContext, tty_vhangup), SD_BUS_VTABLE_PROPERTY_CONST),
	400	SD_BUS_PROPERTY("TTYVTDisallocate", "b", bus_property_get_bool, offsetof(ExecContext, tty_vt_disallocate), SD_BUS_VTABLE_PROPERTY_CONST),
	401	SD_BUS_PROPERTY("SyslogPriority", "i", bus_property_get_int, offsetof(ExecContext, syslog_priority), SD_BUS_VTABLE_PROPERTY_CONST),
	402	SD_BUS_PROPERTY("SyslogIdentifier", "s", NULL, offsetof(ExecContext, syslog_identifier), SD_BUS_VTABLE_PROPERTY_CONST),
	403	SD_BUS_PROPERTY("SyslogLevelPrefix", "b", bus_property_get_bool, offsetof(ExecContext, syslog_level_prefix), SD_BUS_VTABLE_PROPERTY_CONST),
	404	SD_BUS_PROPERTY("Capabilities", "s", property_get_capabilities, 0, SD_BUS_VTABLE_PROPERTY_CONST),
	405	SD_BUS_PROPERTY("SecureBits", "i", bus_property_get_int, offsetof(ExecContext, secure_bits), SD_BUS_VTABLE_PROPERTY_CONST),
	406	SD_BUS_PROPERTY("CapabilityBoundingSet", "t", property_get_capability_bounding_set, 0, SD_BUS_VTABLE_PROPERTY_CONST),
	407	SD_BUS_PROPERTY("User", "s", NULL, offsetof(ExecContext, user), SD_BUS_VTABLE_PROPERTY_CONST),
	408	SD_BUS_PROPERTY("Group", "s", NULL, offsetof(ExecContext, group), SD_BUS_VTABLE_PROPERTY_CONST),
	409	SD_BUS_PROPERTY("SupplementaryGroups", "as", NULL, offsetof(ExecContext, supplementary_groups), SD_BUS_VTABLE_PROPERTY_CONST),
	410	SD_BUS_PROPERTY("TCPWrapName", "s", NULL, offsetof(ExecContext, tcpwrap_name), SD_BUS_VTABLE_PROPERTY_CONST),
	411	SD_BUS_PROPERTY("PAMName", "s", NULL, offsetof(ExecContext, pam_name), SD_BUS_VTABLE_PROPERTY_CONST),
	412	SD_BUS_PROPERTY("ReadWriteDirectories", "as", NULL, offsetof(ExecContext, read_write_dirs), SD_BUS_VTABLE_PROPERTY_CONST),
	413	SD_BUS_PROPERTY("ReadOnlyDirectories", "as", NULL, offsetof(ExecContext, read_only_dirs), SD_BUS_VTABLE_PROPERTY_CONST),
	414	SD_BUS_PROPERTY("InaccessibleDirectories", "as", NULL, offsetof(ExecContext, inaccessible_dirs), SD_BUS_VTABLE_PROPERTY_CONST),
	415	SD_BUS_PROPERTY("MountFlags", "t", bus_property_get_ulong, offsetof(ExecContext, mount_flags), SD_BUS_VTABLE_PROPERTY_CONST),
	416	SD_BUS_PROPERTY("PrivateTmp", "b", bus_property_get_bool, offsetof(ExecContext, private_tmp), SD_BUS_VTABLE_PROPERTY_CONST),
	417	SD_BUS_PROPERTY("PrivateNetwork", "b", bus_property_get_bool, offsetof(ExecContext, private_network), SD_BUS_VTABLE_PROPERTY_CONST),
7f112f50	418	SD_BUS_PROPERTY("PrivateDevices", "b", bus_property_get_bool, offsetof(ExecContext, private_devices), SD_BUS_VTABLE_PROPERTY_CONST),
556089dc LP	419	SD_BUS_PROPERTY("SameProcessGroup", "b", bus_property_get_bool, offsetof(ExecContext, same_pgrp), SD_BUS_VTABLE_PROPERTY_CONST),
	420	SD_BUS_PROPERTY("UtmpIdentifier", "s", NULL, offsetof(ExecContext, utmp_id), SD_BUS_VTABLE_PROPERTY_CONST),
	421	SD_BUS_PROPERTY("IgnoreSIGPIPE", "b", bus_property_get_bool, offsetof(ExecContext, ignore_sigpipe), SD_BUS_VTABLE_PROPERTY_CONST),
	422	SD_BUS_PROPERTY("NoNewPrivileges", "b", bus_property_get_bool, offsetof(ExecContext, no_new_privileges), SD_BUS_VTABLE_PROPERTY_CONST),
	423	SD_BUS_PROPERTY("SystemCallFilter", "au", property_get_syscall_filter, 0, SD_BUS_VTABLE_PROPERTY_CONST),
718db961 LP	424	SD_BUS_VTABLE_END
718db961 LP	425	};
82c121a4	426
4d4c80d0 LP	427	static int append_exec_command(sd_bus_message reply, ExecCommand c) {
	428	int r;
	429
	430	assert(reply);
	431	assert(c);
	432
	433	if (!c->path)
	434	return 0;
	435
	436	r = sd_bus_message_open_container(reply, 'r', "sasbttttuii");
	437	if (r < 0)
	438	return r;
	439
	440	r = sd_bus_message_append(reply, "s", c->path);
	441	if (r < 0)
	442	return r;
	443
	444	r = sd_bus_message_append_strv(reply, c->argv);
	445	if (r < 0)
	446	return r;
	447
	448	r = sd_bus_message_append(reply, "bttttuii",
	449	c->ignore,
	450	c->exec_status.start_timestamp.realtime,
	451	c->exec_status.start_timestamp.monotonic,
	452	c->exec_status.exit_timestamp.realtime,
	453	c->exec_status.exit_timestamp.monotonic,
	454	(uint32_t) c->exec_status.pid,
	455	(int32_t) c->exec_status.code,
	456	(int32_t) c->exec_status.status);
	457	if (r < 0)
	458	return r;
	459
	460	return sd_bus_message_close_container(reply);
	461	}
	462
718db961 LP	463	int bus_property_get_exec_command(
	464	sd_bus *bus,
	465	const char *path,
	466	const char *interface,
	467	const char *property,
	468	sd_bus_message *reply,
ebcf1f97 LP	469	void *userdata,
ebcf1f97 LP	470	sd_bus_error *ret_error) {
fe68089d	471
4d4c80d0	472	ExecCommand c = (ExecCommand) userdata;
718db961	473	int r;
fe68089d	474
718db961 LP	475	assert(bus);
718db961 LP	476	assert(reply);
fe68089d	477
718db961 LP	478	r = sd_bus_message_open_container(reply, 'a', "(sasbttttuii)");
	479	if (r < 0)
	480	return r;
fe68089d	481
4d4c80d0 LP	482	r = append_exec_command(reply, c);
	483	if (r < 0)
	484	return r;
fe68089d	485
4d4c80d0 LP	486	return sd_bus_message_close_container(reply);
4d4c80d0 LP	487	}
718db961	488
4d4c80d0 LP	489	int bus_property_get_exec_command_list(
	490	sd_bus *bus,
	491	const char *path,
	492	const char *interface,
	493	const char *property,
	494	sd_bus_message *reply,
	495	void *userdata,
	496	sd_bus_error *ret_error) {
718db961	497
4d4c80d0 LP	498	ExecCommand c = (ExecCommand**) userdata;
4d4c80d0 LP	499	int r;
718db961	500
4d4c80d0 LP	501	assert(bus);
	502	assert(reply);
	503
	504	r = sd_bus_message_open_container(reply, 'a', "(sasbttttuii)");
	505	if (r < 0)
	506	return r;
718db961	507
4d4c80d0 LP	508	LIST_FOREACH(command, c, c) {
4d4c80d0 LP	509	r = append_exec_command(reply, c);
718db961 LP	510	if (r < 0)
718db961 LP	511	return r;
fe68089d LP	512	}
fe68089d LP	513
718db961	514	return sd_bus_message_close_container(reply);
8351ceae	515	}