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_emergency_action, emergency_action, EmergencyAction);
  37 static BUS_DEFINE_PROPERTY_GET2(property_get_notify_access, "s", Service, service_get_notify_access, notify_access_to_string);
  38 static BUS_DEFINE_PROPERTY_GET(property_get_restart_usec_current, "t", Service, service_restart_usec);
  39 static BUS_DEFINE_PROPERTY_GET(property_get_timeout_abort_usec, "t", Service, service_timeout_abort_usec);
  40 static BUS_DEFINE_PROPERTY_GET(property_get_watchdog_usec, "t", Service, service_get_watchdog_usec);
  41 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_timeout_failure_mode, service_timeout_failure_mode, ServiceTimeoutFailureMode);
  42
  43 static int property_get_open_files(
  44                 sd_bus *bus,
  45                 const char *path,
  46                 const char *interface,
  47                 const char *property,
  48                 sd_bus_message *reply,
  49                 void *userdata,
  50                 sd_bus_error *error) {
  51
  52         OpenFile **open_files = ASSERT_PTR(userdata);
  53         int r;
  54
  55         assert(bus);
  56         assert(reply);
  57
  58         r = sd_bus_message_open_container(reply, 'a', "(sst)");
  59         if (r < 0)
  60                 return r;
  61
  62         LIST_FOREACH(open_files, of, *open_files) {
  63                 r = sd_bus_message_append(reply, "(sst)", of->path, of->fdname, of->flags);
  64                 if (r < 0)
  65                         return r;
  66         }
  67
  68         return sd_bus_message_close_container(reply);
  69 }
  70
  71 static int property_get_exit_status_set(
  72                 sd_bus *bus,
  73                 const char *path,
  74                 const char *interface,
  75                 const char *property,
  76                 sd_bus_message *reply,
  77                 void *userdata,
  78                 sd_bus_error *error) {
  79
  80         const ExitStatusSet *status_set = ASSERT_PTR(userdata);
  81         unsigned n;
  82         int r;
  83
  84         assert(bus);
  85         assert(reply);
  86
  87         r = sd_bus_message_open_container(reply, 'r', "aiai");
  88         if (r < 0)
  89                 return r;
  90
  91         r = sd_bus_message_open_container(reply, 'a', "i");
  92         if (r < 0)
  93                 return r;
  94
  95         BITMAP_FOREACH(n, &status_set->status) {
  96                 assert(n < 256);
  97
  98                 r = sd_bus_message_append_basic(reply, 'i', &n);
  99                 if (r < 0)
 100                         return r;
 101         }
 102
 103         r = sd_bus_message_close_container(reply);
 104         if (r < 0)
 105                 return r;
 106
 107         r = sd_bus_message_open_container(reply, 'a', "i");
 108         if (r < 0)
 109                 return r;
 110
 111         BITMAP_FOREACH(n, &status_set->signal) {
 112                 const char *str;
 113
 114                 str = signal_to_string(n);
 115                 if (!str)
 116                         continue;
 117
 118                 r = sd_bus_message_append_basic(reply, 'i', &n);
 119                 if (r < 0)
 120                         return r;
 121         }
 122
 123         r = sd_bus_message_close_container(reply);
 124         if (r < 0)
 125                 return r;
 126
 127         return sd_bus_message_close_container(reply);
 128 }
 129
 130 static int bus_service_method_mount(sd_bus_message *message, void *userdata, sd_bus_error *error, bool is_image) {
 131         _cleanup_(mount_options_free_allp) MountOptions *options = NULL;
 132         const char *dest, *src, *propagate_directory;
 133         int read_only, make_file_or_directory;
 134         Unit *u = ASSERT_PTR(userdata);
 135         ExecContext *c;
 136         pid_t unit_pid;
 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         unit_pid = unit_main_pid(u);
 195         if (unit_pid == 0 || !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(unit_pid,
 201                                              propagate_directory,
 202                                              "/run/systemd/incoming/",
 203                                              src, dest, read_only, make_file_or_directory, options);
 204         else
 205                 r = bind_mount_in_namespace(unit_pid,
 206                                             propagate_directory,
 207                                             "/run/systemd/incoming/",
 208                                             src, dest, read_only, make_file_or_directory);
 209         if (r < 0)
 210                 return sd_bus_error_set_errnof(error, r, "Failed to mount %s on %s in unit's namespace: %m", src, dest);
 211
 212         return sd_bus_reply_method_return(message, NULL);
 213 }
 214
 215 int bus_service_method_bind_mount(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 216         return bus_service_method_mount(message, userdata, error, false);
 217 }
 218
 219 int bus_service_method_mount_image(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 220         return bus_service_method_mount(message, userdata, error, true);
 221 }
 222
 223 int bus_service_method_dump_file_descriptor_store(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 224         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 225         Service *s = ASSERT_PTR(userdata);
 226         int r;
 227
 228         assert(message);
 229
 230         r = mac_selinux_unit_access_check(UNIT(s), message, "status", error);
 231         if (r < 0)
 232                 return r;
 233
 234         if (s->n_fd_store_max == 0 && s->n_fd_store == 0)
 235                 return sd_bus_error_setf(error, BUS_ERROR_FILE_DESCRIPTOR_STORE_DISABLED, "File descriptor store not enabled for %s.", UNIT(s)->id);
 236
 237         r = sd_bus_message_new_method_return(message, &reply);
 238         if (r < 0)
 239                 return r;
 240
 241         r = sd_bus_message_open_container(reply, 'a', "(suuutuusu)");
 242         if (r < 0)
 243                 return r;
 244
 245         LIST_FOREACH(fd_store, i, s->fd_store) {
 246                 _cleanup_free_ char *path = NULL;
 247                 struct stat st;
 248                 int flags;
 249
 250                 if (fstat(i->fd, &st) < 0) {
 251                         log_debug_errno(errno, "Failed to stat() file descriptor entry '%s', skipping.", strna(i->fdname));
 252                         continue;
 253                 }
 254
 255                 flags = fcntl(i->fd, F_GETFL);
 256                 if (flags < 0) {
 257                         log_debug_errno(errno, "Failed to issue F_GETFL on file descriptor entry '%s', skipping.", strna(i->fdname));
 258                         continue;
 259                 }
 260
 261                 /* glibc implies O_LARGEFILE everywhere on 64bit off_t builds, but forgets to hide it away on
 262                  * F_GETFL, but provides no definition to check for that. Let's mask the flag away manually,
 263                  * to not confuse clients. */
 264                 flags &= ~RAW_O_LARGEFILE;
 265
 266                 (void) fd_get_path(i->fd, &path);
 267
 268                 r = sd_bus_message_append(
 269                                 reply,
 270                                 "(suuutuusu)",
 271                                 i->fdname,
 272                                 (uint32_t) st.st_mode,
 273                                 (uint32_t) major(st.st_dev), (uint32_t) minor(st.st_dev),
 274                                 (uint64_t) st.st_ino,
 275                                 (uint32_t) major(st.st_rdev), (uint32_t) minor(st.st_rdev),
 276                                 path,
 277                                 (uint32_t) flags);
 278                 if (r < 0)
 279                         return r;
 280         }
 281
 282         r = sd_bus_message_close_container(reply);
 283         if (r < 0)
 284                 return r;
 285
 286         return sd_bus_send(NULL, reply, NULL);
 287 }
 288
 289 const sd_bus_vtable bus_service_vtable[] = {
 290         SD_BUS_VTABLE_START(0),
 291         SD_BUS_PROPERTY("Type", "s", property_get_type, offsetof(Service, type), SD_BUS_VTABLE_PROPERTY_CONST),
 292         SD_BUS_PROPERTY("ExitType", "s", property_get_exit_type, offsetof(Service, exit_type), SD_BUS_VTABLE_PROPERTY_CONST),
 293         SD_BUS_PROPERTY("Restart", "s", property_get_restart, offsetof(Service, restart), SD_BUS_VTABLE_PROPERTY_CONST),
 294         SD_BUS_PROPERTY("PIDFile", "s", NULL, offsetof(Service, pid_file), SD_BUS_VTABLE_PROPERTY_CONST),
 295         SD_BUS_PROPERTY("NotifyAccess", "s", property_get_notify_access, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 296         SD_BUS_PROPERTY("RestartUSec", "t", bus_property_get_usec, offsetof(Service, restart_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 297         SD_BUS_PROPERTY("RestartSteps", "u", bus_property_get_unsigned, offsetof(Service, restart_steps), SD_BUS_VTABLE_PROPERTY_CONST),
 298         SD_BUS_PROPERTY("RestartUSecMax", "t", bus_property_get_usec, offsetof(Service, restart_usec_max), SD_BUS_VTABLE_PROPERTY_CONST),
 299         SD_BUS_PROPERTY("RestartUSecCurrent", "t", property_get_restart_usec_current, 0, 0),
 300         SD_BUS_PROPERTY("TimeoutStartUSec", "t", bus_property_get_usec, offsetof(Service, timeout_start_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 301         SD_BUS_PROPERTY("TimeoutStopUSec", "t", bus_property_get_usec, offsetof(Service, timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 302         SD_BUS_PROPERTY("TimeoutAbortUSec", "t", property_get_timeout_abort_usec, 0, 0),
 303         SD_BUS_PROPERTY("TimeoutStartFailureMode", "s", property_get_timeout_failure_mode, offsetof(Service, timeout_start_failure_mode), SD_BUS_VTABLE_PROPERTY_CONST),
 304         SD_BUS_PROPERTY("TimeoutStopFailureMode", "s", property_get_timeout_failure_mode, offsetof(Service, timeout_stop_failure_mode), SD_BUS_VTABLE_PROPERTY_CONST),
 305         SD_BUS_PROPERTY("RuntimeMaxUSec", "t", bus_property_get_usec, offsetof(Service, runtime_max_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 306         SD_BUS_PROPERTY("RuntimeRandomizedExtraUSec", "t", bus_property_get_usec, offsetof(Service, runtime_rand_extra_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 307         SD_BUS_PROPERTY("WatchdogUSec", "t", property_get_watchdog_usec, 0, 0),
 308         BUS_PROPERTY_DUAL_TIMESTAMP("WatchdogTimestamp", offsetof(Service, watchdog_timestamp), 0),
 309         SD_BUS_PROPERTY("PermissionsStartOnly", "b", bus_property_get_bool, offsetof(Service, permissions_start_only), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN), /* 😷 deprecated */
 310         SD_BUS_PROPERTY("RootDirectoryStartOnly", "b", bus_property_get_bool, offsetof(Service, root_directory_start_only), SD_BUS_VTABLE_PROPERTY_CONST),
 311         SD_BUS_PROPERTY("RemainAfterExit", "b", bus_property_get_bool, offsetof(Service, remain_after_exit), SD_BUS_VTABLE_PROPERTY_CONST),
 312         SD_BUS_PROPERTY("GuessMainPID", "b", bus_property_get_bool, offsetof(Service, guess_main_pid), SD_BUS_VTABLE_PROPERTY_CONST),
 313         SD_BUS_PROPERTY("RestartPreventExitStatus", "(aiai)", property_get_exit_status_set, offsetof(Service, restart_prevent_status), SD_BUS_VTABLE_PROPERTY_CONST),
 314         SD_BUS_PROPERTY("RestartForceExitStatus", "(aiai)", property_get_exit_status_set, offsetof(Service, restart_force_status), SD_BUS_VTABLE_PROPERTY_CONST),
 315         SD_BUS_PROPERTY("SuccessExitStatus", "(aiai)", property_get_exit_status_set, offsetof(Service, success_status), SD_BUS_VTABLE_PROPERTY_CONST),
 316         SD_BUS_PROPERTY("MainPID", "u", bus_property_get_pid, offsetof(Service, main_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 317         SD_BUS_PROPERTY("ControlPID", "u", bus_property_get_pid, offsetof(Service, control_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 318         SD_BUS_PROPERTY("BusName", "s", NULL, offsetof(Service, bus_name), SD_BUS_VTABLE_PROPERTY_CONST),
 319         SD_BUS_PROPERTY("FileDescriptorStoreMax", "u", bus_property_get_unsigned, offsetof(Service, n_fd_store_max), SD_BUS_VTABLE_PROPERTY_CONST),
 320         SD_BUS_PROPERTY("NFileDescriptorStore", "u", bus_property_get_unsigned, offsetof(Service, n_fd_store), 0),
 321         SD_BUS_PROPERTY("StatusText", "s", NULL, offsetof(Service, status_text), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 322         SD_BUS_PROPERTY("StatusErrno", "i", bus_property_get_int, offsetof(Service, status_errno), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 323         SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Service, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 324         SD_BUS_PROPERTY("ReloadResult", "s", property_get_result, offsetof(Service, reload_result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 325         SD_BUS_PROPERTY("CleanResult", "s", property_get_result, offsetof(Service, clean_result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 326         SD_BUS_PROPERTY("USBFunctionDescriptors", "s", NULL, offsetof(Service, usb_function_descriptors), SD_BUS_VTABLE_PROPERTY_CONST),
 327         SD_BUS_PROPERTY("USBFunctionStrings", "s", NULL, offsetof(Service, usb_function_strings), SD_BUS_VTABLE_PROPERTY_CONST),
 328         SD_BUS_PROPERTY("UID", "u", bus_property_get_uid, offsetof(Unit, ref_uid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 329         SD_BUS_PROPERTY("GID", "u", bus_property_get_gid, offsetof(Unit, ref_gid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 330         SD_BUS_PROPERTY("NRestarts", "u", bus_property_get_unsigned, offsetof(Service, n_restarts), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 331         SD_BUS_PROPERTY("OOMPolicy", "s", bus_property_get_oom_policy, offsetof(Service, oom_policy), SD_BUS_VTABLE_PROPERTY_CONST),
 332         SD_BUS_PROPERTY("OpenFile", "a(sst)", property_get_open_files, offsetof(Service, open_files), SD_BUS_VTABLE_PROPERTY_CONST),
 333         SD_BUS_PROPERTY("ReloadSignal", "i", bus_property_get_int, offsetof(Service, reload_signal), SD_BUS_VTABLE_PROPERTY_CONST),
 334
 335         BUS_EXEC_STATUS_VTABLE("ExecMain", offsetof(Service, main_exec_status), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 336         BUS_EXEC_COMMAND_LIST_VTABLE("ExecCondition", offsetof(Service, exec_command[SERVICE_EXEC_CONDITION]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 337         BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecConditionEx", offsetof(Service, exec_command[SERVICE_EXEC_CONDITION]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 338         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPre", offsetof(Service, exec_command[SERVICE_EXEC_START_PRE]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 339         BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStartPreEx", offsetof(Service, exec_command[SERVICE_EXEC_START_PRE]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 340         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStart", offsetof(Service, exec_command[SERVICE_EXEC_START]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 341         BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStartEx", offsetof(Service, exec_command[SERVICE_EXEC_START]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 342         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPost", offsetof(Service, exec_command[SERVICE_EXEC_START_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 343         BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStartPostEx", offsetof(Service, exec_command[SERVICE_EXEC_START_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 344         BUS_EXEC_COMMAND_LIST_VTABLE("ExecReload", offsetof(Service, exec_command[SERVICE_EXEC_RELOAD]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 345         BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecReloadEx", offsetof(Service, exec_command[SERVICE_EXEC_RELOAD]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 346         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStop", offsetof(Service, exec_command[SERVICE_EXEC_STOP]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 347         BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStopEx", offsetof(Service, exec_command[SERVICE_EXEC_STOP]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 348         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStopPost", offsetof(Service, exec_command[SERVICE_EXEC_STOP_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 349         BUS_EXEC_EX_COMMAND_LIST_VTABLE("ExecStopPostEx", offsetof(Service, exec_command[SERVICE_EXEC_STOP_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 350
 351         SD_BUS_METHOD_WITH_ARGS("BindMount",
 352                                 SD_BUS_ARGS("s", source, "s", destination, "b", read_only, "b", mkdir),
 353                                 SD_BUS_NO_RESULT,
 354                                 bus_service_method_bind_mount,
 355                                 SD_BUS_VTABLE_UNPRIVILEGED),
 356
 357         SD_BUS_METHOD_WITH_ARGS("MountImage",
 358                                  SD_BUS_ARGS("s", source, "s", destination, "b", read_only, "b", mkdir, "a(ss)", options),
 359                                  SD_BUS_NO_RESULT,
 360                                  bus_service_method_mount_image,
 361                                  SD_BUS_VTABLE_UNPRIVILEGED),
 362
 363         SD_BUS_METHOD_WITH_ARGS("DumpFileDescriptorStore",
 364                                 SD_BUS_NO_ARGS,
 365                                 SD_BUS_ARGS("a(suuutuusu)", entries),
 366                                 bus_service_method_dump_file_descriptor_store,
 367                                 SD_BUS_VTABLE_UNPRIVILEGED),
 368
 369         /* The following four are obsolete, and thus marked hidden here. They moved into the Unit interface */
 370         SD_BUS_PROPERTY("StartLimitInterval", "t", bus_property_get_usec, offsetof(Unit, start_ratelimit.interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
 371         SD_BUS_PROPERTY("StartLimitBurst", "u", bus_property_get_unsigned, offsetof(Unit, start_ratelimit.burst), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
 372         SD_BUS_PROPERTY("StartLimitAction", "s", property_get_emergency_action, offsetof(Unit, start_limit_action), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
 373         SD_BUS_PROPERTY("FailureAction", "s", property_get_emergency_action, offsetof(Unit, failure_action), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
 374         SD_BUS_PROPERTY("RebootArgument", "s", NULL, offsetof(Unit, reboot_arg), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
 375         SD_BUS_VTABLE_END
 376 };
 377
 378 static int bus_set_transient_exit_status(
 379                 Unit *u,
 380                 const char *name,
 381                 ExitStatusSet *status_set,
 382                 sd_bus_message *message,
 383                 UnitWriteFlags flags,
 384                 sd_bus_error *error) {
 385
 386         const int32_t *status, *signal;
 387         size_t n_status, n_signal, i;
 388         int r;
 389
 390         r = sd_bus_message_enter_container(message, 'r', "aiai");
 391         if (r < 0)
 392                 return r;
 393
 394         r = sd_bus_message_read_array(message, 'i', (const void **) &status, &n_status);
 395         if (r < 0)
 396                 return r;
 397
 398         r = sd_bus_message_read_array(message, 'i', (const void **) &signal, &n_signal);
 399         if (r < 0)
 400                 return r;
 401
 402         r = sd_bus_message_exit_container(message);
 403         if (r < 0)
 404                 return r;
 405
 406         n_status /= sizeof(int32_t);
 407         n_signal /= sizeof(int32_t);
 408
 409         if (n_status == 0 && n_signal == 0 && !UNIT_WRITE_FLAGS_NOOP(flags)) {
 410                 exit_status_set_free(status_set);
 411                 unit_write_settingf(u, flags, name, "%s=", name);
 412                 return 1;
 413         }
 414
 415         for (i = 0; i < n_status; i++) {
 416                 if (status[i] < 0 || status[i] > 255)
 417                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid status code in %s: %"PRIi32, name, status[i]);
 418
 419                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 420                         r = bitmap_set(&status_set->status, status[i]);
 421                         if (r < 0)
 422                                 return r;
 423
 424                         unit_write_settingf(u, flags, name, "%s=%"PRIi32, name, status[i]);
 425                 }
 426         }
 427
 428         for (i = 0; i < n_signal; i++) {
 429                 const char *str;
 430
 431                 str = signal_to_string((int) signal[i]);
 432                 if (!str)
 433                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal in %s: %"PRIi32, name, signal[i]);
 434
 435                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 436                         r = bitmap_set(&status_set->signal, signal[i]);
 437                         if (r < 0)
 438                                 return r;
 439
 440                         unit_write_settingf(u, flags, name, "%s=%s", name, str);
 441                 }
 442         }
 443
 444         return 1;
 445 }
 446
 447 static int bus_set_transient_std_fd(
 448                 Unit *u,
 449                 const char *name,
 450                 int *p,
 451                 bool *b,
 452                 sd_bus_message *message,
 453                 UnitWriteFlags flags,
 454                 sd_bus_error *error) {
 455
 456         int fd, r;
 457
 458         assert(p);
 459         assert(b);
 460
 461         r = sd_bus_message_read(message, "h", &fd);
 462         if (r < 0)
 463                 return r;
 464
 465         if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 466                 int copy;
 467
 468                 copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
 469                 if (copy < 0)
 470                         return -errno;
 471
 472                 asynchronous_close(*p);
 473                 *p = copy;
 474                 *b = true;
 475         }
 476
 477         return 1;
 478 }
 479 static BUS_DEFINE_SET_TRANSIENT_PARSE(notify_access, NotifyAccess, notify_access_from_string);
 480 static BUS_DEFINE_SET_TRANSIENT_PARSE(service_type, ServiceType, service_type_from_string);
 481 static BUS_DEFINE_SET_TRANSIENT_PARSE(service_exit_type, ServiceExitType, service_exit_type_from_string);
 482 static BUS_DEFINE_SET_TRANSIENT_PARSE(service_restart, ServiceRestart, service_restart_from_string);
 483 static BUS_DEFINE_SET_TRANSIENT_PARSE(oom_policy, OOMPolicy, oom_policy_from_string);
 484 static BUS_DEFINE_SET_TRANSIENT_STRING_WITH_CHECK(bus_name, sd_bus_service_name_is_valid);
 485 static BUS_DEFINE_SET_TRANSIENT_PARSE(timeout_failure_mode, ServiceTimeoutFailureMode, service_timeout_failure_mode_from_string);
 486 static BUS_DEFINE_SET_TRANSIENT_TO_STRING(reload_signal, "i", int32_t, int, "%" PRIi32, signal_to_string_with_check);
 487
 488 static int bus_service_set_transient_property(
 489                 Service *s,
 490                 const char *name,
 491                 sd_bus_message *message,
 492                 UnitWriteFlags flags,
 493                 sd_bus_error *error) {
 494
 495         Unit *u = UNIT(s);
 496         ServiceExecCommand ci;
 497         int r;
 498
 499         assert(s);
 500         assert(name);
 501         assert(message);
 502
 503         flags |= UNIT_PRIVATE;
 504
 505         if (streq(name, "PermissionsStartOnly"))
 506                 return bus_set_transient_bool(u, name, &s->permissions_start_only, message, flags, error);
 507
 508         if (streq(name, "RootDirectoryStartOnly"))
 509                 return bus_set_transient_bool(u, name, &s->root_directory_start_only, message, flags, error);
 510
 511         if (streq(name, "RemainAfterExit"))
 512                 return bus_set_transient_bool(u, name, &s->remain_after_exit, message, flags, error);
 513
 514         if (streq(name, "GuessMainPID"))
 515                 return bus_set_transient_bool(u, name, &s->guess_main_pid, message, flags, error);
 516
 517         if (streq(name, "Type"))
 518                 return bus_set_transient_service_type(u, name, &s->type, message, flags, error);
 519
 520         if (streq(name, "ExitType"))
 521                 return bus_set_transient_service_exit_type(u, name, &s->exit_type, message, flags, error);
 522
 523         if (streq(name, "OOMPolicy"))
 524                 return bus_set_transient_oom_policy(u, name, &s->oom_policy, message, flags, error);
 525
 526         if (streq(name, "RestartUSec"))
 527                 return bus_set_transient_usec(u, name, &s->restart_usec, message, flags, error);
 528
 529         if (streq(name, "RestartSteps"))
 530                 return bus_set_transient_unsigned(u, name, &s->restart_steps, message, flags, error);
 531
 532         if (streq(name, "RestartUSecMax"))
 533                 return bus_set_transient_usec(u, name, &s->restart_usec_max, message, flags, error);
 534
 535         if (streq(name, "TimeoutStartUSec")) {
 536                 r = bus_set_transient_usec(u, name, &s->timeout_start_usec, message, flags, error);
 537                 if (r >= 0 && !UNIT_WRITE_FLAGS_NOOP(flags))
 538                         s->start_timeout_defined = true;
 539
 540                 return r;
 541         }
 542
 543         if (streq(name, "TimeoutStopUSec"))
 544                 return bus_set_transient_usec(u, name, &s->timeout_stop_usec, message, flags, error);
 545
 546         if (streq(name, "TimeoutAbortUSec")) {
 547                 r = bus_set_transient_usec(u, name, &s->timeout_abort_usec, message, flags, error);
 548                 if (r >= 0 && !UNIT_WRITE_FLAGS_NOOP(flags))
 549                         s->timeout_abort_set = true;
 550                 return r;
 551         }
 552
 553         if (streq(name, "TimeoutStartFailureMode"))
 554                 return bus_set_transient_timeout_failure_mode(u, name, &s->timeout_start_failure_mode, message, flags, error);
 555
 556         if (streq(name, "TimeoutStopFailureMode"))
 557                 return bus_set_transient_timeout_failure_mode(u, name, &s->timeout_stop_failure_mode, message, flags, error);
 558
 559         if (streq(name, "RuntimeMaxUSec"))
 560                 return bus_set_transient_usec(u, name, &s->runtime_max_usec, message, flags, error);
 561
 562         if (streq(name, "RuntimeRandomizedExtraUSec"))
 563                 return bus_set_transient_usec(u, name, &s->runtime_rand_extra_usec, message, flags, error);
 564
 565         if (streq(name, "WatchdogUSec"))
 566                 return bus_set_transient_usec(u, name, &s->watchdog_usec, message, flags, error);
 567
 568         if (streq(name, "FileDescriptorStoreMax"))
 569                 return bus_set_transient_unsigned(u, name, &s->n_fd_store_max, message, flags, error);
 570
 571         if (streq(name, "NotifyAccess"))
 572                 return bus_set_transient_notify_access(u, name, &s->notify_access, message, flags, error);
 573
 574         if (streq(name, "PIDFile")) {
 575                 _cleanup_free_ char *n = NULL;
 576                 const char *v, *e;
 577
 578                 r = sd_bus_message_read(message, "s", &v);
 579                 if (r < 0)
 580                         return r;
 581
 582                 if (!isempty(v)) {
 583                         n = path_make_absolute(v, u->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
 584                         if (!n)
 585                                 return -ENOMEM;
 586
 587                         path_simplify(n);
 588
 589                         if (!path_is_normalized(n))
 590                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "PIDFile= path '%s' is not valid", n);
 591
 592                         e = path_startswith(n, "/var/run/");
 593                         if (e) {
 594                                 char *z;
 595
 596                                 z = path_join("/run", e);
 597                                 if (!z)
 598                                         return log_oom();
 599
 600                                 if (!UNIT_WRITE_FLAGS_NOOP(flags))
 601                                         log_unit_notice(u, "Transient unit's PIDFile= property references path below legacy directory /var/run, updating %s %s %s; please update client accordingly.",
 602                                                         n, special_glyph(SPECIAL_GLYPH_ARROW_RIGHT), z);
 603
 604                                 free_and_replace(n, z);
 605                         }
 606                 }
 607
 608                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 609                         free_and_replace(s->pid_file, n);
 610                         unit_write_settingf(u, flags, name, "%s=%s", name, strempty(s->pid_file));
 611                 }
 612
 613                 return 1;
 614         }
 615
 616         if (streq(name, "USBFunctionDescriptors"))
 617                 return bus_set_transient_path(u, name, &s->usb_function_descriptors, message, flags, error);
 618
 619         if (streq(name, "USBFunctionStrings"))
 620                 return bus_set_transient_path(u, name, &s->usb_function_strings, message, flags, error);
 621
 622         if (streq(name, "BusName"))
 623                 return bus_set_transient_bus_name(u, name, &s->bus_name, message, flags, error);
 624
 625         if (streq(name, "Restart"))
 626                 return bus_set_transient_service_restart(u, name, &s->restart, message, flags, error);
 627
 628         if (streq(name, "RestartPreventExitStatus"))
 629                 return bus_set_transient_exit_status(u, name, &s->restart_prevent_status, message, flags, error);
 630
 631         if (streq(name, "RestartForceExitStatus"))
 632                 return bus_set_transient_exit_status(u, name, &s->restart_force_status, message, flags, error);
 633
 634         if (streq(name, "SuccessExitStatus"))
 635                 return bus_set_transient_exit_status(u, name, &s->success_status, message, flags, error);
 636
 637         ci = service_exec_command_from_string(name);
 638         ci = (ci >= 0) ? ci : service_exec_ex_command_from_string(name);
 639         if (ci >= 0)
 640                 return bus_set_transient_exec_command(u, name, &s->exec_command[ci], message, flags, error);
 641
 642         if (streq(name, "StandardInputFileDescriptor"))
 643                 return bus_set_transient_std_fd(u, name, &s->stdin_fd, &s->exec_context.stdio_as_fds, message, flags, error);
 644
 645         if (streq(name, "StandardOutputFileDescriptor"))
 646                 return bus_set_transient_std_fd(u, name, &s->stdout_fd, &s->exec_context.stdio_as_fds, message, flags, error);
 647
 648         if (streq(name, "StandardErrorFileDescriptor"))
 649                 return bus_set_transient_std_fd(u, name, &s->stderr_fd, &s->exec_context.stdio_as_fds, message, flags, error);
 650
 651         if (streq(name, "OpenFile")) {
 652                 const char *path, *fdname;
 653                 uint64_t offlags;
 654
 655                 r = sd_bus_message_enter_container(message, 'a', "(sst)");
 656                 if (r < 0)
 657                         return r;
 658
 659                 while ((r = sd_bus_message_read(message, "(sst)", &path, &fdname, &offlags)) > 0) {
 660                         _cleanup_(open_file_freep) OpenFile *of = NULL;
 661                         _cleanup_free_ char *ofs = NULL;
 662
 663                         of = new(OpenFile, 1);
 664                         if (!of)
 665                                 return -ENOMEM;
 666
 667                         *of = (OpenFile) {
 668                                 .path = strdup(path),
 669                                 .fdname = strdup(fdname),
 670                                 .flags = offlags,
 671                         };
 672
 673                         if (!of->path || !of->fdname)
 674                                 return -ENOMEM;
 675
 676                         r = open_file_validate(of);
 677                         if (r < 0)
 678                                 return r;
 679
 680                         if (UNIT_WRITE_FLAGS_NOOP(flags))
 681                                 continue;
 682
 683                         r = open_file_to_string(of, &ofs);
 684                         if (r < 0)
 685                                 return sd_bus_error_set_errnof(
 686                                                 error, r, "Failed to convert OpenFile= value to string: %m");
 687
 688                         LIST_APPEND(open_files, s->open_files, TAKE_PTR(of));
 689                         unit_write_settingf(u, flags | UNIT_ESCAPE_SPECIFIERS, name, "OpenFile=%s", ofs);
 690                 }
 691                 if (r < 0)
 692                         return r;
 693
 694                 r = sd_bus_message_exit_container(message);
 695                 if (r < 0)
 696                         return r;
 697
 698                 return 1;
 699         }
 700
 701         if (streq(name, "ReloadSignal"))
 702                 return bus_set_transient_reload_signal(u, name, &s->reload_signal, message, flags, error);
 703
 704         return 0;
 705 }
 706
 707 int bus_service_set_property(
 708                 Unit *u,
 709                 const char *name,
 710                 sd_bus_message *message,
 711                 UnitWriteFlags flags,
 712                 sd_bus_error *error) {
 713
 714         Service *s = SERVICE(u);
 715         int r;
 716
 717         assert(s);
 718         assert(name);
 719         assert(message);
 720
 721         r = bus_cgroup_set_property(u, &s->cgroup_context, name, message, flags, error);
 722         if (r != 0)
 723                 return r;
 724
 725         if (u->transient && u->load_state == UNIT_STUB) {
 726                 /* This is a transient unit, let's load a little more */
 727
 728                 r = bus_service_set_transient_property(s, name, message, flags, error);
 729                 if (r != 0)
 730                         return r;
 731
 732                 r = bus_exec_context_set_transient_property(u, &s->exec_context, name, message, flags, error);
 733                 if (r != 0)
 734                         return r;
 735
 736                 r = bus_kill_context_set_transient_property(u, &s->kill_context, name, message, flags, error);
 737                 if (r != 0)
 738                         return r;
 739         }
 740
 741         return 0;
 742 }
 743
 744 int bus_service_commit_properties(Unit *u) {
 745         assert(u);
 746
 747         unit_realize_cgroup(u);
 748
 749         return 0;
 750 }