src/core/dbus-scope.c

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