src/core/dbus-service.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <fcntl.h>
   4
   5 #include "alloc-util.h"
   6 #include "async.h"
   7 #include "bus-common-errors.h"
   8 #include "bus-get-properties.h"
   9 #include "dbus-cgroup.h"
  10 #include "dbus-execute.h"
  11 #include "dbus-kill.h"
  12 #include "dbus-manager.h"
  13 #include "dbus-service.h"
  14 #include "dbus-util.h"
  15 #include "execute.h"
  16 #include "exit-status.h"
  17 #include "fd-util.h"
  18 #include "fileio.h"
  19 #include "locale-util.h"
  20 #include "missing_fcntl.h"
  21 #include "mount-util.h"
  22 #include "open-file.h"
  23 #include "parse-util.h"
  24 #include "path-util.h"
  25 #include "selinux-access.h"
  26 #include "service.h"
  27 #include "signal-util.h"
  28 #include "string-util.h"
  29 #include "strv.h"
  30 #include "unit.h"
  31
  32 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, service_type, ServiceType);
  33 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exit_type, service_exit_type, ServiceExitType);
  34 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, service_result, ServiceResult);
  35 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_restart, service_restart, ServiceRestart);
  36 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_restart_mode, service_restart_mode, ServiceRestartMode);
  37 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_emergency_action, emergency_action, EmergencyAction);
  38 static BUS_DEFINE_PROPERTY_GET2(property_get_notify_access, "s", Service, service_get_notify_access, notify_access_to_string);
  39 static BUS_DEFINE_PROPERTY_GET(property_get_restart_usec_next, "t", Service, service_restart_usec_next);
  40 static BUS_DEFINE_PROPERTY_GET(property_get_timeout_abort_usec, "t", Service, service_timeout_abort_usec);
  41 static BUS_DEFINE_PROPERTY_GET(property_get_watchdog_usec, "t", Service, service_get_watchdog_usec);
  42 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_timeout_failure_mode, service_timeout_failure_mode, ServiceTimeoutFailureMode);
  43
  44 static int property_get_open_files(
  45                 sd_bus *bus,
  46                 const char *path,
  47                 const char *interface,
  48                 const char *property,
  49                 sd_bus_message *reply,
  50                 void *userdata,
  51                 sd_bus_error *error) {
  52
  53         OpenFile **open_files = ASSERT_PTR(userdata);
  54         int r;
  55
  56         assert(bus);
  57         assert(reply);
  58
  59         r = sd_bus_message_open_container(reply, 'a', "(sst)");
  60         if (r < 0)
  61                 return r;
  62
  63         LIST_FOREACH(open_files, of, *open_files) {
  64                 r = sd_bus_message_append(reply, "(sst)", of->path, of->fdname, of->flags);
  65                 if (r < 0)
  66                         return r;
  67         }
  68
  69         return sd_bus_message_close_container(reply);
  70 }
  71
  72 static int property_get_exit_status_set(
  73                 sd_bus *bus,
  74                 const char *path,
  75                 const char *interface,
  76                 const char *property,
  77                 sd_bus_message *reply,
  78                 void *userdata,
  79                 sd_bus_error *error) {
  80
  81         const ExitStatusSet *status_set = ASSERT_PTR(userdata);
  82         unsigned n;
  83         int r;
  84
  85         assert(bus);
  86         assert(reply);
  87
  88         r = sd_bus_message_open_container(reply, 'r', "aiai");
  89         if (r < 0)
  90                 return r;
  91
  92         r = sd_bus_message_open_container(reply, 'a', "i");
  93         if (r < 0)
  94                 return r;
  95
  96         BITMAP_FOREACH(n, &status_set->status) {
  97                 assert(n < 256);
  98
  99                 r = sd_bus_message_append_basic(reply, 'i', &n);
 100                 if (r < 0)
 101                         return r;
 102         }
 103
 104         r = sd_bus_message_close_container(reply);
 105         if (r < 0)
 106                 return r;
 107
 108         r = sd_bus_message_open_container(reply, 'a', "i");
 109         if (r < 0)
 110                 return r;
 111
 112         BITMAP_FOREACH(n, &status_set->signal) {
 113                 const char *str;
 114
 115                 str = signal_to_string(n);
 116                 if (!str)
 117                         continue;
 118
 119                 r = sd_bus_message_append_basic(reply, 'i', &n);
 120                 if (r < 0)
 121                         return r;
 122         }
 123
 124         r = sd_bus_message_close_container(reply);
 125         if (r < 0)
 126                 return r;
 127
 128         return sd_bus_message_close_container(reply);
 129 }
 130
 131 static int bus_service_method_mount(sd_bus_message *message, void *userdata, sd_bus_error *error, bool is_image) {
 132         _cleanup_(mount_options_free_allp) MountOptions *options = NULL;
 133         const char *dest, *src, *propagate_directory;
 134         int read_only, make_file_or_directory;
 135         Unit *u = ASSERT_PTR(userdata);
 136         ExecContext *c;
 137         int r;
 138
 139         assert(message);
 140
 141         if (!MANAGER_IS_SYSTEM(u->manager))
 142                 return sd_bus_error_set(error, SD_BUS_ERROR_NOT_SUPPORTED, "Adding bind mounts at runtime is only supported for system managers.");
 143
 144         r = mac_selinux_unit_access_check(u, message, "start", error);
 145         if (r < 0)
 146                 return r;
 147
 148         r = sd_bus_message_read(message, "ssbb", &src, &dest, &read_only, &make_file_or_directory);
 149         if (r < 0)
 150                 return r;
 151
 152         if (!path_is_absolute(src) || !path_is_normalized(src))
 153                 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Source path must be absolute and normalized.");
 154
 155         if (!is_image && isempty(dest))
 156                 dest = src;
 157         else if (!path_is_absolute(dest) || !path_is_normalized(dest))
 158                 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Destination path must be absolute and normalized.");
 159
 160         if (is_image) {
 161                 r = bus_read_mount_options(message, error, &options, NULL, "");
 162                 if (r < 0)
 163                         return r;
 164         }
 165
 166         r = bus_verify_manage_units_async_full(
 167                         u,
 168                         is_image ? "mount-image" : "bind-mount",
 169                         CAP_SYS_ADMIN,
 170                         N_("Authentication is required to mount on '$(unit)'."),
 171                         true,
 172                         message,
 173                         error);
 174         if (r < 0)
 175                 return r;
 176         if (r == 0)
 177                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
 178
 179         if (u->type != UNIT_SERVICE)
 180                 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Unit is not of type .service");
 181
 182         /* If it would be dropped at startup time, return an error. The context should always be available, but
 183          * there's an assert in exec_needs_mount_namespace, so double-check just in case. */
 184         c = unit_get_exec_context(u);
 185         if (!c)
 186                 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Cannot access unit execution context");
 187         if (path_startswith_strv(dest, c->inaccessible_paths))
 188                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "%s is not accessible to this unit", dest);
 189
 190         /* Ensure that the unit was started in a private mount namespace */
 191         if (!exec_needs_mount_namespace(c, NULL, unit_get_exec_runtime(u)))
 192                 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Unit not running in private mount namespace, cannot activate bind mount");
 193
 194         PidRef* unit_pid = unit_main_pid(u);
 195         if (!pidref_is_set(unit_pid) || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
 196                 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Unit is not running");
 197
 198         propagate_directory = strjoina("/run/systemd/propagate/", u->id);
 199         if (is_image)
 200                 r = mount_image_in_namespace(
 201                                 unit_pid->pid,
 202                                 propagate_directory,
 203                                 "/run/systemd/incoming/",
 204                                 src, dest,
 205                                 read_only,
 206                                 make_file_or_directory,
 207                                 options,
 208                                 c->mount_image_policy ?: &image_policy_service);
 209         else
 210                 r = bind_mount_in_namespace(
 211                                 unit_pid->pid,
 212                                 propagate_directory,
 213                                 "/run/systemd/incoming/",
 214                                 src, dest,
 215                                 read_only,
 216                                 make_file_or_directory);
 217         if (r < 0)
 218                 return sd_bus_error_set_errnof(error, r, "Failed to mount %s on %s in unit's namespace: %m", src, dest);
 219
 220         return sd_bus_reply_method_return(message, NULL);
 221 }
 222
 223 int bus_service_method_bind_mount(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 224         return bus_service_method_mount(message, userdata, error, false);
 225 }
 226
 227 int bus_service_method_mount_image(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 228         return bus_service_method_mount(message, userdata, error, true);
 229 }
 230
 231 int bus_service_method_dump_file_descriptor_store(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 232         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 233         Service *s = ASSERT_PTR(userdata);
 234         int r;
 235
 236         assert(message);
 237
 238         r = mac_selinux_unit_access_check(UNIT(s), message, "status", error);
 239         if (r < 0)
 240                 return r;
 241
 242         if (s->n_fd_store_max == 0 && s->n_fd_store == 0)
 243                 return sd_bus_error_setf(error, BUS_ERROR_FILE_DESCRIPTOR_STORE_DISABLED, "File descriptor store not enabled for %s.", UNIT(s)->id);
 244
 245         r = sd_bus_message_new_method_return(message, &reply);
 246         if (r < 0)
 247                 return r;
 248
 249         r = sd_bus_message_open_container(reply, 'a', "(suuutuusu)");
 250         if (r < 0)
 251                 return r;
 252
 253         LIST_FOREACH(fd_store, i, s->fd_store) {
 254                 _cleanup_free_ char *path = NULL;
 255                 struct stat st;
 256                 int flags;
 257
 258                 if (fstat(i->fd, &st) < 0) {
 259                         log_debug_errno(errno, "Failed to stat() file descriptor entry '%s', skipping.", strna(i->fdname));
 260                         continue;
 261                 }
 262
 263                 flags = fcntl(i->fd, F_GETFL);
 264                 if (flags < 0) {
 265                         log_debug_errno(errno, "Failed to issue F_GETFL on file descriptor entry '%s', skipping.", strna(i->fdname));
 266                         continue;
 267                 }
 268
 269                 /* glibc implies O_LARGEFILE everywhere on 64-bit off_t builds, but forgets to hide it away on
 270                  * F_GETFL, but provides no definition to check for that. Let's mask the flag away manually,
 271                  * to not confuse clients. */
 272                 flags &= ~RAW_O_LARGEFILE;
 273
 274                 (void) fd_get_path(i->fd, &path);
 275
 276                 r = sd_bus_message_append(
 277                                 reply,
 278                                 "(suuutuusu)",
 279                                 i->fdname,
 280                                 (uint32_t) st.st_mode,
 281                                 (uint32_t) major(st.st_dev), (uint32_t) minor(st.st_dev),
 282                                 (uint64_t) st.st_ino,
 283                                 (uint32_t) major(st.st_rdev), (uint32_t) minor(st.st_rdev),
 284                                 path,
 285                                 (uint32_t) flags);
 286                 if (r < 0)
 287                         return r;
 288         }
 289
 290         r = sd_bus_message_close_container(reply);
 291         if (r < 0)
 292                 return r;
 293
 294         return sd_bus_send(NULL, reply, NULL);
 295 }
 296
 297 #if __SIZEOF_SIZE_T__ == 8
 298 static int property_get_size_as_uint32(
 299                 sd_bus *bus,
 300                 const char *path,
 301                 const char *interface,
 302                 const char *property,
 303                 sd_bus_message *reply,
 304                 void *userdata,
 305                 sd_bus_error *error) {
 306
 307         size_t *value = ASSERT_PTR(userdata);
 308         uint32_t sz = *value >= UINT32_MAX ? UINT32_MAX : (uint32_t) *value;
 309
 310         /* Returns a size_t as a D-Bus "u" type, i.e. as 32-bit value, even if size_t is 64-bit. We'll saturate if it doesn't fit. */
 311
 312         return sd_bus_message_append_basic(reply, 'u', &sz);
 313 }
 314 #elif __SIZEOF_SIZE_T__ == 4
 315 #define property_get_size_as_uint32 ((sd_bus_property_get_t) NULL)
 316 #else
 317 #error "Unexpected size of size_t"
 318 #endif
 319
 320 const sd_bus_vtable bus_service_vtable[] = {
 321         SD_BUS_VTABLE_START(0),
 322         SD_BUS_PROPERTY("Type", "s", property_get_type, offsetof(Service, type), SD_BUS_VTABLE_PROPERTY_CONST),
 323         SD_BUS_PROPERTY("ExitType", "s", property_get_exit_type, offsetof(Service, exit_type), SD_BUS_VTABLE_PROPERTY_CONST),
 324         SD_BUS_PROPERTY("Restart", "s", property_get_restart, offsetof(Service, restart), SD_BUS_VTABLE_PROPERTY_CONST),
 325         SD_BUS_PROPERTY("RestartMode", "s", property_get_restart_mode, offsetof(Service, restart_mode), SD_BUS_VTABLE_PROPERTY_CONST),
 326         SD_BUS_PROPERTY("PIDFile", "s", NULL, offsetof(Service, pid_file), SD_BUS_VTABLE_PROPERTY_CONST),
 327         SD_BUS_PROPERTY("NotifyAccess", "s", property_get_notify_access, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 328         SD_BUS_PROPERTY("RestartUSec", "t", bus_property_get_usec, offsetof(Service, restart_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 329         SD_BUS_PROPERTY("RestartSteps", "u", bus_property_get_unsigned, offsetof(Service, restart_steps), SD_BUS_VTABLE_PROPERTY_CONST),
 330         SD_BUS_PROPERTY("RestartMaxDelayUSec", "t", bus_property_get_usec, offsetof(Service, restart_max_delay_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 331         SD_BUS_PROPERTY("RestartUSecNext", "t", property_get_restart_usec_next, 0, 0),
 332         SD_BUS_PROPERTY("TimeoutStartUSec", "t", bus_property_get_usec, offsetof(Service, timeout_start_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 333         SD_BUS_PROPERTY("TimeoutStopUSec", "t", bus_property_get_usec, offsetof(Service, timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 334         SD_BUS_PROPERTY("TimeoutAbortUSec", "t", property_get_timeout_abort_usec, 0, 0),
 335         SD_BUS_PROPERTY("TimeoutStartFailureMode", "s", property_get_timeout_failure_mode, offsetof(Service, timeout_start_failure_mode), SD_BUS_VTABLE_PROPERTY_CONST),
 336         SD_BUS_PROPERTY("TimeoutStopFailureMode", "s", property_get_timeout_failure_mode, offsetof(Service, timeout_stop_failure_mode), SD_BUS_VTABLE_PROPERTY_CONST),
 337         SD_BUS_PROPERTY("RuntimeMaxUSec", "t", bus_property_get_usec, offsetof(Service, runtime_max_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 338         SD_BUS_PROPERTY("RuntimeRandomizedExtraUSec", "t", bus_property_get_usec, offsetof(Service, runtime_rand_extra_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 339         SD_BUS_PROPERTY("WatchdogUSec", "t", property_get_watchdog_usec, 0, 0),
 340         BUS_PROPERTY_DUAL_TIMESTAMP("WatchdogTimestamp", offsetof(Service, watchdog_timestamp), 0),
 341         SD_BUS_PROPERTY("PermissionsStartOnly", "b", bus_property_get_bool, offsetof(Service, permissions_start_only), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN), /* 😷 deprecated */
 342         SD_BUS_PROPERTY("RootDirectoryStartOnly", "b", bus_property_get_bool, offsetof(Service, root_directory_start_only), SD_BUS_VTABLE_PROPERTY_CONST),
 343         SD_BUS_PROPERTY("RemainAfterExit", "b", bus_property_get_bool, offsetof(Service, remain_after_exit), SD_BUS_VTABLE_PROPERTY_CONST),
 344         SD_BUS_PROPERTY("GuessMainPID", "b", bus_property_get_bool, offsetof(Service, guess_main_pid), SD_BUS_VTABLE_PROPERTY_CONST),
 345         SD_BUS_PROPERTY("RestartPreventExitStatus", "(aiai)", property_get_exit_status_set, offsetof(Service, restart_prevent_status), SD_BUS_VTABLE_PROPERTY_CONST),
 346         SD_BUS_PROPERTY("RestartForceExitStatus", "(aiai)", property_get_exit_status_set, offsetof(Service, restart_force_status), SD_BUS_VTABLE_PROPERTY_CONST),
 347         SD_BUS_PROPERTY("SuccessExitStatus", "(aiai)", property_get_exit_status_set, offsetof(Service, success_status), SD_BUS_VTABLE_PROPERTY_CONST),
 348         SD_BUS_PROPERTY("MainPID", "u", bus_property_get_pid, offsetof(Service, main_pid.pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 349         SD_BUS_PROPERTY("ControlPID", "u", bus_property_get_pid, offsetof(Service, control_pid.pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 350         SD_BUS_PROPERTY("BusName", "s", NULL, offsetof(Service, bus_name), SD_BUS_VTABLE_PROPERTY_CONST),
 351         SD_BUS_PROPERTY("FileDescriptorStoreMax", "u", bus_property_get_unsigned, offsetof(Service, n_fd_store_max), SD_BUS_VTABLE_PROPERTY_CONST),
 352         SD_BUS_PROPERTY("NFileDescriptorStore", "u", property_get_size_as_uint32, offsetof(Service, n_fd_store), 0),
 353         SD_BUS_PROPERTY("FileDescriptorStorePreserve", "s", bus_property_get_exec_preserve_mode, offsetof(Service, fd_store_preserve_mode), 0),
 354         SD_BUS_PROPERTY("StatusText", "s", NULL, offsetof(Service, status_text), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 355         SD_BUS_PROPERTY("StatusErrno", "i", bus_property_get_int, offsetof(Service, status_errno), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 356         SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Service, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 357         SD_BUS_PROPERTY("ReloadResult", "s", property_get_result, offsetof(Service, reload_result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 358         SD_BUS_PROPERTY("CleanResult", "s", property_get_result, offsetof(Service, clean_result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 359         SD_BUS_PROPERTY("USBFunctionDescriptors", "s", NULL, offsetof(Service, usb_function_descriptors), SD_BUS_VTABLE_PROPERTY_CONST),
 360         SD_BUS_PROPERTY("USBFunctionStrings", "s", NULL, offsetof(Service, usb_function_strings), SD_BUS_VTABLE_PROPERTY_CONST),
 361         SD_BUS_PROPERTY("UID", "u", bus_property_get_uid, offsetof(Unit, ref_uid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 362         SD_BUS_PROPERTY("GID", "u", bus_property_get_gid, offsetof(Unit, ref_gid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 363         SD_BUS_PROPERTY("NRestarts", "u", bus_property_get_unsigned, offsetof(Service, n_restarts), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 364         SD_BUS_PROPERTY("OOMPolicy", "s", bus_property_get_oom_policy, offsetof(Service, oom_policy), SD_BUS_VTABLE_PROPERTY_CONST),
 365         SD_BUS_PROPERTY("OpenFile", "a(sst)", property_get_open_files, offsetof(Service, open_files), SD_BUS_VTABLE_PROPERTY_CONST),
 366         SD_BUS_PROPERTY("ReloadSignal", "i", bus_property_get_int, offsetof(Service, reload_signal), SD_BUS_VTABLE_PROPERTY_CONST),
 367
 368         BUS_EXEC_STATUS_VTABLE("ExecMain", offsetof(Service, main_exec_status), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 369         BUS_EXEC_COMMAND_LIST_VTABLE("ExecCondition", offsetof(Service, exec_command[SERVICE_EXEC_CONDITION]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 370         BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecConditionEx", offsetof(Service, exec_command[SERVICE_EXEC_CONDITION]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 371         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPre", offsetof(Service, exec_command[SERVICE_EXEC_START_PRE]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 372         BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStartPreEx", offsetof(Service, exec_command[SERVICE_EXEC_START_PRE]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 373         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStart", offsetof(Service, exec_command[SERVICE_EXEC_START]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 374         BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStartEx", offsetof(Service, exec_command[SERVICE_EXEC_START]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 375         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPost", offsetof(Service, exec_command[SERVICE_EXEC_START_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 376         BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStartPostEx", offsetof(Service, exec_command[SERVICE_EXEC_START_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 377         BUS_EXEC_COMMAND_LIST_VTABLE("ExecReload", offsetof(Service, exec_command[SERVICE_EXEC_RELOAD]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 378         BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecReloadEx", offsetof(Service, exec_command[SERVICE_EXEC_RELOAD]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 379         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStop", offsetof(Service, exec_command[SERVICE_EXEC_STOP]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 380         BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStopEx", offsetof(Service, exec_command[SERVICE_EXEC_STOP]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 381         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStopPost", offsetof(Service, exec_command[SERVICE_EXEC_STOP_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 382         BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStopPostEx", offsetof(Service, exec_command[SERVICE_EXEC_STOP_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 383
 384         SD_BUS_METHOD_WITH_ARGS("BindMount",
 385                                 SD_BUS_ARGS("s", source, "s", destination, "b", read_only, "b", mkdir),
 386                                 SD_BUS_NO_RESULT,
 387                                 bus_service_method_bind_mount,
 388                                 SD_BUS_VTABLE_UNPRIVILEGED),
 389
 390         SD_BUS_METHOD_WITH_ARGS("MountImage",
 391                                  SD_BUS_ARGS("s", source, "s", destination, "b", read_only, "b", mkdir, "a(ss)", options),
 392                                  SD_BUS_NO_RESULT,
 393                                  bus_service_method_mount_image,
 394                                  SD_BUS_VTABLE_UNPRIVILEGED),
 395
 396         SD_BUS_METHOD_WITH_ARGS("DumpFileDescriptorStore",
 397                                 SD_BUS_NO_ARGS,
 398                                 SD_BUS_ARGS("a(suuutuusu)", entries),
 399                                 bus_service_method_dump_file_descriptor_store,
 400                                 SD_BUS_VTABLE_UNPRIVILEGED),
 401
 402         /* The following four are obsolete, and thus marked hidden here. They moved into the Unit interface */
 403         SD_BUS_PROPERTY("StartLimitInterval", "t", bus_property_get_usec, offsetof(Unit, start_ratelimit.interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
 404         SD_BUS_PROPERTY("StartLimitBurst", "u", bus_property_get_unsigned, offsetof(Unit, start_ratelimit.burst), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
 405         SD_BUS_PROPERTY("StartLimitAction", "s", property_get_emergency_action, offsetof(Unit, start_limit_action), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
 406         SD_BUS_PROPERTY("FailureAction", "s", property_get_emergency_action, offsetof(Unit, failure_action), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
 407         SD_BUS_PROPERTY("RebootArgument", "s", NULL, offsetof(Unit, reboot_arg), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
 408         SD_BUS_VTABLE_END
 409 };
 410
 411 static int bus_set_transient_exit_status(
 412                 Unit *u,
 413                 const char *name,
 414                 ExitStatusSet *status_set,
 415                 sd_bus_message *message,
 416                 UnitWriteFlags flags,
 417                 sd_bus_error *error) {
 418
 419         const int32_t *status, *signal;
 420         size_t n_status, n_signal, i;
 421         int r;
 422
 423         r = sd_bus_message_enter_container(message, 'r', "aiai");
 424         if (r < 0)
 425                 return r;
 426
 427         r = sd_bus_message_read_array(message, 'i', (const void **) &status, &n_status);
 428         if (r < 0)
 429                 return r;
 430
 431         r = sd_bus_message_read_array(message, 'i', (const void **) &signal, &n_signal);
 432         if (r < 0)
 433                 return r;
 434
 435         r = sd_bus_message_exit_container(message);
 436         if (r < 0)
 437                 return r;
 438
 439         n_status /= sizeof(int32_t);
 440         n_signal /= sizeof(int32_t);
 441
 442         if (n_status == 0 && n_signal == 0 && !UNIT_WRITE_FLAGS_NOOP(flags)) {
 443                 exit_status_set_free(status_set);
 444                 unit_write_settingf(u, flags, name, "%s=", name);
 445                 return 1;
 446         }
 447
 448         for (i = 0; i < n_status; i++) {
 449                 if (status[i] < 0 || status[i] > 255)
 450                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid status code in %s: %"PRIi32, name, status[i]);
 451
 452                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 453                         r = bitmap_set(&status_set->status, status[i]);
 454                         if (r < 0)
 455                                 return r;
 456
 457                         unit_write_settingf(u, flags, name, "%s=%"PRIi32, name, status[i]);
 458                 }
 459         }
 460
 461         for (i = 0; i < n_signal; i++) {
 462                 const char *str;
 463
 464                 str = signal_to_string((int) signal[i]);
 465                 if (!str)
 466                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal in %s: %"PRIi32, name, signal[i]);
 467
 468                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 469                         r = bitmap_set(&status_set->signal, signal[i]);
 470                         if (r < 0)
 471                                 return r;
 472
 473                         unit_write_settingf(u, flags, name, "%s=%s", name, str);
 474                 }
 475         }
 476
 477         return 1;
 478 }
 479
 480 static int bus_set_transient_std_fd(
 481                 Unit *u,
 482                 const char *name,
 483                 int *p,
 484                 bool *b,
 485                 sd_bus_message *message,
 486                 UnitWriteFlags flags,
 487                 sd_bus_error *error) {
 488
 489         int fd, r;
 490
 491         assert(p);
 492         assert(b);
 493
 494         r = sd_bus_message_read(message, "h", &fd);
 495         if (r < 0)
 496                 return r;
 497
 498         if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 499                 int copy;
 500
 501                 copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
 502                 if (copy < 0)
 503                         return -errno;
 504
 505                 asynchronous_close(*p);
 506                 *p = copy;
 507                 *b = true;
 508         }
 509
 510         return 1;
 511 }
 512 static BUS_DEFINE_SET_TRANSIENT_PARSE(notify_access, NotifyAccess, notify_access_from_string);
 513 static BUS_DEFINE_SET_TRANSIENT_PARSE(service_type, ServiceType, service_type_from_string);
 514 static BUS_DEFINE_SET_TRANSIENT_PARSE(service_exit_type, ServiceExitType, service_exit_type_from_string);
 515 static BUS_DEFINE_SET_TRANSIENT_PARSE(service_restart, ServiceRestart, service_restart_from_string);
 516 static BUS_DEFINE_SET_TRANSIENT_PARSE(service_restart_mode, ServiceRestartMode, service_restart_mode_from_string);
 517 static BUS_DEFINE_SET_TRANSIENT_PARSE(oom_policy, OOMPolicy, oom_policy_from_string);
 518 static BUS_DEFINE_SET_TRANSIENT_STRING_WITH_CHECK(bus_name, sd_bus_service_name_is_valid);
 519 static BUS_DEFINE_SET_TRANSIENT_PARSE(timeout_failure_mode, ServiceTimeoutFailureMode, service_timeout_failure_mode_from_string);
 520 static BUS_DEFINE_SET_TRANSIENT_TO_STRING(reload_signal, "i", int32_t, int, "%" PRIi32, signal_to_string_with_check);
 521
 522 static int bus_service_set_transient_property(
 523                 Service *s,
 524                 const char *name,
 525                 sd_bus_message *message,
 526                 UnitWriteFlags flags,
 527                 sd_bus_error *error) {
 528
 529         Unit *u = UNIT(s);
 530         ServiceExecCommand ci;
 531         int r;
 532
 533         assert(s);
 534         assert(name);
 535         assert(message);
 536
 537         flags |= UNIT_PRIVATE;
 538
 539         if (streq(name, "PermissionsStartOnly"))
 540                 return bus_set_transient_bool(u, name, &s->permissions_start_only, message, flags, error);
 541
 542         if (streq(name, "RootDirectoryStartOnly"))
 543                 return bus_set_transient_bool(u, name, &s->root_directory_start_only, message, flags, error);
 544
 545         if (streq(name, "RemainAfterExit"))
 546                 return bus_set_transient_bool(u, name, &s->remain_after_exit, message, flags, error);
 547
 548         if (streq(name, "GuessMainPID"))
 549                 return bus_set_transient_bool(u, name, &s->guess_main_pid, message, flags, error);
 550
 551         if (streq(name, "Type"))
 552                 return bus_set_transient_service_type(u, name, &s->type, message, flags, error);
 553
 554         if (streq(name, "ExitType"))
 555                 return bus_set_transient_service_exit_type(u, name, &s->exit_type, message, flags, error);
 556
 557         if (streq(name, "OOMPolicy"))
 558                 return bus_set_transient_oom_policy(u, name, &s->oom_policy, message, flags, error);
 559
 560         if (streq(name, "RestartUSec"))
 561                 return bus_set_transient_usec(u, name, &s->restart_usec, message, flags, error);
 562
 563         if (streq(name, "RestartSteps"))
 564                 return bus_set_transient_unsigned(u, name, &s->restart_steps, message, flags, error);
 565
 566         if (streq(name, "RestartMaxDelayUSec"))
 567                 return bus_set_transient_usec(u, name, &s->restart_max_delay_usec, message, flags, error);
 568
 569         if (streq(name, "TimeoutStartUSec")) {
 570                 r = bus_set_transient_usec(u, name, &s->timeout_start_usec, message, flags, error);
 571                 if (r >= 0 && !UNIT_WRITE_FLAGS_NOOP(flags))
 572                         s->start_timeout_defined = true;
 573
 574                 return r;
 575         }
 576
 577         if (streq(name, "TimeoutStopUSec"))
 578                 return bus_set_transient_usec(u, name, &s->timeout_stop_usec, message, flags, error);
 579
 580         if (streq(name, "TimeoutAbortUSec")) {
 581                 r = bus_set_transient_usec(u, name, &s->timeout_abort_usec, message, flags, error);
 582                 if (r >= 0 && !UNIT_WRITE_FLAGS_NOOP(flags))
 583                         s->timeout_abort_set = true;
 584                 return r;
 585         }
 586
 587         if (streq(name, "TimeoutStartFailureMode"))
 588                 return bus_set_transient_timeout_failure_mode(u, name, &s->timeout_start_failure_mode, message, flags, error);
 589
 590         if (streq(name, "TimeoutStopFailureMode"))
 591                 return bus_set_transient_timeout_failure_mode(u, name, &s->timeout_stop_failure_mode, message, flags, error);
 592
 593         if (streq(name, "RuntimeMaxUSec"))
 594                 return bus_set_transient_usec(u, name, &s->runtime_max_usec, message, flags, error);
 595
 596         if (streq(name, "RuntimeRandomizedExtraUSec"))
 597                 return bus_set_transient_usec(u, name, &s->runtime_rand_extra_usec, message, flags, error);
 598
 599         if (streq(name, "WatchdogUSec"))
 600                 return bus_set_transient_usec(u, name, &s->watchdog_usec, message, flags, error);
 601
 602         if (streq(name, "FileDescriptorStoreMax"))
 603                 return bus_set_transient_unsigned(u, name, &s->n_fd_store_max, message, flags, error);
 604
 605         if (streq(name, "FileDescriptorStorePreserve"))
 606                 return bus_set_transient_exec_preserve_mode(u, name, &s->fd_store_preserve_mode, message, flags, error);
 607
 608         if (streq(name, "NotifyAccess"))
 609                 return bus_set_transient_notify_access(u, name, &s->notify_access, message, flags, error);
 610
 611         if (streq(name, "PIDFile")) {
 612                 _cleanup_free_ char *n = NULL;
 613                 const char *v, *e;
 614
 615                 r = sd_bus_message_read(message, "s", &v);
 616                 if (r < 0)
 617                         return r;
 618
 619                 if (!isempty(v)) {
 620                         n = path_make_absolute(v, u->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
 621                         if (!n)
 622                                 return -ENOMEM;
 623
 624                         path_simplify(n);
 625
 626                         if (!path_is_normalized(n))
 627                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "PIDFile= path '%s' is not valid", n);
 628
 629                         e = path_startswith(n, "/var/run/");
 630                         if (e) {
 631                                 char *z;
 632
 633                                 z = path_join("/run", e);
 634                                 if (!z)
 635                                         return log_oom();
 636
 637                                 if (!UNIT_WRITE_FLAGS_NOOP(flags))
 638                                         log_unit_notice(u, "Transient unit's PIDFile= property references path below legacy directory /var/run, updating %s %s %s; please update client accordingly.",
 639                                                         n, special_glyph(SPECIAL_GLYPH_ARROW_RIGHT), z);
 640
 641                                 free_and_replace(n, z);
 642                         }
 643                 }
 644
 645                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 646                         free_and_replace(s->pid_file, n);
 647                         unit_write_settingf(u, flags, name, "%s=%s", name, strempty(s->pid_file));
 648                 }
 649
 650                 return 1;
 651         }
 652
 653         if (streq(name, "USBFunctionDescriptors"))
 654                 return bus_set_transient_path(u, name, &s->usb_function_descriptors, message, flags, error);
 655
 656         if (streq(name, "USBFunctionStrings"))
 657                 return bus_set_transient_path(u, name, &s->usb_function_strings, message, flags, error);
 658
 659         if (streq(name, "BusName"))
 660                 return bus_set_transient_bus_name(u, name, &s->bus_name, message, flags, error);
 661
 662         if (streq(name, "Restart"))
 663                 return bus_set_transient_service_restart(u, name, &s->restart, message, flags, error);
 664
 665         if (streq(name, "RestartMode"))
 666                 return bus_set_transient_service_restart_mode(u, name, &s->restart_mode, message, flags, error);
 667
 668         if (streq(name, "RestartPreventExitStatus"))
 669                 return bus_set_transient_exit_status(u, name, &s->restart_prevent_status, message, flags, error);
 670
 671         if (streq(name, "RestartForceExitStatus"))
 672                 return bus_set_transient_exit_status(u, name, &s->restart_force_status, message, flags, error);
 673
 674         if (streq(name, "SuccessExitStatus"))
 675                 return bus_set_transient_exit_status(u, name, &s->success_status, message, flags, error);
 676
 677         ci = service_exec_command_from_string(name);
 678         if (ci < 0)
 679                 ci = service_exec_ex_command_from_string(name);
 680         if (ci >= 0)
 681                 return bus_set_transient_exec_command(u, name, &s->exec_command[ci], message, flags, error);
 682
 683         if (streq(name, "StandardInputFileDescriptor"))
 684                 return bus_set_transient_std_fd(u, name, &s->stdin_fd, &s->exec_context.stdio_as_fds, message, flags, error);
 685
 686         if (streq(name, "StandardOutputFileDescriptor"))
 687                 return bus_set_transient_std_fd(u, name, &s->stdout_fd, &s->exec_context.stdio_as_fds, message, flags, error);
 688
 689         if (streq(name, "StandardErrorFileDescriptor"))
 690                 return bus_set_transient_std_fd(u, name, &s->stderr_fd, &s->exec_context.stdio_as_fds, message, flags, error);
 691
 692         if (streq(name, "OpenFile")) {
 693                 const char *path, *fdname;
 694                 uint64_t offlags;
 695
 696                 r = sd_bus_message_enter_container(message, 'a', "(sst)");
 697                 if (r < 0)
 698                         return r;
 699
 700                 while ((r = sd_bus_message_read(message, "(sst)", &path, &fdname, &offlags)) > 0) {
 701                         _cleanup_(open_file_freep) OpenFile *of = NULL;
 702                         _cleanup_free_ char *ofs = NULL;
 703
 704                         of = new(OpenFile, 1);
 705                         if (!of)
 706                                 return -ENOMEM;
 707
 708                         *of = (OpenFile) {
 709                                 .path = strdup(path),
 710                                 .fdname = strdup(fdname),
 711                                 .flags = offlags,
 712                         };
 713
 714                         if (!of->path || !of->fdname)
 715                                 return -ENOMEM;
 716
 717                         r = open_file_validate(of);
 718                         if (r < 0)
 719                                 return r;
 720
 721                         if (UNIT_WRITE_FLAGS_NOOP(flags))
 722                                 continue;
 723
 724                         r = open_file_to_string(of, &ofs);
 725                         if (r < 0)
 726                                 return sd_bus_error_set_errnof(
 727                                                 error, r, "Failed to convert OpenFile= value to string: %m");
 728
 729                         LIST_APPEND(open_files, s->open_files, TAKE_PTR(of));
 730                         unit_write_settingf(u, flags | UNIT_ESCAPE_SPECIFIERS, name, "OpenFile=%s", ofs);
 731                 }
 732                 if (r < 0)
 733                         return r;
 734
 735                 r = sd_bus_message_exit_container(message);
 736                 if (r < 0)
 737                         return r;
 738
 739                 return 1;
 740         }
 741
 742         if (streq(name, "ReloadSignal"))
 743                 return bus_set_transient_reload_signal(u, name, &s->reload_signal, message, flags, error);
 744
 745         return 0;
 746 }
 747
 748 int bus_service_set_property(
 749                 Unit *u,
 750                 const char *name,
 751                 sd_bus_message *message,
 752                 UnitWriteFlags flags,
 753                 sd_bus_error *error) {
 754
 755         Service *s = SERVICE(u);
 756         int r;
 757
 758         assert(s);
 759         assert(name);
 760         assert(message);
 761
 762         r = bus_cgroup_set_property(u, &s->cgroup_context, name, message, flags, error);
 763         if (r != 0)
 764                 return r;
 765
 766         if (u->transient && u->load_state == UNIT_STUB) {
 767                 /* This is a transient unit, let's allow a little more */
 768
 769                 r = bus_service_set_transient_property(s, name, message, flags, error);
 770                 if (r != 0)
 771                         return r;
 772
 773                 r = bus_exec_context_set_transient_property(u, &s->exec_context, name, message, flags, error);
 774                 if (r != 0)
 775                         return r;
 776
 777                 r = bus_kill_context_set_transient_property(u, &s->kill_context, name, message, flags, error);
 778                 if (r != 0)
 779                         return r;
 780         }
 781
 782         return 0;
 783 }
 784
 785 int bus_service_commit_properties(Unit *u) {
 786         assert(u);
 787
 788         unit_realize_cgroup(u);
 789
 790         return 0;
 791 }