src/core/dbus-util.h

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 #pragma once
   3
   4 /***
   5   Copyright 2010 Lennart Poettering
   6 ***/
   7
   8 #include "sd-bus.h"
   9
  10 #include "unit.h"
  11
  12 int bus_property_get_triggered_unit(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
  13
  14 #define BUS_DEFINE_SET_TRANSIENT(function, bus_type, type, cast_type, fmt) \
  15         int bus_set_transient_##function(                               \
  16                         Unit *u,                                        \
  17                         const char *name,                               \
  18                         cast_type *p,                                   \
  19                         sd_bus_message *message,                        \
  20                         UnitWriteFlags flags,                           \
  21                         sd_bus_error *error) {                          \
  22                                                                         \
  23                 type v;                                                 \
  24                 int r;                                                  \
  25                                                                         \
  26                 assert(p);                                              \
  27                                                                         \
  28                 r = sd_bus_message_read(message, bus_type, &v);         \
  29                 if (r < 0)                                              \
  30                         return r;                                       \
  31                                                                         \
  32                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {                    \
  33                         *p = (cast_type) v;                             \
  34                         unit_write_settingf(u, flags, name,             \
  35                                             "%s=" fmt, name, v);        \
  36                 }                                                       \
  37                                                                         \
  38                 return 1;                                               \
  39         }
  40
  41 #define BUS_DEFINE_SET_TRANSIENT_IS_VALID(function, bus_type, type, cast_type, fmt, check) \
  42         int bus_set_transient_##function(                               \
  43                         Unit *u,                                        \
  44                         const char *name,                               \
  45                         cast_type *p,                                   \
  46                         sd_bus_message *message,                        \
  47                         UnitWriteFlags flags,                           \
  48                         sd_bus_error *error) {                          \
  49                                                                         \
  50                 type v;                                                 \
  51                 int r;                                                  \
  52                                                                         \
  53                 assert(p);                                              \
  54                                                                         \
  55                 r = sd_bus_message_read(message, bus_type, &v);         \
  56                 if (r < 0)                                              \
  57                         return r;                                       \
  58                                                                         \
  59                 if (!check(v))                                          \
  60                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, \
  61                                                  "Invalid %s setting: " fmt, name, v); \
  62                                                                         \
  63                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {                    \
  64                         *p = (cast_type) v;                             \
  65                         unit_write_settingf(u, flags, name,             \
  66                                             "%s=" fmt, name, v);        \
  67                 }                                                       \
  68                                                                         \
  69                 return 1;                                               \
  70         }
  71
  72 #define BUS_DEFINE_SET_TRANSIENT_TO_STRING(function, bus_type, type, cast_type, fmt, to_string) \
  73         int bus_set_transient_##function(                               \
  74                         Unit *u,                                        \
  75                         const char *name,                               \
  76                         cast_type *p,                                   \
  77                         sd_bus_message *message,                        \
  78                         UnitWriteFlags flags,                           \
  79                         sd_bus_error *error) {                          \
  80                                                                         \
  81                 const char *s;                                          \
  82                 type v;                                                 \
  83                 int r;                                                  \
  84                                                                         \
  85                 assert(p);                                              \
  86                                                                         \
  87                 r = sd_bus_message_read(message, bus_type, &v);         \
  88                 if (r < 0)                                              \
  89                         return r;                                       \
  90                                                                         \
  91                 s = to_string(v);                                       \
  92                 if (!s)                                                 \
  93                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, \
  94                                                  "Invalid %s setting: " fmt, name, v); \
  95                                                                         \
  96                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {                    \
  97                         *p = (cast_type) v;                             \
  98                         unit_write_settingf(u, flags, name,             \
  99                                             "%s=%s", name, s);          \
 100                 }                                                       \
 101                                                                         \
 102                 return 1;                                               \
 103         }
 104
 105 #define BUS_DEFINE_SET_TRANSIENT_TO_STRING_ALLOC(function, bus_type, type, cast_type, fmt, to_string) \
 106         int bus_set_transient_##function(                               \
 107                         Unit *u,                                        \
 108                         const char *name,                               \
 109                         cast_type *p,                                   \
 110                         sd_bus_message *message,                        \
 111                         UnitWriteFlags flags,                           \
 112                         sd_bus_error *error) {                          \
 113                                                                         \
 114                 _cleanup_free_ char *s = NULL;                          \
 115                 type v;                                                 \
 116                 int r;                                                  \
 117                                                                         \
 118                 assert(p);                                              \
 119                                                                         \
 120                 r = sd_bus_message_read(message, bus_type, &v);         \
 121                 if (r < 0)                                              \
 122                         return r;                                       \
 123                                                                         \
 124                 r = to_string(v, &s);                                   \
 125                 if (r == -EINVAL)                                       \
 126                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, \
 127                                                  "Invalid %s setting: " fmt, name, v); \
 128                 if (r < 0)                                              \
 129                         return r;                                       \
 130                                                                         \
 131                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {                    \
 132                         *p = (cast_type) v;                             \
 133                         unit_write_settingf(u, flags, name,             \
 134                                             "%s=%s", name, s);          \
 135                 }                                                       \
 136                                                                         \
 137                 return 1;                                               \
 138         }
 139
 140 #define BUS_DEFINE_SET_TRANSIENT_PARSE(function, type, parse)           \
 141         int bus_set_transient_##function(                               \
 142                         Unit *u,                                        \
 143                         const char *name,                               \
 144                         type *p,                                        \
 145                         sd_bus_message *message,                        \
 146                         UnitWriteFlags flags,                           \
 147                         sd_bus_error *error) {                          \
 148                                                                         \
 149                 const char *s;                                          \
 150                 type v;                                                 \
 151                 int r;                                                  \
 152                                                                         \
 153                 assert(p);                                              \
 154                                                                         \
 155                 r = sd_bus_message_read(message, "s", &s);              \
 156                 if (r < 0)                                              \
 157                         return r;                                       \
 158                                                                         \
 159                 v = parse(s);                                           \
 160                 if (v < 0)                                              \
 161                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, \
 162                                                  "Invalid %s setting: %s", name, s); \
 163                                                                         \
 164                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {                    \
 165                         *p = v;                                         \
 166                         unit_write_settingf(u, flags, name,             \
 167                                             "%s=%s", name, s);          \
 168                 }                                                       \
 169                                                                         \
 170                 return 1;                                               \
 171         }
 172
 173 #define BUS_DEFINE_SET_TRANSIENT_PARSE_PTR(function, type, parse)       \
 174         int bus_set_transient_##function(                               \
 175                         Unit *u,                                        \
 176                         const char *name,                               \
 177                         type *p,                                        \
 178                         sd_bus_message *message,                        \
 179                         UnitWriteFlags flags,                           \
 180                         sd_bus_error *error) {                          \
 181                                                                         \
 182                 const char *s;                                          \
 183                 type v;                                                 \
 184                 int r;                                                  \
 185                                                                         \
 186                 assert(p);                                              \
 187                                                                         \
 188                 r = sd_bus_message_read(message, "s", &s);              \
 189                 if (r < 0)                                              \
 190                         return r;                                       \
 191                                                                         \
 192                 r = parse(s, &v);                                       \
 193                 if (r < 0)                                              \
 194                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, \
 195                                                  "Invalid %s setting: %s", name, s); \
 196                                                                         \
 197                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {                    \
 198                         *p = v;                                         \
 199                         unit_write_settingf(u, flags, name,             \
 200                                             "%s=%s", name, strempty(s)); \
 201                 }                                                       \
 202                                                                         \
 203                 return 1;                                               \
 204         }
 205
 206 #define BUS_DEFINE_SET_TRANSIENT_STRING_WITH_CHECK(function, check)     \
 207         int bus_set_transient_##function(                               \
 208                         Unit *u,                                        \
 209                         const char *name,                               \
 210                         char **p,                                       \
 211                         sd_bus_message *message,                        \
 212                         UnitWriteFlags flags,                           \
 213                         sd_bus_error *error) {                          \
 214                                                                         \
 215                 const char *v;                                          \
 216                 int r;                                                  \
 217                                                                         \
 218                 assert(p);                                              \
 219                                                                         \
 220                 r = sd_bus_message_read(message, "s", &v);              \
 221                 if (r < 0)                                              \
 222                         return r;                                       \
 223                                                                         \
 224                 if (!isempty(v) && !check(v))                           \
 225                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, \
 226                                                  "Invalid %s setting: %s", name, v); \
 227                                                                         \
 228                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {                    \
 229                         r = free_and_strdup(p, empty_to_null(v));       \
 230                         if (r < 0)                                      \
 231                                 return r;                               \
 232                                                                         \
 233                         unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, \
 234                                             "%s=%s", name, strempty(v)); \
 235                 }                                                       \
 236                                                                         \
 237                 return 1;                                               \
 238         }
 239
 240 int bus_set_transient_mode_t(Unit *u, const char *name, mode_t *p, sd_bus_message *message, UnitWriteFlags flags, sd_bus_error *error);
 241 int bus_set_transient_unsigned(Unit *u, const char *name, unsigned *p, sd_bus_message *message, UnitWriteFlags flags, sd_bus_error *error);
 242 int bus_set_transient_user(Unit *u, const char *name, char **p, sd_bus_message *message, UnitWriteFlags flags, sd_bus_error *error);
 243 int bus_set_transient_path(Unit *u, const char *name, char **p, sd_bus_message *message, UnitWriteFlags flags, sd_bus_error *error);
 244 int bus_set_transient_string(Unit *u, const char *name, char **p, sd_bus_message *message, UnitWriteFlags flags, sd_bus_error *error);
 245 int bus_set_transient_bool(Unit *u, const char *name, bool *p, sd_bus_message *message, UnitWriteFlags flags, sd_bus_error *error);
 246 int bus_set_transient_usec_internal(Unit *u, const char *name, usec_t *p, bool fix_0, sd_bus_message *message, UnitWriteFlags flags, sd_bus_error *error);
 247 static inline int bus_set_transient_usec(Unit *u, const char *name, usec_t *p, sd_bus_message *message, UnitWriteFlags flags, sd_bus_error *error) {
 248         return bus_set_transient_usec_internal(u, name, p, false, message, flags, error);
 249 }
 250 static inline int bus_set_transient_usec_fix_0(Unit *u, const char *name, usec_t *p, sd_bus_message *message, UnitWriteFlags flags, sd_bus_error *error) {
 251         return bus_set_transient_usec_internal(u, name, p, true, message, flags, error);
 252 }