src/core/dbus-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include "bus-util.h"
   4 #include "dbus-util.h"
   5 #include "parse-util.h"
   6 #include "path-util.h"
   7 #include "unit-printf.h"
   8 #include "user-util.h"
   9 #include "unit.h"
  10
  11 int bus_property_get_triggered_unit(
  12                 sd_bus *bus,
  13                 const char *path,
  14                 const char *interface,
  15                 const char *property,
  16                 sd_bus_message *reply,
  17                 void *userdata,
  18                 sd_bus_error *error) {
  19
  20         Unit *u = userdata, *trigger;
  21
  22         assert(bus);
  23         assert(reply);
  24         assert(u);
  25
  26         trigger = UNIT_TRIGGER(u);
  27
  28         return sd_bus_message_append(reply, "s", trigger ? trigger->id : NULL);
  29 }
  30
  31 BUS_DEFINE_SET_TRANSIENT(mode_t, "u", uint32_t, mode_t, "%040o");
  32 BUS_DEFINE_SET_TRANSIENT(unsigned, "u", uint32_t, unsigned, "%" PRIu32);
  33
  34 static inline bool valid_user_group_name_or_id_relaxed(const char *u) {
  35         return valid_user_group_name(u, VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX);
  36 }
  37
  38 BUS_DEFINE_SET_TRANSIENT_STRING_WITH_CHECK(user_relaxed, valid_user_group_name_or_id_relaxed);
  39 BUS_DEFINE_SET_TRANSIENT_STRING_WITH_CHECK(path, path_is_absolute);
  40
  41 int bus_set_transient_string(
  42                 Unit *u,
  43                 const char *name,
  44                 char **p,
  45                 sd_bus_message *message,
  46                 UnitWriteFlags flags,
  47                 sd_bus_error *error) {
  48
  49         const char *v;
  50         int r;
  51
  52         assert(p);
  53
  54         r = sd_bus_message_read(message, "s", &v);
  55         if (r < 0)
  56                 return r;
  57
  58         if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
  59                 r = free_and_strdup(p, empty_to_null(v));
  60                 if (r < 0)
  61                         return r;
  62
  63                 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name,
  64                                     "%s=%s", name, strempty(v));
  65         }
  66
  67         return 1;
  68 }
  69
  70 int bus_set_transient_bool(
  71                 Unit *u,
  72                 const char *name,
  73                 bool *p,
  74                 sd_bus_message *message,
  75                 UnitWriteFlags flags,
  76                 sd_bus_error *error) {
  77
  78         int v, r;
  79
  80         assert(p);
  81
  82         r = sd_bus_message_read(message, "b", &v);
  83         if (r < 0)
  84                 return r;
  85
  86         if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
  87                 *p = v;
  88                 unit_write_settingf(u, flags, name, "%s=%s", name, yes_no(v));
  89         }
  90
  91         return 1;
  92 }
  93
  94 int bus_set_transient_usec_internal(
  95                 Unit *u,
  96                 const char *name,
  97                 usec_t *p,
  98                 bool fix_0,
  99                 sd_bus_message *message,
 100                 UnitWriteFlags flags,
 101                 sd_bus_error *error) {
 102
 103         uint64_t v;
 104         int r;
 105
 106         assert(p);
 107
 108         r = sd_bus_message_read(message, "t", &v);
 109         if (r < 0)
 110                 return r;
 111
 112         if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 113                 char *n, ts[FORMAT_TIMESPAN_MAX];
 114
 115                 if (fix_0)
 116                         *p = v != 0 ? v: USEC_INFINITY;
 117                 else
 118                         *p = v;
 119
 120                 n = strndupa(name, strlen(name) - 4);
 121                 unit_write_settingf(u, flags, name, "%sSec=%s", n,
 122                                     format_timespan(ts, sizeof(ts), v, USEC_PER_MSEC));
 123         }
 124
 125         return 1;
 126 }