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