src/core/dbus-service.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <stdio_ext.h>
   4
   5 #include "alloc-util.h"
   6 #include "async.h"
   7 #include "bus-internal.h"
   8 #include "bus-util.h"
   9 #include "dbus-cgroup.h"
  10 #include "dbus-execute.h"
  11 #include "dbus-kill.h"
  12 #include "dbus-service.h"
  13 #include "dbus-util.h"
  14 #include "exit-status.h"
  15 #include "fd-util.h"
  16 #include "fileio.h"
  17 #include "parse-util.h"
  18 #include "path-util.h"
  19 #include "service.h"
  20 #include "signal-util.h"
  21 #include "string-util.h"
  22 #include "strv.h"
  23 #include "unit.h"
  24
  25 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, service_type, ServiceType);
  26 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, service_result, ServiceResult);
  27 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_restart, service_restart, ServiceRestart);
  28 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_notify_access, notify_access, NotifyAccess);
  29 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_emergency_action, emergency_action, EmergencyAction);
  30
  31 static int property_get_exit_status_set(
  32                 sd_bus *bus,
  33                 const char *path,
  34                 const char *interface,
  35                 const char *property,
  36                 sd_bus_message *reply,
  37                 void *userdata,
  38                 sd_bus_error *error) {
  39
  40         ExitStatusSet *status_set = userdata;
  41         Iterator i;
  42         void *id;
  43         int r;
  44
  45         assert(bus);
  46         assert(reply);
  47         assert(status_set);
  48
  49         r = sd_bus_message_open_container(reply, 'r', "aiai");
  50         if (r < 0)
  51                 return r;
  52
  53         r = sd_bus_message_open_container(reply, 'a', "i");
  54         if (r < 0)
  55                 return r;
  56
  57         SET_FOREACH(id, status_set->status, i) {
  58                 int val = PTR_TO_INT(id);
  59
  60                 if (val < 0 || val > 255)
  61                         continue;
  62
  63                 r = sd_bus_message_append_basic(reply, 'i', &val);
  64                 if (r < 0)
  65                         return r;
  66         }
  67
  68         r = sd_bus_message_close_container(reply);
  69         if (r < 0)
  70                 return r;
  71
  72         r = sd_bus_message_open_container(reply, 'a', "i");
  73         if (r < 0)
  74                 return r;
  75
  76         SET_FOREACH(id, status_set->signal, i) {
  77                 int val = PTR_TO_INT(id);
  78                 const char *str;
  79
  80                 str = signal_to_string(val);
  81                 if (!str)
  82                         continue;
  83
  84                 r = sd_bus_message_append_basic(reply, 'i', &val);
  85                 if (r < 0)
  86                         return r;
  87         }
  88
  89         r = sd_bus_message_close_container(reply);
  90         if (r < 0)
  91                 return r;
  92
  93         return sd_bus_message_close_container(reply);
  94 }
  95
  96 const sd_bus_vtable bus_service_vtable[] = {
  97         SD_BUS_VTABLE_START(0),
  98         SD_BUS_PROPERTY("Type", "s", property_get_type, offsetof(Service, type), SD_BUS_VTABLE_PROPERTY_CONST),
  99         SD_BUS_PROPERTY("Restart", "s", property_get_restart, offsetof(Service, restart), SD_BUS_VTABLE_PROPERTY_CONST),
 100         SD_BUS_PROPERTY("PIDFile", "s", NULL, offsetof(Service, pid_file), SD_BUS_VTABLE_PROPERTY_CONST),
 101         SD_BUS_PROPERTY("NotifyAccess", "s", property_get_notify_access, offsetof(Service, notify_access), SD_BUS_VTABLE_PROPERTY_CONST),
 102         SD_BUS_PROPERTY("RestartUSec", "t", bus_property_get_usec, offsetof(Service, restart_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 103         SD_BUS_PROPERTY("TimeoutStartUSec", "t", bus_property_get_usec, offsetof(Service, timeout_start_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 104         SD_BUS_PROPERTY("TimeoutStopUSec", "t", bus_property_get_usec, offsetof(Service, timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 105         SD_BUS_PROPERTY("RuntimeMaxUSec", "t", bus_property_get_usec, offsetof(Service, runtime_max_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 106         SD_BUS_PROPERTY("WatchdogUSec", "t", bus_property_get_usec, offsetof(Service, watchdog_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 107         BUS_PROPERTY_DUAL_TIMESTAMP("WatchdogTimestamp", offsetof(Service, watchdog_timestamp), 0),
 108         SD_BUS_PROPERTY("PermissionsStartOnly", "b", bus_property_get_bool, offsetof(Service, permissions_start_only), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN), /* 😷 deprecated */
 109         SD_BUS_PROPERTY("RootDirectoryStartOnly", "b", bus_property_get_bool, offsetof(Service, root_directory_start_only), SD_BUS_VTABLE_PROPERTY_CONST),
 110         SD_BUS_PROPERTY("RemainAfterExit", "b", bus_property_get_bool, offsetof(Service, remain_after_exit), SD_BUS_VTABLE_PROPERTY_CONST),
 111         SD_BUS_PROPERTY("GuessMainPID", "b", bus_property_get_bool, offsetof(Service, guess_main_pid), SD_BUS_VTABLE_PROPERTY_CONST),
 112         SD_BUS_PROPERTY("RestartPreventExitStatus", "(aiai)", property_get_exit_status_set, offsetof(Service, restart_prevent_status), SD_BUS_VTABLE_PROPERTY_CONST),
 113         SD_BUS_PROPERTY("RestartForceExitStatus", "(aiai)", property_get_exit_status_set, offsetof(Service, restart_force_status), SD_BUS_VTABLE_PROPERTY_CONST),
 114         SD_BUS_PROPERTY("SuccessExitStatus", "(aiai)", property_get_exit_status_set, offsetof(Service, success_status), SD_BUS_VTABLE_PROPERTY_CONST),
 115         SD_BUS_PROPERTY("MainPID", "u", bus_property_get_pid, offsetof(Service, main_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 116         SD_BUS_PROPERTY("ControlPID", "u", bus_property_get_pid, offsetof(Service, control_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 117         SD_BUS_PROPERTY("BusName", "s", NULL, offsetof(Service, bus_name), SD_BUS_VTABLE_PROPERTY_CONST),
 118         SD_BUS_PROPERTY("FileDescriptorStoreMax", "u", bus_property_get_unsigned, offsetof(Service, n_fd_store_max), SD_BUS_VTABLE_PROPERTY_CONST),
 119         SD_BUS_PROPERTY("NFileDescriptorStore", "u", bus_property_get_unsigned, offsetof(Service, n_fd_store), 0),
 120         SD_BUS_PROPERTY("StatusText", "s", NULL, offsetof(Service, status_text), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 121         SD_BUS_PROPERTY("StatusErrno", "i", bus_property_get_int, offsetof(Service, status_errno), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 122         SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Service, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 123         SD_BUS_PROPERTY("USBFunctionDescriptors", "s", NULL, offsetof(Service, usb_function_descriptors), SD_BUS_VTABLE_PROPERTY_CONST),
 124         SD_BUS_PROPERTY("USBFunctionStrings", "s", NULL, offsetof(Service, usb_function_strings), SD_BUS_VTABLE_PROPERTY_CONST),
 125         SD_BUS_PROPERTY("UID", "u", bus_property_get_uid, offsetof(Unit, ref_uid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 126         SD_BUS_PROPERTY("GID", "u", bus_property_get_gid, offsetof(Unit, ref_gid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 127         SD_BUS_PROPERTY("NRestarts", "u", bus_property_get_unsigned, offsetof(Service, n_restarts), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 128
 129         BUS_EXEC_STATUS_VTABLE("ExecMain", offsetof(Service, main_exec_status), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 130         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPre", offsetof(Service, exec_command[SERVICE_EXEC_START_PRE]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 131         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStart", offsetof(Service, exec_command[SERVICE_EXEC_START]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 132         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPost", offsetof(Service, exec_command[SERVICE_EXEC_START_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 133         BUS_EXEC_COMMAND_LIST_VTABLE("ExecReload", offsetof(Service, exec_command[SERVICE_EXEC_RELOAD]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 134         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStop", offsetof(Service, exec_command[SERVICE_EXEC_STOP]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 135         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStopPost", offsetof(Service, exec_command[SERVICE_EXEC_STOP_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 136
 137         /* The following four are obsolete, and thus marked hidden here. They moved into the Unit interface */
 138         SD_BUS_PROPERTY("StartLimitInterval", "t", bus_property_get_usec, offsetof(Unit, start_limit.interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
 139         SD_BUS_PROPERTY("StartLimitBurst", "u", bus_property_get_unsigned, offsetof(Unit, start_limit.burst), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
 140         SD_BUS_PROPERTY("StartLimitAction", "s", property_get_emergency_action, offsetof(Unit, start_limit_action), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
 141         SD_BUS_PROPERTY("FailureAction", "s", property_get_emergency_action, offsetof(Unit, failure_action), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
 142         SD_BUS_PROPERTY("RebootArgument", "s", NULL, offsetof(Unit, reboot_arg), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
 143         SD_BUS_VTABLE_END
 144 };
 145
 146 static int bus_set_transient_exit_status(
 147                 Unit *u,
 148                 const char *name,
 149                 ExitStatusSet *status_set,
 150                 sd_bus_message *message,
 151                 UnitWriteFlags flags,
 152                 sd_bus_error *error) {
 153
 154         const int *status, *signal;
 155         size_t sz_status, sz_signal, i;
 156         int r;
 157
 158         r = sd_bus_message_enter_container(message, 'r', "aiai");
 159         if (r < 0)
 160                 return r;
 161
 162         r = sd_bus_message_read_array(message, 'i', (const void **) &status, &sz_status);
 163         if (r < 0)
 164                 return r;
 165
 166         r = sd_bus_message_read_array(message, 'i', (const void **) &signal, &sz_signal);
 167         if (r < 0)
 168                 return r;
 169
 170         r = sd_bus_message_exit_container(message);
 171         if (r < 0)
 172                 return r;
 173
 174         if (sz_status == 0 && sz_signal == 0 && !UNIT_WRITE_FLAGS_NOOP(flags)) {
 175                 exit_status_set_free(status_set);
 176                 unit_write_settingf(u, flags, name, "%s=", name);
 177                 return 1;
 178         }
 179
 180         for (i = 0; i < sz_status; i++) {
 181                 if (status[i] < 0 || status[i] > 255)
 182                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid status code in %s: %i", name, status[i]);
 183
 184                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 185                         r = set_ensure_allocated(&status_set->status, NULL);
 186                         if (r < 0)
 187                                 return r;
 188
 189                         r = set_put(status_set->status, INT_TO_PTR(status[i]));
 190                         if (r < 0)
 191                                 return r;
 192
 193                         unit_write_settingf(u, flags, name, "%s=%i", name, status[i]);
 194                 }
 195         }
 196
 197         for (i = 0; i < sz_signal; i++) {
 198                 const char *str;
 199
 200                 str = signal_to_string(signal[i]);
 201                 if (!str)
 202                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal in %s: %i", name, signal[i]);
 203
 204                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 205                         r = set_ensure_allocated(&status_set->signal, NULL);
 206                         if (r < 0)
 207                                 return r;
 208
 209                         r = set_put(status_set->signal, INT_TO_PTR(signal[i]));
 210                         if (r < 0)
 211                                 return r;
 212
 213                         unit_write_settingf(u, flags, name, "%s=%s", name, str);
 214                 }
 215         }
 216
 217         return 1;
 218 }
 219
 220 static int bus_set_transient_std_fd(
 221                 Unit *u,
 222                 const char *name,
 223                 int *p,
 224                 bool *b,
 225                 sd_bus_message *message,
 226                 UnitWriteFlags flags,
 227                 sd_bus_error *error) {
 228
 229         int fd, r;
 230
 231         assert(p);
 232         assert(b);
 233
 234         r = sd_bus_message_read(message, "h", &fd);
 235         if (r < 0)
 236                 return r;
 237
 238         if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 239                 int copy;
 240
 241                 copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
 242                 if (copy < 0)
 243                         return -errno;
 244
 245                 asynchronous_close(*p);
 246                 *p = copy;
 247                 *b = true;
 248         }
 249
 250         return 1;
 251 }
 252 static BUS_DEFINE_SET_TRANSIENT_PARSE(notify_access, NotifyAccess, notify_access_from_string);
 253 static BUS_DEFINE_SET_TRANSIENT_PARSE(service_type, ServiceType, service_type_from_string);
 254 static BUS_DEFINE_SET_TRANSIENT_PARSE(service_restart, ServiceRestart, service_restart_from_string);
 255 static BUS_DEFINE_SET_TRANSIENT_STRING_WITH_CHECK(bus_name, service_name_is_valid);
 256
 257 static int bus_service_set_transient_property(
 258                 Service *s,
 259                 const char *name,
 260                 sd_bus_message *message,
 261                 UnitWriteFlags flags,
 262                 sd_bus_error *error) {
 263
 264         Unit *u = UNIT(s);
 265         ServiceExecCommand ci;
 266         int r;
 267
 268         assert(s);
 269         assert(name);
 270         assert(message);
 271
 272         flags |= UNIT_PRIVATE;
 273
 274         if (streq(name, "PermissionsStartOnly"))
 275                 return bus_set_transient_bool(u, name, &s->permissions_start_only, message, flags, error);
 276
 277         if (streq(name, "RootDirectoryStartOnly"))
 278                 return bus_set_transient_bool(u, name, &s->root_directory_start_only, message, flags, error);
 279
 280         if (streq(name, "RemainAfterExit"))
 281                 return bus_set_transient_bool(u, name, &s->remain_after_exit, message, flags, error);
 282
 283         if (streq(name, "GuessMainPID"))
 284                 return bus_set_transient_bool(u, name, &s->guess_main_pid, message, flags, error);
 285
 286         if (streq(name, "Type"))
 287                 return bus_set_transient_service_type(u, name, &s->type, message, flags, error);
 288
 289         if (streq(name, "RestartUSec"))
 290                 return bus_set_transient_usec(u, name, &s->restart_usec, message, flags, error);
 291
 292         if (streq(name, "TimeoutStartUSec")) {
 293                 r = bus_set_transient_usec(u, name, &s->timeout_start_usec, message, flags, error);
 294                 if (r >= 0 && !UNIT_WRITE_FLAGS_NOOP(flags))
 295                         s->start_timeout_defined = true;
 296
 297                 return r;
 298         }
 299
 300         if (streq(name, "TimeoutStopUSec"))
 301                 return bus_set_transient_usec(u, name, &s->timeout_stop_usec, message, flags, error);
 302
 303         if (streq(name, "RuntimeMaxUSec"))
 304                 return bus_set_transient_usec(u, name, &s->runtime_max_usec, message, flags, error);
 305
 306         if (streq(name, "WatchdogUSec"))
 307                 return bus_set_transient_usec(u, name, &s->watchdog_usec, message, flags, error);
 308
 309         if (streq(name, "FileDescriptorStoreMax"))
 310                 return bus_set_transient_unsigned(u, name, &s->n_fd_store_max, message, flags, error);
 311
 312         if (streq(name, "NotifyAccess"))
 313                 return bus_set_transient_notify_access(u, name, &s->notify_access, message, flags, error);
 314
 315         if (streq(name, "PIDFile")) {
 316                 _cleanup_free_ char *n = NULL;
 317                 const char *v, *e;
 318
 319                 r = sd_bus_message_read(message, "s", &v);
 320                 if (r < 0)
 321                         return r;
 322
 323                 if (!isempty(v)) {
 324                         n = path_make_absolute(v, u->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
 325                         if (!n)
 326                                 return -ENOMEM;
 327
 328                         path_simplify(n, true);
 329
 330                         if (!path_is_normalized(n))
 331                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "PIDFile= path '%s' is not valid", n);
 332
 333                         e = path_startswith(n, "/var/run/");
 334                         if (e) {
 335                                 char *z;
 336
 337                                 z = strjoin("/run/", e);
 338                                 if (!z)
 339                                         return log_oom();
 340
 341                                 if (!UNIT_WRITE_FLAGS_NOOP(flags))
 342                                         log_unit_notice(u, "Transient unit's PIDFile= property references path below legacy directory /var/run, updating %s → %s; please update client accordingly.", n, z);
 343
 344                                 free_and_replace(n, z);
 345                         }
 346                 }
 347
 348                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 349                         free_and_replace(s->pid_file, n);
 350                         unit_write_settingf(u, flags, name, "%s=%s", name, strempty(s->pid_file));
 351                 }
 352
 353                 return 1;
 354         }
 355
 356         if (streq(name, "USBFunctionDescriptors"))
 357                 return bus_set_transient_path(u, name, &s->usb_function_descriptors, message, flags, error);
 358
 359         if (streq(name, "USBFunctionStrings"))
 360                 return bus_set_transient_path(u, name, &s->usb_function_strings, message, flags, error);
 361
 362         if (streq(name, "BusName"))
 363                 return bus_set_transient_bus_name(u, name, &s->bus_name, message, flags, error);
 364
 365         if (streq(name, "Restart"))
 366                 return bus_set_transient_service_restart(u, name, &s->restart, message, flags, error);
 367
 368         if (streq(name, "RestartPreventExitStatus"))
 369                 return bus_set_transient_exit_status(u, name, &s->restart_prevent_status, message, flags, error);
 370
 371         if (streq(name, "RestartForceExitStatus"))
 372                 return bus_set_transient_exit_status(u, name, &s->restart_force_status, message, flags, error);
 373
 374         if (streq(name, "SuccessExitStatus"))
 375                 return bus_set_transient_exit_status(u, name, &s->success_status, message, flags, error);
 376
 377         ci = service_exec_command_from_string(name);
 378         if (ci >= 0)
 379                 return bus_set_transient_exec_command(u, name, &s->exec_command[ci], message, flags, error);
 380
 381         if (streq(name, "StandardInputFileDescriptor"))
 382                 return bus_set_transient_std_fd(u, name, &s->stdin_fd, &s->exec_context.stdio_as_fds, message, flags, error);
 383
 384         if (streq(name, "StandardOutputFileDescriptor"))
 385                 return bus_set_transient_std_fd(u, name, &s->stdout_fd, &s->exec_context.stdio_as_fds, message, flags, error);
 386
 387         if (streq(name, "StandardErrorFileDescriptor"))
 388                 return bus_set_transient_std_fd(u, name, &s->stderr_fd, &s->exec_context.stdio_as_fds, message, flags, error);
 389
 390         return 0;
 391 }
 392
 393 int bus_service_set_property(
 394                 Unit *u,
 395                 const char *name,
 396                 sd_bus_message *message,
 397                 UnitWriteFlags flags,
 398                 sd_bus_error *error) {
 399
 400         Service *s = SERVICE(u);
 401         int r;
 402
 403         assert(s);
 404         assert(name);
 405         assert(message);
 406
 407         r = bus_cgroup_set_property(u, &s->cgroup_context, name, message, flags, error);
 408         if (r != 0)
 409                 return r;
 410
 411         if (u->transient && u->load_state == UNIT_STUB) {
 412                 /* This is a transient unit, let's load a little more */
 413
 414                 r = bus_service_set_transient_property(s, name, message, flags, error);
 415                 if (r != 0)
 416                         return r;
 417
 418                 r = bus_exec_context_set_transient_property(u, &s->exec_context, name, message, flags, error);
 419                 if (r != 0)
 420                         return r;
 421
 422                 r = bus_kill_context_set_transient_property(u, &s->kill_context, name, message, flags, error);
 423                 if (r != 0)
 424                         return r;
 425         }
 426
 427         return 0;
 428 }
 429
 430 int bus_service_commit_properties(Unit *u) {
 431         assert(u);
 432
 433         unit_invalidate_cgroup_members_masks(u);
 434         unit_realize_cgroup(u);
 435
 436         return 0;
 437 }