src/core/dbus-job.c

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