src/core/dbus-scope.c

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