src/core/dbus-service.c

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