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

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include "alloc-util.h"
#include "bus-get-properties.h"
#include "dbus-timer.h"
#include "dbus-util.h"
#include "strv.h"
#include "timer.h"
#include "unit.h"

static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, timer_result, TimerResult);

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

        Timer *t = userdata;
        TimerValue *v;
        int r;

        assert(bus);
        assert(reply);
        assert(t);

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

        LIST_FOREACH(value, v, t->values) {
                _cleanup_free_ char *buf = NULL;
                const char *s;
                size_t l;

                if (v->base == TIMER_CALENDAR)
                        continue;

                s = timer_base_to_string(v->base);
                assert(endswith(s, "Sec"));

                /* s/Sec/USec/ */
                l = strlen(s);
                buf = new(char, l+2);
                if (!buf)
                        return -ENOMEM;

                memcpy(buf, s, l-3);
                memcpy(buf+l-3, "USec", 5);

                r = sd_bus_message_append(reply, "(stt)", buf, v->value, v->next_elapse);
                if (r < 0)
                        return r;
        }

        return sd_bus_message_close_container(reply);
}

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

        Timer *t = userdata;
        TimerValue *v;
        int r;

        assert(bus);
        assert(reply);
        assert(t);

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

        LIST_FOREACH(value, v, t->values) {
                _cleanup_free_ char *buf = NULL;

                if (v->base != TIMER_CALENDAR)
                        continue;

                r = calendar_spec_to_string(v->calendar_spec, &buf);
                if (r < 0)
                        return r;

                r = sd_bus_message_append(reply, "(sst)", timer_base_to_string(v->base), buf, v->next_elapse);
                if (r < 0)
                        return r;
        }

        return sd_bus_message_close_container(reply);
}

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

        Timer *t = userdata;

        assert(bus);
        assert(reply);
        assert(t);

        return sd_bus_message_append(reply, "t",
                                     (uint64_t) usec_shift_clock(t->next_elapse_monotonic_or_boottime,
                                                                 TIMER_MONOTONIC_CLOCK(t), CLOCK_MONOTONIC));
}

const sd_bus_vtable bus_timer_vtable[] = {
        SD_BUS_VTABLE_START(0),
        SD_BUS_PROPERTY("Unit", "s", bus_property_get_triggered_unit, 0, SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("TimersMonotonic", "a(stt)", property_get_monotonic_timers, 0, SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
        SD_BUS_PROPERTY("TimersCalendar", "a(sst)", property_get_calendar_timers, 0, SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
        SD_BUS_PROPERTY("OnClockChange", "b", bus_property_get_bool, offsetof(Timer, on_clock_change), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("OnTimezoneChange", "b", bus_property_get_bool, offsetof(Timer, on_timezone_change), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("NextElapseUSecRealtime", "t", bus_property_get_usec, offsetof(Timer, next_elapse_realtime), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("NextElapseUSecMonotonic", "t", property_get_next_elapse_monotonic, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        BUS_PROPERTY_DUAL_TIMESTAMP("LastTriggerUSec", offsetof(Timer, last_trigger), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Timer, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("AccuracyUSec", "t", bus_property_get_usec, offsetof(Timer, accuracy_usec), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("RandomizedDelayUSec", "t", bus_property_get_usec, offsetof(Timer, random_usec), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("FixedRandomDelay", "b", bus_property_get_bool, offsetof(Timer, fixed_random_delay), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("Persistent", "b", bus_property_get_bool, offsetof(Timer, persistent), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("WakeSystem", "b", bus_property_get_bool, offsetof(Timer, wake_system), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("RemainAfterElapse", "b", bus_property_get_bool, offsetof(Timer, remain_after_elapse), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_VTABLE_END
};

static int timer_add_one_monotonic_spec(
                Timer *t,
                const char *name,
                TimerBase base,
                UnitWriteFlags flags,
                usec_t usec,
                sd_bus_error *error) {

        if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                TimerValue *v;

                unit_write_settingf(UNIT(t), flags|UNIT_ESCAPE_SPECIFIERS, name,
                                    "%s=%s",
                                    timer_base_to_string(base),
                                    FORMAT_TIMESPAN(usec, USEC_PER_MSEC));

                v = new(TimerValue, 1);
                if (!v)
                        return -ENOMEM;

                *v = (TimerValue) {
                        .base = base,
                        .value = usec,
                };

                LIST_PREPEND(value, t->values, v);
        }

        return 1;
}

static int timer_add_one_calendar_spec(
                Timer *t,
                const char *name,
                TimerBase base,
                UnitWriteFlags flags,
                const char *str,
                sd_bus_error *error) {

        _cleanup_(calendar_spec_freep) CalendarSpec *c = NULL;
        int r;

        r = calendar_spec_from_string(str, &c);
        if (r == -EINVAL)
                return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid calendar spec");
        if (r < 0)
                return r;

        if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
                unit_write_settingf(UNIT(t), flags|UNIT_ESCAPE_SPECIFIERS, name,
                                    "%s=%s", timer_base_to_string(base), str);

                TimerValue *v = new(TimerValue, 1);
                if (!v)
                        return -ENOMEM;

                *v = (TimerValue) {
                        .base = base,
                        .calendar_spec = TAKE_PTR(c),
                };

                LIST_PREPEND(value, t->values, v);
        }

        return 1;
};

static int bus_timer_set_transient_property(
                Timer *t,
                const char *name,
                sd_bus_message *message,
                UnitWriteFlags flags,
                sd_bus_error *error) {

        Unit *u = UNIT(t);
        int r;

        assert(t);
        assert(name);
        assert(message);

        flags |= UNIT_PRIVATE;

        if (streq(name, "AccuracyUSec"))
                return bus_set_transient_usec(u, name, &t->accuracy_usec, message, flags, error);

        if (streq(name, "AccuracySec")) {
                log_notice("Client is using obsolete AccuracySec= transient property, please use AccuracyUSec= instead.");
                return bus_set_transient_usec(u, "AccuracyUSec", &t->accuracy_usec, message, flags, error);
        }

        if (streq(name, "RandomizedDelayUSec"))
                return bus_set_transient_usec(u, name, &t->random_usec, message, flags, error);

        if (streq(name, "FixedRandomDelay"))
                return bus_set_transient_bool(u, name, &t->fixed_random_delay, message, flags, error);

        if (streq(name, "WakeSystem"))
                return bus_set_transient_bool(u, name, &t->wake_system, message, flags, error);

        if (streq(name, "Persistent"))
                return bus_set_transient_bool(u, name, &t->persistent, message, flags, error);

        if (streq(name, "RemainAfterElapse"))
                return bus_set_transient_bool(u, name, &t->remain_after_elapse, message, flags, error);

        if (streq(name, "OnTimezoneChange"))
                return bus_set_transient_bool(u, name, &t->on_timezone_change, message, flags, error);

        if (streq(name, "OnClockChange"))
                return bus_set_transient_bool(u, name, &t->on_clock_change, message, flags, error);

        if (streq(name, "TimersMonotonic")) {
                const char *base_name;
                usec_t usec;
                bool empty = true;

                r = sd_bus_message_enter_container(message, 'a', "(st)");
                if (r < 0)
                        return r;

                while ((r = sd_bus_message_read(message, "(st)", &base_name, &usec)) > 0) {
                        TimerBase b;

                        b = timer_base_from_string(base_name);
                        if (b < 0 || b == TIMER_CALENDAR)
                                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
                                                         "Invalid timer base: %s", base_name);

                        r = timer_add_one_monotonic_spec(t, name, b, flags, usec, error);
                        if (r < 0)
                                return r;

                        empty = false;
                }
                if (r < 0)
                        return r;

                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;

                if (!UNIT_WRITE_FLAGS_NOOP(flags) && empty) {
                        timer_free_values(t);
                        unit_write_setting(u, flags, name, "OnActiveSec=");
                }

                return 1;

        } else if (streq(name, "TimersCalendar")) {
                const char *base_name, *str;
                bool empty = true;

                r = sd_bus_message_enter_container(message, 'a', "(ss)");
                if (r < 0)
                        return r;

                while ((r = sd_bus_message_read(message, "(ss)", &base_name, &str)) > 0) {
                        TimerBase b;

                        b = timer_base_from_string(base_name);
                        if (b != TIMER_CALENDAR)
                                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
                                                         "Invalid timer base: %s", base_name);

                        r = timer_add_one_calendar_spec(t, name, b, flags, str, error);
                        if (r < 0)
                                return r;

                        empty = false;
                }
                if (r < 0)
                        return r;

                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;

                if (!UNIT_WRITE_FLAGS_NOOP(flags) && empty) {
                        timer_free_values(t);
                        unit_write_setting(u, flags, name, "OnCalendar=");
                }

                return 1;

        } else if (STR_IN_SET(name,
                       "OnActiveSec",
                       "OnBootSec",
                       "OnStartupSec",
                       "OnUnitActiveSec",
                       "OnUnitInactiveSec")) {

                TimerBase b;
                usec_t usec;

                log_notice("Client is using obsolete %s= transient property, please use TimersMonotonic= instead.", name);

                b = timer_base_from_string(name);
                if (b < 0)
                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown timer base %s", name);

                r = sd_bus_message_read(message, "t", &usec);
                if (r < 0)
                        return r;

                return timer_add_one_monotonic_spec(t, name, b, flags, usec, error);

        } else if (streq(name, "OnCalendar")) {

                const char *str;

                log_notice("Client is using obsolete %s= transient property, please use TimersCalendar= instead.", name);

                r = sd_bus_message_read(message, "s", &str);
                if (r < 0)
                        return r;

                return timer_add_one_calendar_spec(t, name, TIMER_CALENDAR, flags, str, error);
        }

        return 0;
}

int bus_timer_set_property(
                Unit *u,
                const char *name,
                sd_bus_message *message,
                UnitWriteFlags mode,
                sd_bus_error *error) {

        Timer *t = TIMER(u);

        assert(t);
        assert(name);
        assert(message);

        if (u->transient && u->load_state == UNIT_STUB)
                return bus_timer_set_transient_property(t, name, message, mode, error);

        return 0;
}
Commit	Line	Data
db9ecf05	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
871d7de4	2
b5efdb8a	3	#include "alloc-util.h"
40af3d02	4	#include "bus-get-properties.h"
b5efdb8a	5	#include "dbus-timer.h"
3e3c5a45	6	#include "dbus-util.h"
d8a812d1	7	#include "strv.h"
b5efdb8a LP	8	#include "timer.h"
b5efdb8a LP	9	#include "unit.h"
718db961 LP	10
	11	static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, timer_result, TimerResult);
	12
	13	static int property_get_monotonic_timers(
	14	sd_bus *bus,
	15	const char *path,
	16	const char *interface,
	17	const char *property,
	18	sd_bus_message *reply,
ebcf1f97 LP	19	void *userdata,
ebcf1f97 LP	20	sd_bus_error *error) {
718db961 LP	21
	22	Timer *t = userdata;
	23	TimerValue *v;
	24	int r;
	25
	26	assert(bus);
	27	assert(reply);
	28	assert(t);
	29
	30	r = sd_bus_message_open_container(reply, 'a', "(stt)");
	31	if (r < 0)
	32	return r;
	33
	34	LIST_FOREACH(value, v, t->values) {
3761902e	35	_cleanup_free_ char *buf = NULL;
718db961	36	const char *s;
03fae018	37	size_t l;
707e5e52	38
718db961	39	if (v->base == TIMER_CALENDAR)
b719810d	40	continue;
03fae018	41
718db961 LP	42	s = timer_base_to_string(v->base);
718db961 LP	43	assert(endswith(s, "Sec"));
3761902e	44
b719810d	45	/* s/Sec/USec/ */
718db961	46	l = strlen(s);
b719810d LP	47	buf = new(char, l+2);
	48	if (!buf)
	49	return -ENOMEM;
03fae018	50
718db961	51	memcpy(buf, s, l-3);
b719810d	52	memcpy(buf+l-3, "USec", 5);
03fae018	53
718db961 LP	54	r = sd_bus_message_append(reply, "(stt)", buf, v->value, v->next_elapse);
	55	if (r < 0)
	56	return r;
707e5e52 LP	57	}
707e5e52 LP	58
718db961	59	return sd_bus_message_close_container(reply);
707e5e52 LP	60	}
707e5e52 LP	61
718db961 LP	62	static int property_get_calendar_timers(
	63	sd_bus *bus,
	64	const char *path,
	65	const char *interface,
	66	const char *property,
	67	sd_bus_message *reply,
ebcf1f97 LP	68	void *userdata,
ebcf1f97 LP	69	sd_bus_error *error) {
b719810d	70
718db961 LP	71	Timer *t = userdata;
	72	TimerValue *v;
	73	int r;
b719810d	74
718db961 LP	75	assert(bus);
	76	assert(reply);
	77	assert(t);
b719810d	78
718db961 LP	79	r = sd_bus_message_open_container(reply, 'a', "(sst)");
	80	if (r < 0)
	81	return r;
	82
	83	LIST_FOREACH(value, v, t->values) {
b719810d	84	_cleanup_free_ char *buf = NULL;
b719810d	85
718db961	86	if (v->base != TIMER_CALENDAR)
b719810d LP	87	continue;
b719810d LP	88
718db961 LP	89	r = calendar_spec_to_string(v->calendar_spec, &buf);
	90	if (r < 0)
	91	return r;
b719810d	92
718db961 LP	93	r = sd_bus_message_append(reply, "(sst)", timer_base_to_string(v->base), buf, v->next_elapse);
	94	if (r < 0)
	95	return r;
b719810d LP	96	}
b719810d LP	97
718db961	98	return sd_bus_message_close_container(reply);
b719810d LP	99	}
b719810d LP	100
dedabea4 LP	101	static int property_get_next_elapse_monotonic(
	102	sd_bus *bus,
	103	const char *path,
	104	const char *interface,
	105	const char *property,
	106	sd_bus_message *reply,
	107	void *userdata,
	108	sd_bus_error *error) {
	109
	110	Timer *t = userdata;
dedabea4 LP	111
	112	assert(bus);
	113	assert(reply);
	114	assert(t);
	115
79fc8b96 LP	116	return sd_bus_message_append(reply, "t",
	117	(uint64_t) usec_shift_clock(t->next_elapse_monotonic_or_boottime,
	118	TIMER_MONOTONIC_CLOCK(t), CLOCK_MONOTONIC));
dedabea4 LP	119	}
dedabea4 LP	120
718db961 LP	121	const sd_bus_vtable bus_timer_vtable[] = {
718db961 LP	122	SD_BUS_VTABLE_START(0),
54138a8d	123	SD_BUS_PROPERTY("Unit", "s", bus_property_get_triggered_unit, 0, SD_BUS_VTABLE_PROPERTY_CONST),
556089dc LP	124	SD_BUS_PROPERTY("TimersMonotonic", "a(stt)", property_get_monotonic_timers, 0, SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
556089dc LP	125	SD_BUS_PROPERTY("TimersCalendar", "a(sst)", property_get_calendar_timers, 0, SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
efebb613 LP	126	SD_BUS_PROPERTY("OnClockChange", "b", bus_property_get_bool, offsetof(Timer, on_clock_change), SD_BUS_VTABLE_PROPERTY_CONST),
efebb613 LP	127	SD_BUS_PROPERTY("OnTimezoneChange", "b", bus_property_get_bool, offsetof(Timer, on_timezone_change), SD_BUS_VTABLE_PROPERTY_CONST),
454f7158	128	SD_BUS_PROPERTY("NextElapseUSecRealtime", "t", bus_property_get_usec, offsetof(Timer, next_elapse_realtime), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
dedabea4 LP	129	SD_BUS_PROPERTY("NextElapseUSecMonotonic", "t", property_get_next_elapse_monotonic, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
dedabea4 LP	130	BUS_PROPERTY_DUAL_TIMESTAMP("LastTriggerUSec", offsetof(Timer, last_trigger), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
718db961	131	SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Timer, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
556089dc	132	SD_BUS_PROPERTY("AccuracyUSec", "t", bus_property_get_usec, offsetof(Timer, accuracy_usec), SD_BUS_VTABLE_PROPERTY_CONST),
6f5d7998	133	SD_BUS_PROPERTY("RandomizedDelayUSec", "t", bus_property_get_usec, offsetof(Timer, random_usec), SD_BUS_VTABLE_PROPERTY_CONST),
acf24a1a	134	SD_BUS_PROPERTY("FixedRandomDelay", "b", bus_property_get_bool, offsetof(Timer, fixed_random_delay), SD_BUS_VTABLE_PROPERTY_CONST),
06642d17	135	SD_BUS_PROPERTY("Persistent", "b", bus_property_get_bool, offsetof(Timer, persistent), SD_BUS_VTABLE_PROPERTY_CONST),
dedabea4	136	SD_BUS_PROPERTY("WakeSystem", "b", bus_property_get_bool, offsetof(Timer, wake_system), SD_BUS_VTABLE_PROPERTY_CONST),
3e0c30ac	137	SD_BUS_PROPERTY("RemainAfterElapse", "b", bus_property_get_bool, offsetof(Timer, remain_after_elapse), SD_BUS_VTABLE_PROPERTY_CONST),
718db961	138	SD_BUS_VTABLE_END
d200735e	139	};
d8a812d1	140
cd87f634 ZJS	141	static int timer_add_one_monotonic_spec(
	142	Timer *t,
	143	const char *name,
	144	TimerBase base,
	145	UnitWriteFlags flags,
	146	usec_t usec,
	147	sd_bus_error *error) {
	148
	149	if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
cd87f634 ZJS	150	TimerValue *v;
	151
	152	unit_write_settingf(UNIT(t), flags\|UNIT_ESCAPE_SPECIFIERS, name,
	153	"%s=%s",
	154	timer_base_to_string(base),
5291f26d	155	FORMAT_TIMESPAN(usec, USEC_PER_MSEC));
cd87f634 ZJS	156
	157	v = new(TimerValue, 1);
	158	if (!v)
	159	return -ENOMEM;
	160
	161	*v = (TimerValue) {
	162	.base = base,
	163	.value = usec,
	164	};
	165
	166	LIST_PREPEND(value, t->values, v);
	167	}
	168
	169	return 1;
	170	}
	171
d00a52c7 ZJS	172	static int timer_add_one_calendar_spec(
	173	Timer *t,
	174	const char *name,
	175	TimerBase base,
	176	UnitWriteFlags flags,
	177	const char *str,
	178	sd_bus_error *error) {
	179
	180	_cleanup_(calendar_spec_freep) CalendarSpec *c = NULL;
	181	int r;
	182
	183	r = calendar_spec_from_string(str, &c);
	184	if (r == -EINVAL)
1b09b81c	185	return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid calendar spec");
d00a52c7 ZJS	186	if (r < 0)
	187	return r;
	188
	189	if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
	190	unit_write_settingf(UNIT(t), flags\|UNIT_ESCAPE_SPECIFIERS, name,
	191	"%s=%s", timer_base_to_string(base), str);
	192
	193	TimerValue *v = new(TimerValue, 1);
	194	if (!v)
	195	return -ENOMEM;
	196
	197	*v = (TimerValue) {
	198	.base = base,
23f8fbb3	199	.calendar_spec = TAKE_PTR(c),
d00a52c7 ZJS	200	};
	201
	202	LIST_PREPEND(value, t->values, v);
	203	}
	204
	205	return 1;
	206	};
	207
d8a812d1 WC	208	static int bus_timer_set_transient_property(
	209	Timer *t,
	210	const char *name,
	211	sd_bus_message *message,
2e59b241	212	UnitWriteFlags flags,
d8a812d1 WC	213	sd_bus_error *error) {
d8a812d1 WC	214
3e3c5a45	215	Unit *u = UNIT(t);
d8a812d1 WC	216	int r;
	217
	218	assert(t);
	219	assert(name);
	220	assert(message);
	221
2e59b241 LP	222	flags \|= UNIT_PRIVATE;
2e59b241 LP	223
3e3c5a45 YW	224	if (streq(name, "AccuracyUSec"))
	225	return bus_set_transient_usec(u, name, &t->accuracy_usec, message, flags, error);
	226
	227	if (streq(name, "AccuracySec")) {
	228	log_notice("Client is using obsolete AccuracySec= transient property, please use AccuracyUSec= instead.");
	229	return bus_set_transient_usec(u, "AccuracyUSec", &t->accuracy_usec, message, flags, error);
	230	}
	231
	232	if (streq(name, "RandomizedDelayUSec"))
	233	return bus_set_transient_usec(u, name, &t->random_usec, message, flags, error);
	234
acf24a1a KG	235	if (streq(name, "FixedRandomDelay"))
	236	return bus_set_transient_bool(u, name, &t->fixed_random_delay, message, flags, error);
	237
3e3c5a45 YW	238	if (streq(name, "WakeSystem"))
	239	return bus_set_transient_bool(u, name, &t->wake_system, message, flags, error);
	240
	241	if (streq(name, "Persistent"))
	242	return bus_set_transient_bool(u, name, &t->persistent, message, flags, error);
	243
	244	if (streq(name, "RemainAfterElapse"))
	245	return bus_set_transient_bool(u, name, &t->remain_after_elapse, message, flags, error);
	246
efebb613 LP	247	if (streq(name, "OnTimezoneChange"))
	248	return bus_set_transient_bool(u, name, &t->on_timezone_change, message, flags, error);
	249
	250	if (streq(name, "OnClockChange"))
	251	return bus_set_transient_bool(u, name, &t->on_clock_change, message, flags, error);
	252
3e3c5a45 YW	253	if (streq(name, "TimersMonotonic")) {
3e3c5a45 YW	254	const char *base_name;
cd87f634	255	usec_t usec;
3e3c5a45 YW	256	bool empty = true;
	257
	258	r = sd_bus_message_enter_container(message, 'a', "(st)");
	259	if (r < 0)
	260	return r;
	261
	262	while ((r = sd_bus_message_read(message, "(st)", &base_name, &usec)) > 0) {
	263	TimerBase b;
	264
	265	b = timer_base_from_string(base_name);
	266	if (b < 0 \|\| b == TIMER_CALENDAR)
cd87f634 ZJS	267	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
cd87f634 ZJS	268	"Invalid timer base: %s", base_name);
3e3c5a45	269
cd87f634 ZJS	270	r = timer_add_one_monotonic_spec(t, name, b, flags, usec, error);
	271	if (r < 0)
	272	return r;
3e3c5a45 YW	273
	274	empty = false;
	275	}
	276	if (r < 0)
	277	return r;
	278
	279	r = sd_bus_message_exit_container(message);
	280	if (r < 0)
	281	return r;
	282
	283	if (!UNIT_WRITE_FLAGS_NOOP(flags) && empty) {
	284	timer_free_values(t);
	285	unit_write_setting(u, flags, name, "OnActiveSec=");
	286	}
	287
	288	return 1;
	289
	290	} else if (streq(name, "TimersCalendar")) {
	291	const char base_name, str;
	292	bool empty = true;
	293
	294	r = sd_bus_message_enter_container(message, 'a', "(ss)");
	295	if (r < 0)
	296	return r;
	297
	298	while ((r = sd_bus_message_read(message, "(ss)", &base_name, &str)) > 0) {
3e3c5a45 YW	299	TimerBase b;
	300
	301	b = timer_base_from_string(base_name);
	302	if (b != TIMER_CALENDAR)
d00a52c7 ZJS	303	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
d00a52c7 ZJS	304	"Invalid timer base: %s", base_name);
3e3c5a45	305
d00a52c7	306	r = timer_add_one_calendar_spec(t, name, b, flags, str, error);
3e3c5a45 YW	307	if (r < 0)
	308	return r;
	309
3e3c5a45 YW	310	empty = false;
	311	}
	312	if (r < 0)
	313	return r;
	314
	315	r = sd_bus_message_exit_container(message);
	316	if (r < 0)
	317	return r;
	318
	319	if (!UNIT_WRITE_FLAGS_NOOP(flags) && empty) {
	320	timer_free_values(t);
	321	unit_write_setting(u, flags, name, "OnCalendar=");
	322	}
	323
	324	return 1;
	325
	326	} else if (STR_IN_SET(name,
d8a812d1 WC	327	"OnActiveSec",
	328	"OnBootSec",
	329	"OnStartupSec",
	330	"OnUnitActiveSec",
	331	"OnUnitInactiveSec")) {
	332
cd87f634 ZJS	333	TimerBase b;
cd87f634 ZJS	334	usec_t usec;
3e3c5a45 YW	335
3e3c5a45 YW	336	log_notice("Client is using obsolete %s= transient property, please use TimersMonotonic= instead.", name);
d8a812d1 WC	337
	338	b = timer_base_from_string(name);
	339	if (b < 0)
170d4026	340	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown timer base %s", name);
d8a812d1	341
3e3c5a45	342	r = sd_bus_message_read(message, "t", &usec);
d8a812d1 WC	343	if (r < 0)
	344	return r;
	345
cd87f634	346	return timer_add_one_monotonic_spec(t, name, b, flags, usec, error);
d8a812d1 WC	347
	348	} else if (streq(name, "OnCalendar")) {
	349
d8a812d1 WC	350	const char *str;
d8a812d1 WC	351
3e3c5a45 YW	352	log_notice("Client is using obsolete %s= transient property, please use TimersCalendar= instead.", name);
3e3c5a45 YW	353
d8a812d1 WC	354	r = sd_bus_message_read(message, "s", &str);
	355	if (r < 0)
	356	return r;
	357
d00a52c7	358	return timer_add_one_calendar_spec(t, name, TIMER_CALENDAR, flags, str, error);
d8a812d1 WC	359	}
	360
	361	return 0;
	362	}
	363
	364	int bus_timer_set_property(
	365	Unit *u,
	366	const char *name,
	367	sd_bus_message *message,
2e59b241	368	UnitWriteFlags mode,
d8a812d1 WC	369	sd_bus_error *error) {
	370
	371	Timer *t = TIMER(u);
d8a812d1 WC	372
	373	assert(t);
	374	assert(name);
	375	assert(message);
	376
2e59b241 LP	377	if (u->transient && u->load_state == UNIT_STUB)
2e59b241 LP	378	return bus_timer_set_transient_property(t, name, message, mode, error);
d8a812d1 WC	379
	380	return 0;
	381	}