src/core/dbus-scope.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include "alloc-util.h"
   4 #include "bus-common-errors.h"
   5 #include "bus-util.h"
   6 #include "dbus-cgroup.h"
   7 #include "dbus-kill.h"
   8 #include "dbus-scope.h"
   9 #include "dbus-unit.h"
  10 #include "dbus-util.h"
  11 #include "dbus.h"
  12 #include "scope.h"
  13 #include "selinux-access.h"
  14 #include "unit.h"
  15
  16 int bus_scope_method_abandon(sd_bus_message *message, void *userdata, sd_bus_error *error) {
  17         Scope *s = userdata;
  18         int r;
  19
  20         assert(message);
  21         assert(s);
  22
  23         r = mac_selinux_unit_access_check(UNIT(s), message, "stop", error);
  24         if (r < 0)
  25                 return r;
  26
  27         r = bus_verify_manage_units_async(UNIT(s)->manager, message, error);
  28         if (r < 0)
  29                 return r;
  30         if (r == 0)
  31                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
  32
  33         r = scope_abandon(s);
  34         if (r == -ESTALE)
  35                 return sd_bus_error_setf(error, BUS_ERROR_SCOPE_NOT_RUNNING, "Scope %s is not running, cannot abandon.", UNIT(s)->id);
  36         if (r < 0)
  37                 return r;
  38
  39         return sd_bus_reply_method_return(message, NULL);
  40 }
  41
  42 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, scope_result, ScopeResult);
  43
  44 const sd_bus_vtable bus_scope_vtable[] = {
  45         SD_BUS_VTABLE_START(0),
  46         SD_BUS_PROPERTY("Controller", "s", NULL, offsetof(Scope, controller), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  47         SD_BUS_PROPERTY("TimeoutStopUSec", "t", bus_property_get_usec, offsetof(Scope, timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
  48         SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Scope, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  49         SD_BUS_PROPERTY("RuntimeMaxUSec", "t", bus_property_get_usec, offsetof(Scope, runtime_max_usec), SD_BUS_VTABLE_PROPERTY_CONST),
  50         SD_BUS_SIGNAL("RequestStop", NULL, 0),
  51         SD_BUS_METHOD("Abandon", NULL, NULL, bus_scope_method_abandon, SD_BUS_VTABLE_UNPRIVILEGED),
  52         SD_BUS_VTABLE_END
  53 };
  54
  55 static int bus_scope_set_transient_property(
  56                 Scope *s,
  57                 const char *name,
  58                 sd_bus_message *message,
  59                 UnitWriteFlags flags,
  60                 sd_bus_error *error) {
  61
  62         Unit *u = UNIT(s);
  63         int r;
  64
  65         assert(s);
  66         assert(name);
  67         assert(message);
  68
  69         flags |= UNIT_PRIVATE;
  70
  71         if (streq(name, "TimeoutStopUSec"))
  72                 return bus_set_transient_usec(u, name, &s->timeout_stop_usec, message, flags, error);
  73
  74         if (streq(name, "RuntimeMaxUSec"))
  75                 return bus_set_transient_usec(u, name, &s->runtime_max_usec, message, flags, error);
  76
  77         if (streq(name, "PIDs")) {
  78                 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
  79                 unsigned n = 0;
  80
  81                 r = sd_bus_message_enter_container(message, 'a', "u");
  82                 if (r < 0)
  83                         return r;
  84
  85                 for (;;) {
  86                         uint32_t upid;
  87                         pid_t pid;
  88
  89                         r = sd_bus_message_read(message, "u", &upid);
  90                         if (r < 0)
  91                                 return r;
  92                         if (r == 0)
  93                                 break;
  94
  95                         if (upid == 0) {
  96                                 if (!creds) {
  97                                         r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
  98                                         if (r < 0)
  99                                                 return r;
 100                                 }
 101
 102                                 r = sd_bus_creds_get_pid(creds, &pid);
 103                                 if (r < 0)
 104                                         return r;
 105                         } else
 106                                 pid = (uid_t) upid;
 107
 108                         r = unit_pid_attachable(u, pid, error);
 109                         if (r < 0)
 110                                 return r;
 111
 112                         if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 113                                 r = unit_watch_pid(u, pid, false);
 114                                 if (r < 0 && r != -EEXIST)
 115                                         return r;
 116                         }
 117
 118                         n++;
 119                 }
 120
 121                 r = sd_bus_message_exit_container(message);
 122                 if (r < 0)
 123                         return r;
 124
 125                 if (n <= 0)
 126                         return -EINVAL;
 127
 128                 return 1;
 129
 130         } else if (streq(name, "Controller")) {
 131                 const char *controller;
 132
 133                 /* We can't support direct connections with this, as direct connections know no service or unique name
 134                  * concept, but the Controller field stores exactly that. */
 135                 if (sd_bus_message_get_bus(message) != u->manager->api_bus)
 136                         return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Sorry, Controller= logic only supported via the bus.");
 137
 138                 r = sd_bus_message_read(message, "s", &controller);
 139                 if (r < 0)
 140                         return r;
 141
 142                 if (!isempty(controller) && !sd_bus_service_name_is_valid(controller))
 143                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Controller '%s' is not a valid bus name.", controller);
 144
 145                 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 146                         r = free_and_strdup(&s->controller, empty_to_null(controller));
 147                         if (r < 0)
 148                                 return r;
 149                 }
 150
 151                 return 1;
 152         }
 153
 154         return 0;
 155 }
 156
 157 int bus_scope_set_property(
 158                 Unit *u,
 159                 const char *name,
 160                 sd_bus_message *message,
 161                 UnitWriteFlags flags,
 162                 sd_bus_error *error) {
 163
 164         Scope *s = SCOPE(u);
 165         int r;
 166
 167         assert(s);
 168         assert(name);
 169         assert(message);
 170
 171         r = bus_cgroup_set_property(u, &s->cgroup_context, name, message, flags, error);
 172         if (r != 0)
 173                 return r;
 174
 175         if (u->load_state == UNIT_STUB) {
 176                 /* While we are created we still accept PIDs */
 177
 178                 r = bus_scope_set_transient_property(s, name, message, flags, error);
 179                 if (r != 0)
 180                         return r;
 181
 182                 r = bus_kill_context_set_transient_property(u, &s->kill_context, name, message, flags, error);
 183                 if (r != 0)
 184                         return r;
 185         }
 186
 187         return 0;
 188 }
 189
 190 int bus_scope_commit_properties(Unit *u) {
 191         assert(u);
 192
 193         unit_invalidate_cgroup_members_masks(u);
 194         unit_realize_cgroup(u);
 195
 196         return 0;
 197 }
 198
 199 int bus_scope_send_request_stop(Scope *s) {
 200         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
 201         _cleanup_free_ char *p = NULL;
 202         int r;
 203
 204         assert(s);
 205
 206         if (!s->controller)
 207                 return 0;
 208
 209         p = unit_dbus_path(UNIT(s));
 210         if (!p)
 211                 return -ENOMEM;
 212
 213         r = sd_bus_message_new_signal(
 214                         UNIT(s)->manager->api_bus,
 215                         &m,
 216                         p,
 217                         "org.freedesktop.systemd1.Scope",
 218                         "RequestStop");
 219         if (r < 0)
 220                 return r;
 221
 222         return sd_bus_send_to(UNIT(s)->manager->api_bus, m, s->controller, NULL);
 223 }
 224
 225 static int on_controller_gone(sd_bus_track *track, void *userdata) {
 226         Scope *s = userdata;
 227
 228         assert(track);
 229
 230         if (s->controller) {
 231                 log_unit_debug(UNIT(s), "Controller %s disappeared from bus.", s->controller);
 232                 unit_add_to_dbus_queue(UNIT(s));
 233                 s->controller = mfree(s->controller);
 234         }
 235
 236         s->controller_track = sd_bus_track_unref(s->controller_track);
 237
 238         return 0;
 239 }
 240
 241 int bus_scope_track_controller(Scope *s) {
 242         int r;
 243
 244         assert(s);
 245
 246         if (!s->controller || s->controller_track)
 247                 return 0;
 248
 249         r = sd_bus_track_new(UNIT(s)->manager->api_bus, &s->controller_track, on_controller_gone, s);
 250         if (r < 0)
 251                 return r;
 252
 253         r = sd_bus_track_add_name(s->controller_track, s->controller);
 254         if (r < 0) {
 255                 s->controller_track = sd_bus_track_unref(s->controller_track);
 256                 return r;
 257         }
 258
 259         return 0;
 260 }