[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 "calendarspec.h"
#include "dbus-timer.h"
#include "dbus-util.h"
#include "string-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 = ASSERT_PTR(userdata);
        int r;

        assert(bus);
        assert(reply);

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

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

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

                usec = timer_base_to_usec_string(v->base);
                if (!usec)
                        return -ENOMEM;

                r = sd_bus_message_append(reply, "(stt)", usec, 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 = ASSERT_PTR(userdata);
        int r;

        assert(bus);
        assert(reply);

        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 = ASSERT_PTR(userdata);

        assert(bus);
        assert(reply);

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

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_delay_usec), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("RandomizedOffsetUSec", "t", bus_property_get_usec, offsetof(Timer, random_offset_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_PROPERTY("DeferReactivation", "b", bus_property_get_bool, offsetof(Timer, defer_reactivation), 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_delay_usec, message, flags, error);

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