src/core/dbus-util.h

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 #pragma once
   3
   4 /***
   5   This file is part of systemd.
   6
   7   Copyright 2010 Lennart Poettering
   8
   9   systemd is free software; you can redistribute it and/or modify it
  10   under the terms of the GNU Lesser General Public License as published by
  11   the Free Software Foundation; either version 2.1 of the License, or
  12   (at your option) any later version.
  13
  14   systemd is distributed in the hope that it will be useful, but
  15   WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17   Lesser General Public License for more details.
  18
  19   You should have received a copy of the GNU Lesser General Public License
  20   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  21 ***/
  22
  23 #include "sd-bus.h"
  24 #include "unit.h"
  25
  26 #define BUS_DEFINE_SET_TRANSIENT(function, bus_type, type, cast_type, fmt) \
  27         int bus_set_transient_##function(                               \
  28                         Unit *u,                                        \
  29                         const char *name,                               \
  30                         cast_type *p,                                   \
  31                         sd_bus_message *message,                        \
  32                         UnitWriteFlags flags,                           \
  33                         sd_bus_error *error) {                          \
  34                                                                         \
  35                 type v;                                                 \
  36                 int r;                                                  \
  37                                                                         \
  38                 assert(p);                                              \
  39                                                                         \
  40                 r = sd_bus_message_read(message, bus_type, &v);         \
  41                 if (r < 0)                                              \
  42                         return r;                                       \
  43                                                                         \
  44                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {                    \
  45                         *p = (cast_type) v;                             \
  46                         unit_write_settingf(u, flags, name,             \
  47                                             "%s=" fmt, name, v);        \
  48                 }                                                       \
  49                                                                         \
  50                 return 1;                                               \
  51         }
  52
  53 #define BUS_DEFINE_SET_TRANSIENT_IS_VALID(function, bus_type, type, cast_type, fmt, check) \
  54         int bus_set_transient_##function(                               \
  55                         Unit *u,                                        \
  56                         const char *name,                               \
  57                         cast_type *p,                                   \
  58                         sd_bus_message *message,                        \
  59                         UnitWriteFlags flags,                           \
  60                         sd_bus_error *error) {                          \
  61                                                                         \
  62                 type v;                                                 \
  63                 int r;                                                  \
  64                                                                         \
  65                 assert(p);                                              \
  66                                                                         \
  67                 r = sd_bus_message_read(message, bus_type, &v);         \
  68                 if (r < 0)                                              \
  69                         return r;                                       \
  70                                                                         \
  71                 if (!check(v))                                          \
  72                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, \
  73                                                  "Invalid %s setting: " fmt, name, v); \
  74                                                                         \
  75                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {                    \
  76                         *p = (cast_type) v;                             \
  77                         unit_write_settingf(u, flags, name,             \
  78                                             "%s=" fmt, name, v);        \
  79                 }                                                       \
  80                                                                         \
  81                 return 1;                                               \
  82         }
  83
  84 #define BUS_DEFINE_SET_TRANSIENT_TO_STRING(function, bus_type, type, cast_type, fmt, to_string) \
  85         int bus_set_transient_##function(                               \
  86                         Unit *u,                                        \
  87                         const char *name,                               \
  88                         cast_type *p,                                   \
  89                         sd_bus_message *message,                        \
  90                         UnitWriteFlags flags,                           \
  91                         sd_bus_error *error) {                          \
  92                                                                         \
  93                 const char *s;                                          \
  94                 type v;                                                 \
  95                 int r;                                                  \
  96                                                                         \
  97                 assert(p);                                              \
  98                                                                         \
  99                 r = sd_bus_message_read(message, bus_type, &v);         \
 100                 if (r < 0)                                              \
 101                         return r;                                       \
 102                                                                         \
 103                 s = to_string(v);                                       \
 104                 if (!s)                                                 \
 105                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, \
 106                                                  "Invalid %s setting: " fmt, name, v); \
 107                                                                         \
 108                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {                    \
 109                         *p = (cast_type) v;                             \
 110                         unit_write_settingf(u, flags, name,             \
 111                                             "%s=%s", name, s);          \
 112                 }                                                       \
 113                                                                         \
 114                 return 1;                                               \
 115         }
 116
 117 #define BUS_DEFINE_SET_TRANSIENT_TO_STRING_ALLOC(function, bus_type, type, cast_type, fmt, to_string) \
 118         int bus_set_transient_##function(                               \
 119                         Unit *u,                                        \
 120                         const char *name,                               \
 121                         cast_type *p,                                   \
 122                         sd_bus_message *message,                        \
 123                         UnitWriteFlags flags,                           \
 124                         sd_bus_error *error) {                          \
 125                                                                         \
 126                 _cleanup_free_ char *s = NULL;                          \
 127                 type v;                                                 \
 128                 int r;                                                  \
 129                                                                         \
 130                 assert(p);                                              \
 131                                                                         \
 132                 r = sd_bus_message_read(message, bus_type, &v);         \
 133                 if (r < 0)                                              \
 134                         return r;                                       \
 135                                                                         \
 136                 r = to_string(v, &s);                                   \
 137                 if (r == -EINVAL)                                       \
 138                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, \
 139                                                  "Invalid %s setting: " fmt, name, v); \
 140                 if (r < 0)                                              \
 141                         return r;                                       \
 142                                                                         \
 143                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {                    \
 144                         *p = (cast_type) v;                             \
 145                         unit_write_settingf(u, flags, name,             \
 146                                             "%s=%s", name, s);          \
 147                 }                                                       \
 148                                                                         \
 149                 return 1;                                               \
 150         }
 151
 152 #define BUS_DEFINE_SET_TRANSIENT_PARSE(function, type, parse)           \
 153         int bus_set_transient_##function(                               \
 154                         Unit *u,                                        \
 155                         const char *name,                               \
 156                         type *p,                                        \
 157                         sd_bus_message *message,                        \
 158                         UnitWriteFlags flags,                           \
 159                         sd_bus_error *error) {                          \
 160                                                                         \
 161                 const char *s;                                          \
 162                 type v;                                                 \
 163                 int r;                                                  \
 164                                                                         \
 165                 assert(p);                                              \
 166                                                                         \
 167                 r = sd_bus_message_read(message, "s", &s);              \
 168                 if (r < 0)                                              \
 169                         return r;                                       \
 170                                                                         \
 171                 v = parse(s);                                           \
 172                 if (v < 0)                                              \
 173                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, \
 174                                                  "Invalid %s setting: %s", name, s); \
 175                                                                         \
 176                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {                    \
 177                         *p = v;                                         \
 178                         unit_write_settingf(u, flags, name,             \
 179                                             "%s=%s", name, s);          \
 180                 }                                                       \
 181                                                                         \
 182                 return 1;                                               \
 183         }
 184
 185 #define BUS_DEFINE_SET_TRANSIENT_PARSE_PTR(function, type, parse)       \
 186         int bus_set_transient_##function(                               \
 187                         Unit *u,                                        \
 188                         const char *name,                               \
 189                         type *p,                                        \
 190                         sd_bus_message *message,                        \
 191                         UnitWriteFlags flags,                           \
 192                         sd_bus_error *error) {                          \
 193                                                                         \
 194                 const char *s;                                          \
 195                 type v;                                                 \
 196                 int r;                                                  \
 197                                                                         \
 198                 assert(p);                                              \
 199                                                                         \
 200                 r = sd_bus_message_read(message, "s", &s);              \
 201                 if (r < 0)                                              \
 202                         return r;                                       \
 203                                                                         \
 204                 r = parse(s, &v);                                       \
 205                 if (r < 0)                                              \
 206                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, \
 207                                                  "Invalid %s setting: %s", name, s); \
 208                                                                         \
 209                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {                    \
 210                         *p = v;                                         \
 211                         unit_write_settingf(u, flags, name,             \
 212                                             "%s=%s", name, strempty(s)); \
 213                 }                                                       \
 214                                                                         \
 215                 return 1;                                               \
 216         }
 217
 218 #define BUS_DEFINE_SET_TRANSIENT_STRING_WITH_CHECK(function, check)     \
 219         int bus_set_transient_##function(                               \
 220                         Unit *u,                                        \
 221                         const char *name,                               \
 222                         char **p,                                       \
 223                         sd_bus_message *message,                        \
 224                         UnitWriteFlags flags,                           \
 225                         sd_bus_error *error) {                          \
 226                                                                         \
 227                 const char *v;                                          \
 228                 int r;                                                  \
 229                                                                         \
 230                 assert(p);                                              \
 231                                                                         \
 232                 r = sd_bus_message_read(message, "s", &v);              \
 233                 if (r < 0)                                              \
 234                         return r;                                       \
 235                                                                         \
 236                 if (!isempty(v) && !check(v))                           \
 237                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, \
 238                                                  "Invalid %s setting: %s", name, v); \
 239                                                                         \
 240                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {                    \
 241                         r = free_and_strdup(p, empty_to_null(v));       \
 242                         if (r < 0)                                      \
 243                                 return r;                               \
 244                                                                         \
 245                         unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, \
 246                                             "%s=%s", name, strempty(v)); \
 247                 }                                                       \
 248                                                                         \
 249                 return 1;                                               \
 250         }
 251
 252 #define BUS_DEFINE_SET_CGROUP_WEIGHT(function, mask, check, val, str)   \
 253         int bus_cgroup_set_##function(                                  \
 254                         Unit *u,                                        \
 255                         const char *name,                               \
 256                         uint64_t *p,                                    \
 257                         sd_bus_message *message,                        \
 258                         UnitWriteFlags flags,                           \
 259                         sd_bus_error *error) {                          \
 260                                                                         \
 261                 uint64_t v;                                             \
 262                 int r;                                                  \
 263                                                                         \
 264                 assert(p);                                              \
 265                                                                         \
 266                 r = sd_bus_message_read(message, "t", &v);              \
 267                 if (r < 0)                                              \
 268                         return r;                                       \
 269                                                                         \
 270                 if (!check(v))                                          \
 271                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, \
 272                                                  "Value specified in %s is out of range", name); \
 273                                                                         \
 274                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {                    \
 275                         *p = v;                                         \
 276                         unit_invalidate_cgroup(u, (mask));              \
 277                                                                         \
 278                         if (v == (val))                                 \
 279                                 unit_write_settingf(u, flags, name,     \
 280                                                     "%s=" str, name);   \
 281                         else                                            \
 282                                 unit_write_settingf(u, flags, name,     \
 283                                                     "%s=%" PRIu64, name, v); \
 284                 }                                                       \
 285                                                                         \
 286                 return 1;                                               \
 287         }
 288
 289 #define BUS_DEFINE_SET_CGROUP_SCALE(function, mask, scale)              \
 290         int bus_cgroup_set_##function##_scale(                          \
 291                         Unit *u,                                        \
 292                         const char *name,                               \
 293                         uint64_t *p,                                    \
 294                         sd_bus_message *message,                        \
 295                         UnitWriteFlags flags,                           \
 296                         sd_bus_error *error) {                          \
 297                                                                         \
 298                 uint64_t v;                                             \
 299                 uint32_t raw;                                           \
 300                 int r;                                                  \
 301                                                                         \
 302                 assert(p);                                              \
 303                                                                         \
 304                 r = sd_bus_message_read(message, "u", &raw);            \
 305                 if (r < 0)                                              \
 306                         return r;                                       \
 307                                                                         \
 308                 v = scale(raw, UINT32_MAX);                             \
 309                 if (v <= 0 || v >= UINT64_MAX)                          \
 310                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, \
 311                                                  "Value specified in %s is out of range", name); \
 312                                                                         \
 313                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {                    \
 314                         const char *e;                                  \
 315                                                                         \
 316                         *p = v;                                         \
 317                         unit_invalidate_cgroup(u, (mask));              \
 318                                                                         \
 319                         /* Chop off suffix */                           \
 320                         assert_se(e = endswith(name, "Scale"));         \
 321                         name = strndupa(name, e - name);                \
 322                                                                         \
 323                         unit_write_settingf(u, flags, name, "%s=%" PRIu32 "%%", name, \
 324                                             (uint32_t) (DIV_ROUND_UP((uint64_t) raw * 100U, (uint64_t) UINT32_MAX))); \
 325                 }                                                       \
 326                                                                         \
 327                 return 1;                                               \
 328         }
 329
 330 int bus_set_transient_mode_t(Unit *u, const char *name, mode_t *p, sd_bus_message *message, UnitWriteFlags flags, sd_bus_error *error);
 331 int bus_set_transient_unsigned(Unit *u, const char *name, unsigned *p, sd_bus_message *message, UnitWriteFlags flags, sd_bus_error *error);
 332 int bus_set_transient_user(Unit *u, const char *name, char **p, sd_bus_message *message, UnitWriteFlags flags, sd_bus_error *error);
 333 int bus_set_transient_path(Unit *u, const char *name, char **p, sd_bus_message *message, UnitWriteFlags flags, sd_bus_error *error);
 334 int bus_set_transient_string(Unit *u, const char *name, char **p, sd_bus_message *message, UnitWriteFlags flags, sd_bus_error *error);
 335 int bus_set_transient_bool(Unit *u, const char *name, bool *p, sd_bus_message *message, UnitWriteFlags flags, sd_bus_error *error);
 336 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);
 337 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) {
 338         return bus_set_transient_usec_internal(u, name, p, false, message, flags, error);
 339 }
 340 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) {
 341         return bus_set_transient_usec_internal(u, name, p, true, message, flags, error);
 342 }