src/core/dbus-service.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2010 Lennart Poettering
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include "alloc-util.h"
  22 #include "async.h"
  23 #include "bus-util.h"
  24 #include "dbus-cgroup.h"
  25 #include "dbus-execute.h"
  26 #include "dbus-kill.h"
  27 #include "dbus-service.h"
  28 #include "fd-util.h"
  29 #include "fileio.h"
  30 #include "path-util.h"
  31 #include "service.h"
  32 #include "string-util.h"
  33 #include "strv.h"
  34 #include "unit.h"
  35
  36 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, service_type, ServiceType);
  37 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, service_result, ServiceResult);
  38 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_restart, service_restart, ServiceRestart);
  39 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_notify_access, notify_access, NotifyAccess);
  40 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_emergency_action, emergency_action, EmergencyAction);
  41
  42 const sd_bus_vtable bus_service_vtable[] = {
  43         SD_BUS_VTABLE_START(0),
  44         SD_BUS_PROPERTY("Type", "s", property_get_type, offsetof(Service, type), SD_BUS_VTABLE_PROPERTY_CONST),
  45         SD_BUS_PROPERTY("Restart", "s", property_get_restart, offsetof(Service, restart), SD_BUS_VTABLE_PROPERTY_CONST),
  46         SD_BUS_PROPERTY("PIDFile", "s", NULL, offsetof(Service, pid_file), SD_BUS_VTABLE_PROPERTY_CONST),
  47         SD_BUS_PROPERTY("NotifyAccess", "s", property_get_notify_access, offsetof(Service, notify_access), SD_BUS_VTABLE_PROPERTY_CONST),
  48         SD_BUS_PROPERTY("RestartUSec", "t", bus_property_get_usec, offsetof(Service, restart_usec), SD_BUS_VTABLE_PROPERTY_CONST),
  49         SD_BUS_PROPERTY("TimeoutStartUSec", "t", bus_property_get_usec, offsetof(Service, timeout_start_usec), SD_BUS_VTABLE_PROPERTY_CONST),
  50         SD_BUS_PROPERTY("TimeoutStopUSec", "t", bus_property_get_usec, offsetof(Service, timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
  51         SD_BUS_PROPERTY("RuntimeMaxUSec", "t", bus_property_get_usec, offsetof(Service, runtime_max_usec), SD_BUS_VTABLE_PROPERTY_CONST),
  52         SD_BUS_PROPERTY("WatchdogUSec", "t", bus_property_get_usec, offsetof(Service, watchdog_usec), SD_BUS_VTABLE_PROPERTY_CONST),
  53         BUS_PROPERTY_DUAL_TIMESTAMP("WatchdogTimestamp", offsetof(Service, watchdog_timestamp), 0),
  54         SD_BUS_PROPERTY("PermissionsStartOnly", "b", bus_property_get_bool, offsetof(Service, permissions_start_only), SD_BUS_VTABLE_PROPERTY_CONST),
  55         SD_BUS_PROPERTY("RootDirectoryStartOnly", "b", bus_property_get_bool, offsetof(Service, root_directory_start_only), SD_BUS_VTABLE_PROPERTY_CONST),
  56         SD_BUS_PROPERTY("RemainAfterExit", "b", bus_property_get_bool, offsetof(Service, remain_after_exit), SD_BUS_VTABLE_PROPERTY_CONST),
  57         SD_BUS_PROPERTY("GuessMainPID", "b", bus_property_get_bool, offsetof(Service, guess_main_pid), SD_BUS_VTABLE_PROPERTY_CONST),
  58         SD_BUS_PROPERTY("MainPID", "u", bus_property_get_pid, offsetof(Service, main_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  59         SD_BUS_PROPERTY("ControlPID", "u", bus_property_get_pid, offsetof(Service, control_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  60         SD_BUS_PROPERTY("BusName", "s", NULL, offsetof(Service, bus_name), SD_BUS_VTABLE_PROPERTY_CONST),
  61         SD_BUS_PROPERTY("FileDescriptorStoreMax", "u", bus_property_get_unsigned, offsetof(Service, n_fd_store_max), SD_BUS_VTABLE_PROPERTY_CONST),
  62         SD_BUS_PROPERTY("NFileDescriptorStore", "u", bus_property_get_unsigned, offsetof(Service, n_fd_store), 0),
  63         SD_BUS_PROPERTY("StatusText", "s", NULL, offsetof(Service, status_text), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  64         SD_BUS_PROPERTY("StatusErrno", "i", NULL, offsetof(Service, status_errno), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  65         SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Service, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  66         SD_BUS_PROPERTY("USBFunctionDescriptors", "s", NULL, offsetof(Service, usb_function_descriptors), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  67         SD_BUS_PROPERTY("USBFunctionStrings", "s", NULL, offsetof(Service, usb_function_strings), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  68         SD_BUS_PROPERTY("UID", "u", NULL, offsetof(Unit, ref_uid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  69         SD_BUS_PROPERTY("GID", "u", NULL, offsetof(Unit, ref_gid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  70         SD_BUS_PROPERTY("NRestarts", "u", bus_property_get_unsigned, offsetof(Service, n_restarts), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  71
  72         BUS_EXEC_STATUS_VTABLE("ExecMain", offsetof(Service, main_exec_status), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  73         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPre", offsetof(Service, exec_command[SERVICE_EXEC_START_PRE]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
  74         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStart", offsetof(Service, exec_command[SERVICE_EXEC_START]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
  75         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStartPost", offsetof(Service, exec_command[SERVICE_EXEC_START_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
  76         BUS_EXEC_COMMAND_LIST_VTABLE("ExecReload", offsetof(Service, exec_command[SERVICE_EXEC_RELOAD]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
  77         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStop", offsetof(Service, exec_command[SERVICE_EXEC_STOP]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
  78         BUS_EXEC_COMMAND_LIST_VTABLE("ExecStopPost", offsetof(Service, exec_command[SERVICE_EXEC_STOP_POST]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
  79
  80         /* The following four are obsolete, and thus marked hidden here. They moved into the Unit interface */
  81         SD_BUS_PROPERTY("StartLimitInterval", "t", bus_property_get_usec, offsetof(Unit, start_limit.interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
  82         SD_BUS_PROPERTY("StartLimitBurst", "u", bus_property_get_unsigned, offsetof(Unit, start_limit.burst), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
  83         SD_BUS_PROPERTY("StartLimitAction", "s", property_get_emergency_action, offsetof(Unit, start_limit_action), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
  84         SD_BUS_PROPERTY("FailureAction", "s", property_get_emergency_action, offsetof(Unit, failure_action), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
  85         SD_BUS_PROPERTY("RebootArgument", "s", NULL, offsetof(Unit, reboot_arg), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
  86         SD_BUS_VTABLE_END
  87 };
  88
  89 static int bus_service_set_transient_property(
  90                 Service *s,
  91                 const char *name,
  92                 sd_bus_message *message,
  93                 UnitSetPropertiesMode mode,
  94                 sd_bus_error *error) {
  95
  96         int r;
  97
  98         assert(s);
  99         assert(name);
 100         assert(message);
 101
 102         if (streq(name, "RemainAfterExit")) {
 103                 int b;
 104
 105                 r = sd_bus_message_read(message, "b", &b);
 106                 if (r < 0)
 107                         return r;
 108
 109                 if (mode != UNIT_CHECK) {
 110                         s->remain_after_exit = b;
 111                         unit_write_drop_in_private_format(UNIT(s), mode, name, "RemainAfterExit=%s", yes_no(b));
 112                 }
 113
 114                 return 1;
 115
 116         } else if (streq(name, "Type")) {
 117                 const char *t;
 118                 ServiceType k;
 119
 120                 r = sd_bus_message_read(message, "s", &t);
 121                 if (r < 0)
 122                         return r;
 123
 124                 k = service_type_from_string(t);
 125                 if (k < 0)
 126                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid service type %s", t);
 127
 128                 if (mode != UNIT_CHECK) {
 129                         s->type = k;
 130                         unit_write_drop_in_private_format(UNIT(s), mode, name, "Type=%s", service_type_to_string(s->type));
 131                 }
 132
 133                 return 1;
 134         } else if (streq(name, "RuntimeMaxUSec")) {
 135                 usec_t u;
 136
 137                 r = sd_bus_message_read(message, "t", &u);
 138                 if (r < 0)
 139                         return r;
 140
 141                 if (mode != UNIT_CHECK) {
 142                         s->runtime_max_usec = u;
 143                         unit_write_drop_in_private_format(UNIT(s), mode, name, "RuntimeMaxSec=" USEC_FMT "us", u);
 144                 }
 145
 146                 return 1;
 147
 148         } else if (streq(name, "Restart")) {
 149                 ServiceRestart sr;
 150                 const char *v;
 151
 152                 r = sd_bus_message_read(message, "s", &v);
 153                 if (r < 0)
 154                         return r;
 155
 156                 if (isempty(v))
 157                         sr = SERVICE_RESTART_NO;
 158                 else {
 159                         sr = service_restart_from_string(v);
 160                         if (sr < 0)
 161                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid restart setting: %s", v);
 162                 }
 163
 164                 if (mode != UNIT_CHECK) {
 165                         s->restart = sr;
 166                         unit_write_drop_in_private_format(UNIT(s), mode, name, "Restart=%s", service_restart_to_string(sr));
 167                 }
 168
 169                 return 1;
 170
 171         } else if (STR_IN_SET(name,
 172                               "StandardInputFileDescriptor",
 173                               "StandardOutputFileDescriptor",
 174                               "StandardErrorFileDescriptor")) {
 175                 int fd;
 176
 177                 r = sd_bus_message_read(message, "h", &fd);
 178                 if (r < 0)
 179                         return r;
 180
 181                 if (mode != UNIT_CHECK) {
 182                         int copy;
 183
 184                         copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
 185                         if (copy < 0)
 186                                 return -errno;
 187
 188                         if (streq(name, "StandardInputFileDescriptor")) {
 189                                 asynchronous_close(s->stdin_fd);
 190                                 s->stdin_fd = copy;
 191                         } else if (streq(name, "StandardOutputFileDescriptor")) {
 192                                 asynchronous_close(s->stdout_fd);
 193                                 s->stdout_fd = copy;
 194                         } else {
 195                                 asynchronous_close(s->stderr_fd);
 196                                 s->stderr_fd = copy;
 197                         }
 198
 199                         s->exec_context.stdio_as_fds = true;
 200                 }
 201
 202                 return 1;
 203
 204         } else if (streq(name, "FileDescriptorStoreMax")) {
 205                 uint32_t u;
 206
 207                 r = sd_bus_message_read(message, "u", &u);
 208                 if (r < 0)
 209                         return r;
 210
 211                 if (mode != UNIT_CHECK) {
 212                         s->n_fd_store_max = (unsigned) u;
 213                         unit_write_drop_in_private_format(UNIT(s), mode, name, "FileDescriptorStoreMax=%" PRIu32, u);
 214                 }
 215
 216                 return 1;
 217
 218         } else if (streq(name, "NotifyAccess")) {
 219                 const char *t;
 220                 NotifyAccess k;
 221
 222                 r = sd_bus_message_read(message, "s", &t);
 223                 if (r < 0)
 224                         return r;
 225
 226                 k = notify_access_from_string(t);
 227                 if (k < 0)
 228                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid notify access setting %s", t);
 229
 230                 if (mode != UNIT_CHECK) {
 231                         s->notify_access = k;
 232                         unit_write_drop_in_private_format(UNIT(s), mode, name, "NotifyAccess=%s", notify_access_to_string(s->notify_access));
 233                 }
 234
 235                 return 1;
 236
 237         } else if (streq(name, "ExecStart")) {
 238                 unsigned n = 0;
 239
 240                 r = sd_bus_message_enter_container(message, 'a', "(sasb)");
 241                 if (r < 0)
 242                         return r;
 243
 244                 while ((r = sd_bus_message_enter_container(message, 'r', "sasb")) > 0) {
 245                         _cleanup_strv_free_ char **argv = NULL;
 246                         const char *path;
 247                         int b;
 248
 249                         r = sd_bus_message_read(message, "s", &path);
 250                         if (r < 0)
 251                                 return r;
 252
 253                         if (!path_is_absolute(path))
 254                                 return sd_bus_error_set_errnof(error, EINVAL, "Path %s is not absolute.", path);
 255
 256                         r = sd_bus_message_read_strv(message, &argv);
 257                         if (r < 0)
 258                                 return r;
 259
 260                         r = sd_bus_message_read(message, "b", &b);
 261                         if (r < 0)
 262                                 return r;
 263
 264                         r = sd_bus_message_exit_container(message);
 265                         if (r < 0)
 266                                 return r;
 267
 268                         if (mode != UNIT_CHECK) {
 269                                 ExecCommand *c;
 270
 271                                 c = new0(ExecCommand, 1);
 272                                 if (!c)
 273                                         return -ENOMEM;
 274
 275                                 c->path = strdup(path);
 276                                 if (!c->path) {
 277                                         free(c);
 278                                         return -ENOMEM;
 279                                 }
 280
 281                                 c->argv = argv;
 282                                 argv = NULL;
 283
 284                                 c->flags = b ? EXEC_COMMAND_IGNORE_FAILURE : 0;
 285
 286                                 path_kill_slashes(c->path);
 287                                 exec_command_append_list(&s->exec_command[SERVICE_EXEC_START], c);
 288                         }
 289
 290                         n++;
 291                 }
 292
 293                 if (r < 0)
 294                         return r;
 295
 296                 r = sd_bus_message_exit_container(message);
 297                 if (r < 0)
 298                         return r;
 299
 300                 if (mode != UNIT_CHECK) {
 301                         _cleanup_free_ char *buf = NULL;
 302                         _cleanup_fclose_ FILE *f = NULL;
 303                         ExecCommand *c;
 304                         size_t size = 0;
 305
 306                         if (n == 0)
 307                                 s->exec_command[SERVICE_EXEC_START] = exec_command_free_list(s->exec_command[SERVICE_EXEC_START]);
 308
 309                         f = open_memstream(&buf, &size);
 310                         if (!f)
 311                                 return -ENOMEM;
 312
 313                         fputs_unlocked("ExecStart=\n", f);
 314
 315                         LIST_FOREACH(command, c, s->exec_command[SERVICE_EXEC_START]) {
 316                                 _cleanup_free_ char *a;
 317
 318                                 a = strv_join_quoted(c->argv);
 319                                 if (!a)
 320                                         return -ENOMEM;
 321
 322                                 fprintf(f, "ExecStart=%s@%s %s\n",
 323                                         c->flags & EXEC_COMMAND_IGNORE_FAILURE ? "-" : "",
 324                                         c->path,
 325                                         a);
 326                         }
 327
 328                         r = fflush_and_check(f);
 329                         if (r < 0)
 330                                 return r;
 331                         unit_write_drop_in_private(UNIT(s), mode, name, buf);
 332                 }
 333
 334                 return 1;
 335         }
 336
 337         return 0;
 338 }
 339
 340 int bus_service_set_property(
 341                 Unit *u,
 342                 const char *name,
 343                 sd_bus_message *message,
 344                 UnitSetPropertiesMode mode,
 345                 sd_bus_error *error) {
 346
 347         Service *s = SERVICE(u);
 348         int r;
 349
 350         assert(s);
 351         assert(name);
 352         assert(message);
 353
 354         r = bus_cgroup_set_property(u, &s->cgroup_context, name, message, mode, error);
 355         if (r != 0)
 356                 return r;
 357
 358         if (u->transient && u->load_state == UNIT_STUB) {
 359                 /* This is a transient unit, let's load a little more */
 360
 361                 r = bus_service_set_transient_property(s, name, message, mode, error);
 362                 if (r != 0)
 363                         return r;
 364
 365                 r = bus_exec_context_set_transient_property(u, &s->exec_context, name, message, mode, error);
 366                 if (r != 0)
 367                         return r;
 368
 369                 r = bus_kill_context_set_transient_property(u, &s->kill_context, name, message, mode, error);
 370                 if (r != 0)
 371                         return r;
 372         }
 373
 374         return 0;
 375 }
 376
 377 int bus_service_commit_properties(Unit *u) {
 378         assert(u);
 379
 380         unit_update_cgroup_members_masks(u);
 381         unit_realize_cgroup(u);
 382
 383         return 0;
 384 }