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