src/core/dbus-timer.c

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