src/core/dbus-job.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2010 Lennart Poettering
   6 ***/
   7
   8 #include "sd-bus.h"
   9
  10 #include "alloc-util.h"
  11 #include "dbus-job.h"
  12 #include "dbus.h"
  13 #include "job.h"
  14 #include "log.h"
  15 #include "selinux-access.h"
  16 #include "string-util.h"
  17
  18 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, job_type, JobType);
  19 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_state, job_state, JobState);
  20
  21 static int property_get_unit(
  22                 sd_bus *bus,
  23                 const char *path,
  24                 const char *interface,
  25                 const char *property,
  26                 sd_bus_message *reply,
  27                 void *userdata,
  28                 sd_bus_error *error) {
  29
  30         _cleanup_free_ char *p = NULL;
  31         Job *j = userdata;
  32
  33         assert(bus);
  34         assert(reply);
  35         assert(j);
  36
  37         p = unit_dbus_path(j->unit);
  38         if (!p)
  39                 return -ENOMEM;
  40
  41         return sd_bus_message_append(reply, "(so)", j->unit->id, p);
  42 }
  43
  44 int bus_job_method_cancel(sd_bus_message *message, void *userdata, sd_bus_error *error) {
  45         Job *j = userdata;
  46         int r;
  47
  48         assert(message);
  49         assert(j);
  50
  51         r = mac_selinux_unit_access_check(j->unit, message, "stop", error);
  52         if (r < 0)
  53                 return r;
  54
  55         /* Access is granted to the job owner */
  56         if (!sd_bus_track_contains(j->bus_track, sd_bus_message_get_sender(message))) {
  57
  58                 /* And for everybody else consult PolicyKit */
  59                 r = bus_verify_manage_units_async(j->unit->manager, message, error);
  60                 if (r < 0)
  61                         return r;
  62                 if (r == 0)
  63                         return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
  64         }
  65
  66         job_finish_and_invalidate(j, JOB_CANCELED, true, false);
  67
  68         return sd_bus_reply_method_return(message, NULL);
  69 }
  70
  71 int bus_job_method_get_waiting_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
  72         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
  73         _cleanup_free_ Job **list = NULL;
  74         Job *j = userdata;
  75         int r, i, n;
  76
  77         if (strstr(sd_bus_message_get_member(message), "After"))
  78                 n = job_get_after(j, &list);
  79         else
  80                 n = job_get_before(j, &list);
  81         if (n < 0)
  82                 return n;
  83
  84         r = sd_bus_message_new_method_return(message, &reply);
  85         if (r < 0)
  86                 return r;
  87
  88         r = sd_bus_message_open_container(reply, 'a', "(usssoo)");
  89         if (r < 0)
  90                 return r;
  91
  92         for (i = 0; i < n; i ++) {
  93                 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
  94
  95                 job_path = job_dbus_path(list[i]);
  96                 if (!job_path)
  97                         return -ENOMEM;
  98
  99                 unit_path = unit_dbus_path(list[i]->unit);
 100                 if (!unit_path)
 101                         return -ENOMEM;
 102
 103                 r = sd_bus_message_append(reply, "(usssoo)",
 104                                           list[i]->id,
 105                                           list[i]->unit->id,
 106                                           job_type_to_string(list[i]->type),
 107                                           job_state_to_string(list[i]->state),
 108                                           job_path,
 109                                           unit_path);
 110                 if (r < 0)
 111                         return r;
 112         }
 113
 114         r = sd_bus_message_close_container(reply);
 115         if (r < 0)
 116                 return r;
 117
 118         return sd_bus_send(NULL, reply, NULL);
 119 }
 120
 121 const sd_bus_vtable bus_job_vtable[] = {
 122         SD_BUS_VTABLE_START(0),
 123         SD_BUS_METHOD("Cancel", NULL, NULL, bus_job_method_cancel, SD_BUS_VTABLE_UNPRIVILEGED),
 124         SD_BUS_METHOD("GetAfter", NULL, "a(usssoo)", bus_job_method_get_waiting_jobs, SD_BUS_VTABLE_UNPRIVILEGED),
 125         SD_BUS_METHOD("GetBefore", NULL, "a(usssoo)", bus_job_method_get_waiting_jobs, SD_BUS_VTABLE_UNPRIVILEGED),
 126         SD_BUS_PROPERTY("Id", "u", NULL, offsetof(Job, id), SD_BUS_VTABLE_PROPERTY_CONST),
 127         SD_BUS_PROPERTY("Unit", "(so)", property_get_unit, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 128         SD_BUS_PROPERTY("JobType", "s", property_get_type, offsetof(Job, type), SD_BUS_VTABLE_PROPERTY_CONST),
 129         SD_BUS_PROPERTY("State", "s", property_get_state, offsetof(Job, state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 130         SD_BUS_VTABLE_END
 131 };
 132
 133 static int send_new_signal(sd_bus *bus, void *userdata) {
 134         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
 135         _cleanup_free_ char *p = NULL;
 136         Job *j = userdata;
 137         int r;
 138
 139         assert(bus);
 140         assert(j);
 141
 142         p = job_dbus_path(j);
 143         if (!p)
 144                 return -ENOMEM;
 145
 146         r = sd_bus_message_new_signal(
 147                         bus,
 148                         &m,
 149                         "/org/freedesktop/systemd1",
 150                         "org.freedesktop.systemd1.Manager",
 151                         "JobNew");
 152         if (r < 0)
 153                 return r;
 154
 155         r = sd_bus_message_append(m, "uos", j->id, p, j->unit->id);
 156         if (r < 0)
 157                 return r;
 158
 159         return sd_bus_send(bus, m, NULL);
 160 }
 161
 162 static int send_changed_signal(sd_bus *bus, void *userdata) {
 163         _cleanup_free_ char *p = NULL;
 164         Job *j = userdata;
 165
 166         assert(bus);
 167         assert(j);
 168
 169         p = job_dbus_path(j);
 170         if (!p)
 171                 return -ENOMEM;
 172
 173         return sd_bus_emit_properties_changed(bus, p, "org.freedesktop.systemd1.Job", "State", NULL);
 174 }
 175
 176 void bus_job_send_change_signal(Job *j) {
 177         int r;
 178
 179         assert(j);
 180
 181         if (j->in_dbus_queue) {
 182                 LIST_REMOVE(dbus_queue, j->manager->dbus_job_queue, j);
 183                 j->in_dbus_queue = false;
 184         }
 185
 186         r = bus_foreach_bus(j->manager, j->bus_track, j->sent_dbus_new_signal ? send_changed_signal : send_new_signal, j);
 187         if (r < 0)
 188                 log_debug_errno(r, "Failed to send job change signal for %u: %m", j->id);
 189
 190         j->sent_dbus_new_signal = true;
 191 }
 192
 193 static int send_removed_signal(sd_bus *bus, void *userdata) {
 194         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
 195         _cleanup_free_ char *p = NULL;
 196         Job *j = userdata;
 197         int r;
 198
 199         assert(bus);
 200         assert(j);
 201
 202         p = job_dbus_path(j);
 203         if (!p)
 204                 return -ENOMEM;
 205
 206         r = sd_bus_message_new_signal(
 207                         bus,
 208                         &m,
 209                         "/org/freedesktop/systemd1",
 210                         "org.freedesktop.systemd1.Manager",
 211                         "JobRemoved");
 212         if (r < 0)
 213                 return r;
 214
 215         r = sd_bus_message_append(m, "uoss", j->id, p, j->unit->id, job_result_to_string(j->result));
 216         if (r < 0)
 217                 return r;
 218
 219         return sd_bus_send(bus, m, NULL);
 220 }
 221
 222 void bus_job_send_removed_signal(Job *j) {
 223         int r;
 224
 225         assert(j);
 226
 227         if (!j->sent_dbus_new_signal)
 228                 bus_job_send_change_signal(j);
 229
 230         r = bus_foreach_bus(j->manager, j->bus_track, send_removed_signal, j);
 231         if (r < 0)
 232                 log_debug_errno(r, "Failed to send job remove signal for %u: %m", j->id);
 233 }
 234
 235 static int bus_job_track_handler(sd_bus_track *t, void *userdata) {
 236         Job *j = userdata;
 237
 238         assert(t);
 239         assert(j);
 240
 241         j->bus_track = sd_bus_track_unref(j->bus_track); /* make sure we aren't called again */
 242
 243         /* Last client dropped off the bus, maybe we should GC this now? */
 244         job_add_to_gc_queue(j);
 245         return 0;
 246 }
 247
 248 static int bus_job_allocate_bus_track(Job *j) {
 249
 250         assert(j);
 251
 252         if (j->bus_track)
 253                 return 0;
 254
 255         return sd_bus_track_new(j->unit->manager->api_bus, &j->bus_track, bus_job_track_handler, j);
 256 }
 257
 258 int bus_job_coldplug_bus_track(Job *j) {
 259         int r = 0;
 260         _cleanup_strv_free_ char **deserialized_clients = NULL;
 261
 262         assert(j);
 263
 264         deserialized_clients = TAKE_PTR(j->deserialized_clients);
 265
 266         if (strv_isempty(deserialized_clients))
 267                 return 0;
 268
 269         if (!j->manager->api_bus)
 270                 return 0;
 271
 272         r = bus_job_allocate_bus_track(j);
 273         if (r < 0)
 274                 return r;
 275
 276         return bus_track_add_name_many(j->bus_track, deserialized_clients);
 277 }
 278
 279 int bus_job_track_sender(Job *j, sd_bus_message *m) {
 280         int r;
 281
 282         assert(j);
 283         assert(m);
 284
 285         if (sd_bus_message_get_bus(m) != j->unit->manager->api_bus) {
 286                 j->ref_by_private_bus = true;
 287                 return 0;
 288         }
 289
 290         r = bus_job_allocate_bus_track(j);
 291         if (r < 0)
 292                 return r;
 293
 294         return sd_bus_track_add_sender(j->bus_track, m);
 295 }