[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 General Public License as published by
  the Free Software Foundation; either version 2 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
  General Public License for more details.

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

#include <errno.h>
#include <dbus/dbus.h>
#include <sys/prctl.h>

#include "dbus-execute.h"
#include "missing.h"
#include "ioprio.h"
#include "strv.h"
#include "dbus-common.h"

DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_execute_append_kill_mode, kill_mode, KillMode);

DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_execute_append_input, exec_input, ExecInput);
DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_execute_append_output, exec_output, ExecOutput);

int bus_execute_append_env_files(DBusMessageIter *i, const char *property, void *data) {
        char **env_files = data, **j;
        DBusMessageIter sub, sub2;

        assert(i);
        assert(property);

        if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "(sb)", &sub))
                return -ENOMEM;

        STRV_FOREACH(j, env_files) {
                dbus_bool_t b = false;
                char *fn = *j;

                if (fn[0] == '-') {
                        b = true;
                        fn++;
                }

                if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &fn) ||
                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_BOOLEAN, &b) ||
                    !dbus_message_iter_close_container(&sub, &sub2))
                        return -ENOMEM;
        }

        if (!dbus_message_iter_close_container(i, &sub))
                return -ENOMEM;

        return 0;
}

int bus_execute_append_oom_score_adjust(DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        int32_t n;

        assert(i);
        assert(property);
        assert(c);

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

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

                        if (n == OOM_ADJUST_MAX)
                                n = OOM_SCORE_ADJ_MAX;
                        else
                                n = (n * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE;
                }
        }

        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
                return -ENOMEM;

        return 0;
}

int bus_execute_append_nice(DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        int32_t n;

        assert(i);
        assert(property);
        assert(c);

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

        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
                return -ENOMEM;

        return 0;
}

int bus_execute_append_ioprio(DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        int32_t n;

        assert(i);
        assert(property);
        assert(c);

        if (c->ioprio_set)
                n = c->ioprio;
        else
                n = ioprio_get(IOPRIO_WHO_PROCESS, 0);

        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
                return -ENOMEM;

        return 0;
}

int bus_execute_append_cpu_sched_policy(DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        int32_t n;

        assert(i);
        assert(property);
        assert(c);

        if (c->cpu_sched_set)
                n = c->cpu_sched_policy;
        else
                n = sched_getscheduler(0);

        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
                return -ENOMEM;

        return 0;
}

int bus_execute_append_cpu_sched_priority(DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        int32_t n;

        assert(i);
        assert(property);
        assert(c);

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

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

        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
                return -ENOMEM;

        return 0;
}

int bus_execute_append_affinity(DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        dbus_bool_t b;
        DBusMessageIter sub;

        assert(i);
        assert(property);
        assert(c);

        if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "y", &sub))
                return -ENOMEM;

        if (c->cpuset)
                b = dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &c->cpuset, CPU_ALLOC_SIZE(c->cpuset_ncpus));
        else
                b = dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &c->cpuset, 0);

        if (!b)
                return -ENOMEM;

        if (!dbus_message_iter_close_container(i, &sub))
                return -ENOMEM;

        return 0;
}

int bus_execute_append_timer_slack_nsec(DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        uint64_t u;

        assert(i);
        assert(property);
        assert(c);

        if (c->timer_slack_nsec_set)
                u = (uint64_t) c->timer_slack_nsec;
        else
                u = (uint64_t) prctl(PR_GET_TIMERSLACK);

        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u))
                return -ENOMEM;

        return 0;
}

int bus_execute_append_capability_bs(DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        uint64_t normal, inverted;

        assert(i);
        assert(property);
        assert(c);

        /* We store this negated internally, to match the kernel, but
         * we expose it normalized. */

        normal = *(uint64_t*) data;
        inverted = ~normal;

        return bus_property_append_uint64(i, property, &inverted);
}

int bus_execute_append_capabilities(DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        char *t = NULL;
        const char *s;
        dbus_bool_t b;

        assert(i);
        assert(property);
        assert(c);

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

        if (!s)
                return -ENOMEM;

        b = dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &s);

        if (t)
                cap_free(t);

        if (!b)
                return -ENOMEM;

        return 0;
}

int bus_execute_append_rlimits(DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        int r;
        uint64_t u;

        assert(i);
        assert(property);
        assert(c);

        assert_se((r = rlimit_from_string(property)) >= 0);

        if (c->rlimit[r])
                u = (uint64_t) c->rlimit[r]->rlim_max;
        else {
                struct rlimit rl;

                zero(rl);
                getrlimit(r, &rl);

                u = (uint64_t) rl.rlim_max;
        }

        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u))
                return -ENOMEM;

        return 0;
}

int bus_execute_append_command(DBusMessageIter *i, const char *property, void *data) {
        ExecCommand *c = data;
        DBusMessageIter sub, sub2, sub3;

        assert(i);
        assert(property);

        if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "(sasbttttuii)", &sub))
                return -ENOMEM;

        LIST_FOREACH(command, c, c) {
                char **l;
                uint32_t pid;
                int32_t code, status;
                dbus_bool_t b;

                if (!c->path)
                        continue;

                if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &c->path) ||
                    !dbus_message_iter_open_container(&sub2, DBUS_TYPE_ARRAY, "s", &sub3))
                        return -ENOMEM;

                STRV_FOREACH(l, c->argv)
                        if (!dbus_message_iter_append_basic(&sub3, DBUS_TYPE_STRING, l))
                                return -ENOMEM;

                pid = (uint32_t) c->exec_status.pid;
                code = (int32_t) c->exec_status.code;
                status = (int32_t) c->exec_status.status;

                b = !!c->ignore;

                if (!dbus_message_iter_close_container(&sub2, &sub3) ||
                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_BOOLEAN, &b) ||
                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT64, &c->exec_status.start_timestamp.realtime) ||
                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT64, &c->exec_status.start_timestamp.monotonic) ||
                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT64, &c->exec_status.exit_timestamp.realtime) ||
                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT64, &c->exec_status.exit_timestamp.monotonic) ||
                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &pid) ||
                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_INT32, &code) ||
                    !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_INT32, &status))
                        return -ENOMEM;

                if (!dbus_message_iter_close_container(&sub, &sub2))
                        return -ENOMEM;
        }

        if (!dbus_message_iter_close_container(i, &sub))
                return -ENOMEM;

        return 0;
}

const BusProperty bus_exec_context_properties[] = {
        { "Environment",              bus_property_append_strv,             "as", offsetof(ExecContext, environment),            true },
        { "EnvironmentFiles",         bus_execute_append_env_files,      "a(sb)", offsetof(ExecContext, environment_files),      true },
        { "UMask",                    bus_property_append_mode,              "u", offsetof(ExecContext, umask)                        },
        { "LimitCPU",                 bus_execute_append_rlimits,            "t", 0 },
        { "LimitFSIZE",               bus_execute_append_rlimits,            "t", 0 },
        { "LimitDATA",                bus_execute_append_rlimits,            "t", 0 },
        { "LimitSTACK",               bus_execute_append_rlimits,            "t", 0 },
        { "LimitCORE",                bus_execute_append_rlimits,            "t", 0 },
        { "LimitRSS",                 bus_execute_append_rlimits,            "t", 0 },
        { "LimitNOFILE",              bus_execute_append_rlimits,            "t", 0 },
        { "LimitAS",                  bus_execute_append_rlimits,            "t", 0 },
        { "LimitNPROC",               bus_execute_append_rlimits,            "t", 0 },
        { "LimitMEMLOCK",             bus_execute_append_rlimits,            "t", 0 },
        { "LimitLOCKS",               bus_execute_append_rlimits,            "t", 0 },
        { "LimitSIGPENDING",          bus_execute_append_rlimits,            "t", 0 },
        { "LimitMSGQUEUE",            bus_execute_append_rlimits,            "t", 0 },
        { "LimitNICE",                bus_execute_append_rlimits,            "t", 0 },
        { "LimitRTPRIO",              bus_execute_append_rlimits,            "t", 0 },
        { "LimitRTTIME",              bus_execute_append_rlimits,            "t", 0 },
        { "WorkingDirectory",         bus_property_append_string,            "s", offsetof(ExecContext, working_directory),      true },
        { "RootDirectory",            bus_property_append_string,            "s", offsetof(ExecContext, root_directory),         true },
        { "OOMScoreAdjust",           bus_execute_append_oom_score_adjust,   "i", 0 },
        { "Nice",                     bus_execute_append_nice,               "i", 0 },
        { "IOScheduling",             bus_execute_append_ioprio,             "i", 0 },
        { "CPUSchedulingPolicy",      bus_execute_append_cpu_sched_policy,   "i", 0 },
        { "CPUSchedulingPriority",    bus_execute_append_cpu_sched_priority, "i", 0 },
        { "CPUAffinity",              bus_execute_append_affinity,          "ay", 0 },
        { "TimerSlackNSec",           bus_execute_append_timer_slack_nsec,   "t", 0 },
        { "CPUSchedulingResetOnFork", bus_property_append_bool,              "b", offsetof(ExecContext, cpu_sched_reset_on_fork)      },
        { "NonBlocking",              bus_property_append_bool,              "b", offsetof(ExecContext, non_blocking)                 },
        { "StandardInput",            bus_execute_append_input,              "s", offsetof(ExecContext, std_input)                    },
        { "StandardOutput",           bus_execute_append_output,             "s", offsetof(ExecContext, std_output)                   },
        { "StandardError",            bus_execute_append_output,             "s", offsetof(ExecContext, std_error)                    },
        { "TTYPath",                  bus_property_append_string,            "s", offsetof(ExecContext, tty_path),               true },
        { "TTYReset",                 bus_property_append_bool,              "b", offsetof(ExecContext, tty_reset)                    },
        { "TTYVHangup",               bus_property_append_bool,              "b", offsetof(ExecContext, tty_vhangup)                  },
        { "TTYVTDisallocate",         bus_property_append_bool,              "b", offsetof(ExecContext, tty_vt_disallocate)           },
        { "SyslogPriority",           bus_property_append_int,               "i", offsetof(ExecContext, syslog_priority)              },
        { "SyslogIdentifier",         bus_property_append_string,            "s", offsetof(ExecContext, syslog_identifier),      true },
        { "SyslogLevelPrefix",        bus_property_append_bool,              "b", offsetof(ExecContext, syslog_level_prefix)          },
        { "Capabilities",             bus_execute_append_capabilities,       "s", 0 },
        { "SecureBits",               bus_property_append_int,               "i", offsetof(ExecContext, secure_bits)                  },
        { "CapabilityBoundingSet",    bus_execute_append_capability_bs,      "t", offsetof(ExecContext, capability_bounding_set_drop) },
        { "User",                     bus_property_append_string,            "s", offsetof(ExecContext, user),                   true },
        { "Group",                    bus_property_append_string,            "s", offsetof(ExecContext, group),                  true },
        { "SupplementaryGroups",      bus_property_append_strv,             "as", offsetof(ExecContext, supplementary_groups),   true },
        { "TCPWrapName",              bus_property_append_string,            "s", offsetof(ExecContext, tcpwrap_name),           true },
        { "PAMName",                  bus_property_append_string,            "s", offsetof(ExecContext, pam_name),               true },
        { "ReadWriteDirectories",     bus_property_append_strv,             "as", offsetof(ExecContext, read_write_dirs),        true },
        { "ReadOnlyDirectories",      bus_property_append_strv,             "as", offsetof(ExecContext, read_only_dirs),         true },
        { "InaccessibleDirectories",  bus_property_append_strv,             "as", offsetof(ExecContext, inaccessible_dirs),      true },
        { "MountFlags",               bus_property_append_ul,                "t", offsetof(ExecContext, mount_flags)                  },
        { "PrivateTmp",               bus_property_append_bool,              "b", offsetof(ExecContext, private_tmp)                  },
        { "PrivateNetwork",           bus_property_append_bool,              "b", offsetof(ExecContext, private_network)              },
        { "SameProcessGroup",         bus_property_append_bool,              "b", offsetof(ExecContext, same_pgrp)                    },
        { "KillMode",                 bus_execute_append_kill_mode,          "s", offsetof(ExecContext, kill_mode)                    },
        { "KillSignal",               bus_property_append_int,               "i", offsetof(ExecContext, kill_signal)                  },
        { "UtmpIdentifier",           bus_property_append_string,            "s", offsetof(ExecContext, utmp_id),                true },
        { "ControlGroupModify",       bus_property_append_bool,              "b", offsetof(ExecContext, control_group_modify)         },
        { "ControlGroupPersistent",   bus_property_append_tristate_false,    "b", offsetof(ExecContext, control_group_persistent)     },
        { "IgnoreSIGPIPE",            bus_property_append_bool,              "b", offsetof(ExecContext, ignore_sigpipe          )     },
        { NULL, }
};
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
	9	under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	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
	16	General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <errno.h>
	23	#include <dbus/dbus.h>
82c121a4	24	#include <sys/prctl.h>
4139c1b2 LP	25
4139c1b2 LP	26	#include "dbus-execute.h"
82c121a4 LP	27	#include "missing.h"
82c121a4 LP	28	#include "ioprio.h"
fe68089d	29	#include "strv.h"
bfebab7f	30	#include "dbus-common.h"
4139c1b2	31
2e22afe9 LP	32	DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_execute_append_kill_mode, kill_mode, KillMode);
2e22afe9 LP	33
4139c1b2 LP	34	DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_execute_append_input, exec_input, ExecInput);
4139c1b2 LP	35	DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_execute_append_output, exec_output, ExecOutput);
82c121a4	36
bfebab7f	37	int bus_execute_append_env_files(DBusMessageIter i, const char property, void *data) {
8c7be95e LP	38	char env_files = data, j;
	39	DBusMessageIter sub, sub2;
	40
8c7be95e LP	41	assert(i);
	42	assert(property);
	43
	44	if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "(sb)", &sub))
	45	return -ENOMEM;
	46
	47	STRV_FOREACH(j, env_files) {
	48	dbus_bool_t b = false;
	49	char fn = j;
	50
	51	if (fn[0] == '-') {
	52	b = true;
	53	fn++;
	54	}
	55
	56	if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) \|\|
	57	!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &fn) \|\|
	58	!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_BOOLEAN, &b) \|\|
	59	!dbus_message_iter_close_container(&sub, &sub2))
	60	return -ENOMEM;
	61	}
	62
	63	if (!dbus_message_iter_close_container(i, &sub))
	64	return -ENOMEM;
	65
	66	return 0;
	67	}
	68
bfebab7f	69	int bus_execute_append_oom_score_adjust(DBusMessageIter i, const char property, void *data) {
82c121a4 LP	70	ExecContext *c = data;
	71	int32_t n;
	72
82c121a4 LP	73	assert(i);
	74	assert(property);
	75	assert(c);
	76
dd6c17b1 LP	77	if (c->oom_score_adjust_set)
dd6c17b1 LP	78	n = c->oom_score_adjust;
82c121a4 LP	79	else {
	80	char *t;
	81
	82	n = 0;
dd6c17b1	83	if (read_one_line_file("/proc/self/oom_score_adj", &t) >= 0) {
82c121a4 LP	84	safe_atoi(t, &n);
82c121a4 LP	85	free(t);
dd6c17b1 LP	86	} else if (read_one_line_file("/proc/self/oom_adj", &t) >= 0) {
	87	safe_atoi(t, &n);
	88	free(t);
	89
	90	if (n == OOM_ADJUST_MAX)
	91	n = OOM_SCORE_ADJ_MAX;
	92	else
	93	n = (n * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE;
82c121a4 LP	94	}
	95	}
	96
	97	if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
	98	return -ENOMEM;
	99
	100	return 0;
	101	}
	102
bfebab7f	103	int bus_execute_append_nice(DBusMessageIter i, const char property, void *data) {
82c121a4 LP	104	ExecContext *c = data;
	105	int32_t n;
	106
82c121a4 LP	107	assert(i);
	108	assert(property);
	109	assert(c);
	110
	111	if (c->nice_set)
	112	n = c->nice;
	113	else
	114	n = getpriority(PRIO_PROCESS, 0);
	115
	116	if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
	117	return -ENOMEM;
	118
	119	return 0;
	120	}
	121
bfebab7f	122	int bus_execute_append_ioprio(DBusMessageIter i, const char property, void *data) {
82c121a4 LP	123	ExecContext *c = data;
	124	int32_t n;
	125
82c121a4 LP	126	assert(i);
	127	assert(property);
	128	assert(c);
	129
	130	if (c->ioprio_set)
	131	n = c->ioprio;
	132	else
	133	n = ioprio_get(IOPRIO_WHO_PROCESS, 0);
	134
	135	if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
	136	return -ENOMEM;
	137
	138	return 0;
	139	}
	140
bfebab7f	141	int bus_execute_append_cpu_sched_policy(DBusMessageIter i, const char property, void *data) {
82c121a4 LP	142	ExecContext *c = data;
	143	int32_t n;
	144
82c121a4 LP	145	assert(i);
	146	assert(property);
	147	assert(c);
	148
	149	if (c->cpu_sched_set)
	150	n = c->cpu_sched_policy;
	151	else
	152	n = sched_getscheduler(0);
	153
	154	if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
	155	return -ENOMEM;
	156
	157	return 0;
	158	}
	159
bfebab7f	160	int bus_execute_append_cpu_sched_priority(DBusMessageIter i, const char property, void *data) {
82c121a4 LP	161	ExecContext *c = data;
	162	int32_t n;
	163
82c121a4 LP	164	assert(i);
	165	assert(property);
	166	assert(c);
	167
	168	if (c->cpu_sched_set)
	169	n = c->cpu_sched_priority;
	170	else {
	171	struct sched_param p;
	172	n = 0;
	173
	174	zero(p);
	175	if (sched_getparam(0, &p) >= 0)
	176	n = p.sched_priority;
	177	}
	178
	179	if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
	180	return -ENOMEM;
	181
	182	return 0;
	183	}
	184
bfebab7f	185	int bus_execute_append_affinity(DBusMessageIter i, const char property, void *data) {
82c121a4 LP	186	ExecContext *c = data;
	187	dbus_bool_t b;
	188	DBusMessageIter sub;
	189
82c121a4 LP	190	assert(i);
	191	assert(property);
	192	assert(c);
	193
fe68089d	194	if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "y", &sub))
82c121a4 LP	195	return -ENOMEM;
	196
	197	if (c->cpuset)
	198	b = dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &c->cpuset, CPU_ALLOC_SIZE(c->cpuset_ncpus));
	199	else
	200	b = dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &c->cpuset, 0);
	201
	202	if (!b)
	203	return -ENOMEM;
	204
	205	if (!dbus_message_iter_close_container(i, &sub))
	206	return -ENOMEM;
	207
	208	return 0;
	209	}
	210
bfebab7f	211	int bus_execute_append_timer_slack_nsec(DBusMessageIter i, const char property, void *data) {
82c121a4 LP	212	ExecContext *c = data;
	213	uint64_t u;
	214
82c121a4 LP	215	assert(i);
	216	assert(property);
	217	assert(c);
	218
03fae018 LP	219	if (c->timer_slack_nsec_set)
03fae018 LP	220	u = (uint64_t) c->timer_slack_nsec;
82c121a4 LP	221	else
	222	u = (uint64_t) prctl(PR_GET_TIMERSLACK);
	223
	224	if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u))
	225	return -ENOMEM;
	226
	227	return 0;
	228	}
	229
bfebab7f	230	int bus_execute_append_capability_bs(DBusMessageIter i, const char property, void *data) {
260abb78 LP	231	ExecContext *c = data;
	232	uint64_t normal, inverted;
	233
260abb78 LP	234	assert(i);
	235	assert(property);
	236	assert(c);
	237
7c3d67ef	238	/* We store this negated internally, to match the kernel, but
260abb78 LP	239	* we expose it normalized. */
	240
	241	normal = (uint64_t) data;
	242	inverted = ~normal;
	243
bfebab7f	244	return bus_property_append_uint64(i, property, &inverted);
260abb78 LP	245	}
260abb78 LP	246
bfebab7f	247	int bus_execute_append_capabilities(DBusMessageIter i, const char property, void *data) {
82c121a4 LP	248	ExecContext *c = data;
	249	char *t = NULL;
	250	const char *s;
	251	dbus_bool_t b;
	252
82c121a4 LP	253	assert(i);
	254	assert(property);
	255	assert(c);
	256
	257	if (c->capabilities)
	258	s = t = cap_to_text(c->capabilities, NULL);
	259	else
	260	s = "";
	261
674cdd19	262	if (!s)
82c121a4 LP	263	return -ENOMEM;
	264
	265	b = dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &s);
674cdd19 LP	266
	267	if (t)
	268	cap_free(t);
82c121a4 LP	269
	270	if (!b)
	271	return -ENOMEM;
	272
	273	return 0;
	274	}
	275
bfebab7f	276	int bus_execute_append_rlimits(DBusMessageIter i, const char property, void *data) {
82c121a4 LP	277	ExecContext *c = data;
	278	int r;
	279	uint64_t u;
	280
82c121a4 LP	281	assert(i);
	282	assert(property);
	283	assert(c);
	284
	285	assert_se((r = rlimit_from_string(property)) >= 0);
	286
	287	if (c->rlimit[r])
	288	u = (uint64_t) c->rlimit[r]->rlim_max;
	289	else {
	290	struct rlimit rl;
	291
	292	zero(rl);
	293	getrlimit(r, &rl);
	294
	295	u = (uint64_t) rl.rlim_max;
	296	}
	297
	298	if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u))
	299	return -ENOMEM;
	300
	301	return 0;
	302	}
fe68089d	303
bfebab7f	304	int bus_execute_append_command(DBusMessageIter i, const char property, void *data) {
fe68089d LP	305	ExecCommand *c = data;
	306	DBusMessageIter sub, sub2, sub3;
	307
fe68089d LP	308	assert(i);
	309	assert(property);
	310
7daa9e6e	311	if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "(sasbttttuii)", &sub))
fe68089d LP	312	return -ENOMEM;
	313
	314	LIST_FOREACH(command, c, c) {
	315	char **l;
	316	uint32_t pid;
	317	int32_t code, status;
7daa9e6e	318	dbus_bool_t b;
fe68089d LP	319
	320	if (!c->path)
	321	continue;
	322
	323	if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) \|\|
	324	!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &c->path) \|\|
	325	!dbus_message_iter_open_container(&sub2, DBUS_TYPE_ARRAY, "s", &sub3))
	326	return -ENOMEM;
	327
	328	STRV_FOREACH(l, c->argv)
	329	if (!dbus_message_iter_append_basic(&sub3, DBUS_TYPE_STRING, l))
	330	return -ENOMEM;
	331
	332	pid = (uint32_t) c->exec_status.pid;
	333	code = (int32_t) c->exec_status.code;
	334	status = (int32_t) c->exec_status.status;
	335
7daa9e6e LP	336	b = !!c->ignore;
7daa9e6e LP	337
fe68089d	338	if (!dbus_message_iter_close_container(&sub2, &sub3) \|\|
7daa9e6e	339	!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_BOOLEAN, &b) \|\|
fe68089d	340	!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT64, &c->exec_status.start_timestamp.realtime) \|\|
b21a0ef8	341	!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT64, &c->exec_status.start_timestamp.monotonic) \|\|
fe68089d	342	!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT64, &c->exec_status.exit_timestamp.realtime) \|\|
b21a0ef8	343	!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT64, &c->exec_status.exit_timestamp.monotonic) \|\|
e364ad06 LP	344	!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &pid) \|\|
	345	!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_INT32, &code) \|\|
	346	!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_INT32, &status))
fe68089d LP	347	return -ENOMEM;
	348
	349	if (!dbus_message_iter_close_container(&sub, &sub2))
	350	return -ENOMEM;
	351	}
	352
	353	if (!dbus_message_iter_close_container(i, &sub))
	354	return -ENOMEM;
	355
	356	return 0;
	357	}
d200735e MS	358
	359	const BusProperty bus_exec_context_properties[] = {
	360	{ "Environment", bus_property_append_strv, "as", offsetof(ExecContext, environment), true },
	361	{ "EnvironmentFiles", bus_execute_append_env_files, "a(sb)", offsetof(ExecContext, environment_files), true },
	362	{ "UMask", bus_property_append_mode, "u", offsetof(ExecContext, umask) },
	363	{ "LimitCPU", bus_execute_append_rlimits, "t", 0 },
	364	{ "LimitFSIZE", bus_execute_append_rlimits, "t", 0 },
	365	{ "LimitDATA", bus_execute_append_rlimits, "t", 0 },
	366	{ "LimitSTACK", bus_execute_append_rlimits, "t", 0 },
	367	{ "LimitCORE", bus_execute_append_rlimits, "t", 0 },
	368	{ "LimitRSS", bus_execute_append_rlimits, "t", 0 },
	369	{ "LimitNOFILE", bus_execute_append_rlimits, "t", 0 },
	370	{ "LimitAS", bus_execute_append_rlimits, "t", 0 },
	371	{ "LimitNPROC", bus_execute_append_rlimits, "t", 0 },
	372	{ "LimitMEMLOCK", bus_execute_append_rlimits, "t", 0 },
	373	{ "LimitLOCKS", bus_execute_append_rlimits, "t", 0 },
	374	{ "LimitSIGPENDING", bus_execute_append_rlimits, "t", 0 },
	375	{ "LimitMSGQUEUE", bus_execute_append_rlimits, "t", 0 },
	376	{ "LimitNICE", bus_execute_append_rlimits, "t", 0 },
	377	{ "LimitRTPRIO", bus_execute_append_rlimits, "t", 0 },
	378	{ "LimitRTTIME", bus_execute_append_rlimits, "t", 0 },
	379	{ "WorkingDirectory", bus_property_append_string, "s", offsetof(ExecContext, working_directory), true },
	380	{ "RootDirectory", bus_property_append_string, "s", offsetof(ExecContext, root_directory), true },
	381	{ "OOMScoreAdjust", bus_execute_append_oom_score_adjust, "i", 0 },
	382	{ "Nice", bus_execute_append_nice, "i", 0 },
	383	{ "IOScheduling", bus_execute_append_ioprio, "i", 0 },
	384	{ "CPUSchedulingPolicy", bus_execute_append_cpu_sched_policy, "i", 0 },
	385	{ "CPUSchedulingPriority", bus_execute_append_cpu_sched_priority, "i", 0 },
	386	{ "CPUAffinity", bus_execute_append_affinity, "ay", 0 },
	387	{ "TimerSlackNSec", bus_execute_append_timer_slack_nsec, "t", 0 },
	388	{ "CPUSchedulingResetOnFork", bus_property_append_bool, "b", offsetof(ExecContext, cpu_sched_reset_on_fork) },
	389	{ "NonBlocking", bus_property_append_bool, "b", offsetof(ExecContext, non_blocking) },
	390	{ "StandardInput", bus_execute_append_input, "s", offsetof(ExecContext, std_input) },
	391	{ "StandardOutput", bus_execute_append_output, "s", offsetof(ExecContext, std_output) },
	392	{ "StandardError", bus_execute_append_output, "s", offsetof(ExecContext, std_error) },
	393	{ "TTYPath", bus_property_append_string, "s", offsetof(ExecContext, tty_path), true },
	394	{ "TTYReset", bus_property_append_bool, "b", offsetof(ExecContext, tty_reset) },
	395	{ "TTYVHangup", bus_property_append_bool, "b", offsetof(ExecContext, tty_vhangup) },
	396	{ "TTYVTDisallocate", bus_property_append_bool, "b", offsetof(ExecContext, tty_vt_disallocate) },
	397	{ "SyslogPriority", bus_property_append_int, "i", offsetof(ExecContext, syslog_priority) },
	398	{ "SyslogIdentifier", bus_property_append_string, "s", offsetof(ExecContext, syslog_identifier), true },
	399	{ "SyslogLevelPrefix", bus_property_append_bool, "b", offsetof(ExecContext, syslog_level_prefix) },
	400	{ "Capabilities", bus_execute_append_capabilities, "s", 0 },
	401	{ "SecureBits", bus_property_append_int, "i", offsetof(ExecContext, secure_bits) },
	402	{ "CapabilityBoundingSet", bus_execute_append_capability_bs, "t", offsetof(ExecContext, capability_bounding_set_drop) },
	403	{ "User", bus_property_append_string, "s", offsetof(ExecContext, user), true },
	404	{ "Group", bus_property_append_string, "s", offsetof(ExecContext, group), true },
	405	{ "SupplementaryGroups", bus_property_append_strv, "as", offsetof(ExecContext, supplementary_groups), true },
	406	{ "TCPWrapName", bus_property_append_string, "s", offsetof(ExecContext, tcpwrap_name), true },
	407	{ "PAMName", bus_property_append_string, "s", offsetof(ExecContext, pam_name), true },
	408	{ "ReadWriteDirectories", bus_property_append_strv, "as", offsetof(ExecContext, read_write_dirs), true },
	409	{ "ReadOnlyDirectories", bus_property_append_strv, "as", offsetof(ExecContext, read_only_dirs), true },
	410	{ "InaccessibleDirectories", bus_property_append_strv, "as", offsetof(ExecContext, inaccessible_dirs), true },
	411	{ "MountFlags", bus_property_append_ul, "t", offsetof(ExecContext, mount_flags) },
	412	{ "PrivateTmp", bus_property_append_bool, "b", offsetof(ExecContext, private_tmp) },
	413	{ "PrivateNetwork", bus_property_append_bool, "b", offsetof(ExecContext, private_network) },
	414	{ "SameProcessGroup", bus_property_append_bool, "b", offsetof(ExecContext, same_pgrp) },
	415	{ "KillMode", bus_execute_append_kill_mode, "s", offsetof(ExecContext, kill_mode) },
	416	{ "KillSignal", bus_property_append_int, "i", offsetof(ExecContext, kill_signal) },
	417	{ "UtmpIdentifier", bus_property_append_string, "s", offsetof(ExecContext, utmp_id), true },
	418	{ "ControlGroupModify", bus_property_append_bool, "b", offsetof(ExecContext, control_group_modify) },
aa001cd6	419	{ "ControlGroupPersistent", bus_property_append_tristate_false, "b", offsetof(ExecContext, control_group_persistent) },
353e12c2	420	{ "IgnoreSIGPIPE", bus_property_append_bool, "b", offsetof(ExecContext, ignore_sigpipe ) },
d200735e MS	421	{ NULL, }
d200735e MS	422	};