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

/* SPDX-License-Identifier: LGPL-2.1+ */

#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("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)) {
                char ts[FORMAT_TIMESPAN_MAX];
                TimerValue *v;

                unit_write_settingf(UNIT(t), flags|UNIT_ESCAPE_SPECIFIERS, name,
                                    "%s=%s",
                                    timer_base_to_string(base),
                                    format_timespan(ts, sizeof ts, 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_setf(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, "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");

                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
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
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),
06642d17	134	SD_BUS_PROPERTY("Persistent", "b", bus_property_get_bool, offsetof(Timer, persistent), SD_BUS_VTABLE_PROPERTY_CONST),
dedabea4	135	SD_BUS_PROPERTY("WakeSystem", "b", bus_property_get_bool, offsetof(Timer, wake_system), SD_BUS_VTABLE_PROPERTY_CONST),
3e0c30ac	136	SD_BUS_PROPERTY("RemainAfterElapse", "b", bus_property_get_bool, offsetof(Timer, remain_after_elapse), SD_BUS_VTABLE_PROPERTY_CONST),
718db961	137	SD_BUS_VTABLE_END
d200735e	138	};
d8a812d1	139
cd87f634 ZJS	140	static int timer_add_one_monotonic_spec(
	141	Timer *t,
	142	const char *name,
	143	TimerBase base,
	144	UnitWriteFlags flags,
	145	usec_t usec,
	146	sd_bus_error *error) {
	147
	148	if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
	149	char ts[FORMAT_TIMESPAN_MAX];
	150	TimerValue *v;
	151
	152	unit_write_settingf(UNIT(t), flags\|UNIT_ESCAPE_SPECIFIERS, name,
	153	"%s=%s",
	154	timer_base_to_string(base),
	155	format_timespan(ts, sizeof ts, usec, USEC_PER_MSEC));
	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)
	185	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid calendar spec");
	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
	235	if (streq(name, "WakeSystem"))
	236	return bus_set_transient_bool(u, name, &t->wake_system, message, flags, error);
	237
	238	if (streq(name, "Persistent"))
	239	return bus_set_transient_bool(u, name, &t->persistent, message, flags, error);
	240
	241	if (streq(name, "RemainAfterElapse"))
	242	return bus_set_transient_bool(u, name, &t->remain_after_elapse, message, flags, error);
	243
efebb613 LP	244	if (streq(name, "OnTimezoneChange"))
	245	return bus_set_transient_bool(u, name, &t->on_timezone_change, message, flags, error);
	246
	247	if (streq(name, "OnClockChange"))
	248	return bus_set_transient_bool(u, name, &t->on_clock_change, message, flags, error);
	249
3e3c5a45 YW	250	if (streq(name, "TimersMonotonic")) {
3e3c5a45 YW	251	const char *base_name;
cd87f634	252	usec_t usec;
3e3c5a45 YW	253	bool empty = true;
	254
	255	r = sd_bus_message_enter_container(message, 'a', "(st)");
	256	if (r < 0)
	257	return r;
	258
	259	while ((r = sd_bus_message_read(message, "(st)", &base_name, &usec)) > 0) {
	260	TimerBase b;
	261
	262	b = timer_base_from_string(base_name);
	263	if (b < 0 \|\| b == TIMER_CALENDAR)
cd87f634 ZJS	264	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
cd87f634 ZJS	265	"Invalid timer base: %s", base_name);
3e3c5a45	266
cd87f634 ZJS	267	r = timer_add_one_monotonic_spec(t, name, b, flags, usec, error);
	268	if (r < 0)
	269	return r;
3e3c5a45 YW	270
	271	empty = false;
	272	}
	273	if (r < 0)
	274	return r;
	275
	276	r = sd_bus_message_exit_container(message);
	277	if (r < 0)
	278	return r;
	279
	280	if (!UNIT_WRITE_FLAGS_NOOP(flags) && empty) {
	281	timer_free_values(t);
	282	unit_write_setting(u, flags, name, "OnActiveSec=");
	283	}
	284
	285	return 1;
	286
	287	} else if (streq(name, "TimersCalendar")) {
	288	const char base_name, str;
	289	bool empty = true;
	290
	291	r = sd_bus_message_enter_container(message, 'a', "(ss)");
	292	if (r < 0)
	293	return r;
	294
	295	while ((r = sd_bus_message_read(message, "(ss)", &base_name, &str)) > 0) {
3e3c5a45 YW	296	TimerBase b;
	297
	298	b = timer_base_from_string(base_name);
	299	if (b != TIMER_CALENDAR)
d00a52c7 ZJS	300	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
d00a52c7 ZJS	301	"Invalid timer base: %s", base_name);
3e3c5a45	302
d00a52c7	303	r = timer_add_one_calendar_spec(t, name, b, flags, str, error);
3e3c5a45 YW	304	if (r < 0)
	305	return r;
	306
3e3c5a45 YW	307	empty = false;
	308	}
	309	if (r < 0)
	310	return r;
	311
	312	r = sd_bus_message_exit_container(message);
	313	if (r < 0)
	314	return r;
	315
	316	if (!UNIT_WRITE_FLAGS_NOOP(flags) && empty) {
	317	timer_free_values(t);
	318	unit_write_setting(u, flags, name, "OnCalendar=");
	319	}
	320
	321	return 1;
	322
	323	} else if (STR_IN_SET(name,
d8a812d1 WC	324	"OnActiveSec",
	325	"OnBootSec",
	326	"OnStartupSec",
	327	"OnUnitActiveSec",
	328	"OnUnitInactiveSec")) {
	329
cd87f634 ZJS	330	TimerBase b;
cd87f634 ZJS	331	usec_t usec;
3e3c5a45 YW	332
3e3c5a45 YW	333	log_notice("Client is using obsolete %s= transient property, please use TimersMonotonic= instead.", name);
d8a812d1 WC	334
	335	b = timer_base_from_string(name);
	336	if (b < 0)
1e3b7b0e	337	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown timer base");
d8a812d1	338
3e3c5a45	339	r = sd_bus_message_read(message, "t", &usec);
d8a812d1 WC	340	if (r < 0)
	341	return r;
	342
cd87f634	343	return timer_add_one_monotonic_spec(t, name, b, flags, usec, error);
d8a812d1 WC	344
	345	} else if (streq(name, "OnCalendar")) {
	346
d8a812d1 WC	347	const char *str;
d8a812d1 WC	348
3e3c5a45 YW	349	log_notice("Client is using obsolete %s= transient property, please use TimersCalendar= instead.", name);
3e3c5a45 YW	350
d8a812d1 WC	351	r = sd_bus_message_read(message, "s", &str);
	352	if (r < 0)
	353	return r;
	354
d00a52c7	355	return timer_add_one_calendar_spec(t, name, TIMER_CALENDAR, flags, str, error);
d8a812d1 WC	356	}
	357
	358	return 0;
	359	}
	360
	361	int bus_timer_set_property(
	362	Unit *u,
	363	const char *name,
	364	sd_bus_message *message,
2e59b241	365	UnitWriteFlags mode,
d8a812d1 WC	366	sd_bus_error *error) {
	367
	368	Timer *t = TIMER(u);
d8a812d1 WC	369
	370	assert(t);
	371	assert(name);
	372	assert(message);
	373
2e59b241 LP	374	if (u->transient && u->load_state == UNIT_STUB)
2e59b241 LP	375	return bus_timer_set_transient_property(t, name, message, mode, error);
d8a812d1 WC	376
	377	return 0;
	378	}