src/core/dbus-job.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include "sd-bus.h"
   4
   5 #include "alloc-util.h"
   6 #include "bus-util.h"
   7 #include "dbus-job.h"
   8 #include "dbus-unit.h"
   9 #include "dbus.h"
  10 #include "job.h"
  11 #include "log.h"
  12 #include "selinux-access.h"
  13 #include "string-util.h"
  14 #include "strv.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 polkit */
  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
 122         SD_BUS_METHOD("Cancel", NULL, NULL, bus_job_method_cancel, SD_BUS_VTABLE_UNPRIVILEGED),
 123         SD_BUS_METHOD_WITH_NAMES("GetAfter",
 124                                  NULL,,
 125                                  "a(usssoo)",
 126                                  SD_BUS_PARAM(jobs),
 127                                  bus_job_method_get_waiting_jobs,
 128                                  SD_BUS_VTABLE_UNPRIVILEGED),
 129         SD_BUS_METHOD_WITH_NAMES("GetBefore",
 130                                  NULL,,
 131                                  "a(usssoo)",
 132                                  SD_BUS_PARAM(jobs),
 133                                  bus_job_method_get_waiting_jobs,
 134                                  SD_BUS_VTABLE_UNPRIVILEGED),
 135
 136         SD_BUS_PROPERTY("Id", "u", NULL, offsetof(Job, id), SD_BUS_VTABLE_PROPERTY_CONST),
 137         SD_BUS_PROPERTY("Unit", "(so)", property_get_unit, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 138         SD_BUS_PROPERTY("JobType", "s", property_get_type, offsetof(Job, type), SD_BUS_VTABLE_PROPERTY_CONST),
 139         SD_BUS_PROPERTY("State", "s", property_get_state, offsetof(Job, state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 140         SD_BUS_VTABLE_END
 141 };
 142
 143 static int send_new_signal(sd_bus *bus, void *userdata) {
 144         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
 145         _cleanup_free_ char *p = NULL;
 146         Job *j = userdata;
 147         int r;
 148
 149         assert(bus);
 150         assert(j);
 151
 152         p = job_dbus_path(j);
 153         if (!p)
 154                 return -ENOMEM;
 155
 156         r = sd_bus_message_new_signal(
 157                         bus,
 158                         &m,
 159                         "/org/freedesktop/systemd1",
 160                         "org.freedesktop.systemd1.Manager",
 161                         "JobNew");
 162         if (r < 0)
 163                 return r;
 164
 165         r = sd_bus_message_append(m, "uos", j->id, p, j->unit->id);
 166         if (r < 0)
 167                 return r;
 168
 169         return sd_bus_send(bus, m, NULL);
 170 }
 171
 172 static int send_changed_signal(sd_bus *bus, void *userdata) {
 173         _cleanup_free_ char *p = NULL;
 174         Job *j = userdata;
 175
 176         assert(bus);
 177         assert(j);
 178
 179         p = job_dbus_path(j);
 180         if (!p)
 181                 return -ENOMEM;
 182
 183         return sd_bus_emit_properties_changed(bus, p, "org.freedesktop.systemd1.Job", "State", NULL);
 184 }
 185
 186 void bus_job_send_change_signal(Job *j) {
 187         int r;
 188
 189         assert(j);
 190
 191         /* Make sure that any change signal on the unit is reflected before we send out the change signal on the job */
 192         bus_unit_send_pending_change_signal(j->unit, true);
 193
 194         if (j->in_dbus_queue) {
 195                 LIST_REMOVE(dbus_queue, j->manager->dbus_job_queue, j);
 196                 j->in_dbus_queue = false;
 197         }
 198
 199         r = bus_foreach_bus(j->manager, j->bus_track, j->sent_dbus_new_signal ? send_changed_signal : send_new_signal, j);
 200         if (r < 0)
 201                 log_debug_errno(r, "Failed to send job change signal for %u: %m", j->id);
 202
 203         j->sent_dbus_new_signal = true;
 204 }
 205
 206 void bus_job_send_pending_change_signal(Job *j, bool including_new) {
 207         assert(j);
 208
 209         if (!j->in_dbus_queue)
 210                 return;
 211
 212         if (!j->sent_dbus_new_signal && !including_new)
 213                 return;
 214
 215         if (MANAGER_IS_RELOADING(j->unit->manager))
 216                 return;
 217
 218         bus_job_send_change_signal(j);
 219 }
 220
 221 static int send_removed_signal(sd_bus *bus, void *userdata) {
 222         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
 223         _cleanup_free_ char *p = NULL;
 224         Job *j = userdata;
 225         int r;
 226
 227         assert(bus);
 228         assert(j);
 229
 230         p = job_dbus_path(j);
 231         if (!p)
 232                 return -ENOMEM;
 233
 234         r = sd_bus_message_new_signal(
 235                         bus,
 236                         &m,
 237                         "/org/freedesktop/systemd1",
 238                         "org.freedesktop.systemd1.Manager",
 239                         "JobRemoved");
 240         if (r < 0)
 241                 return r;
 242
 243         r = sd_bus_message_append(m, "uoss", j->id, p, j->unit->id, job_result_to_string(j->result));
 244         if (r < 0)
 245                 return r;
 246
 247         return sd_bus_send(bus, m, NULL);
 248 }
 249
 250 void bus_job_send_removed_signal(Job *j) {
 251         int r;
 252
 253         assert(j);
 254
 255         if (!j->sent_dbus_new_signal)
 256                 bus_job_send_change_signal(j);
 257
 258         /* Make sure that any change signal on the unit is reflected before we send out the change signal on the job */
 259         bus_unit_send_pending_change_signal(j->unit, true);
 260
 261         r = bus_foreach_bus(j->manager, j->bus_track, send_removed_signal, j);
 262         if (r < 0)
 263                 log_debug_errno(r, "Failed to send job remove signal for %u: %m", j->id);
 264 }
 265
 266 static int bus_job_track_handler(sd_bus_track *t, void *userdata) {
 267         Job *j = userdata;
 268
 269         assert(t);
 270         assert(j);
 271
 272         j->bus_track = sd_bus_track_unref(j->bus_track); /* make sure we aren't called again */
 273
 274         /* Last client dropped off the bus, maybe we should GC this now? */
 275         job_add_to_gc_queue(j);
 276         return 0;
 277 }
 278
 279 static int bus_job_allocate_bus_track(Job *j) {
 280
 281         assert(j);
 282
 283         if (j->bus_track)
 284                 return 0;
 285
 286         return sd_bus_track_new(j->unit->manager->api_bus, &j->bus_track, bus_job_track_handler, j);
 287 }
 288
 289 int bus_job_coldplug_bus_track(Job *j) {
 290         int r = 0;
 291         _cleanup_strv_free_ char **deserialized_clients = NULL;
 292
 293         assert(j);
 294
 295         deserialized_clients = TAKE_PTR(j->deserialized_clients);
 296
 297         if (strv_isempty(deserialized_clients))
 298                 return 0;
 299
 300         if (!j->manager->api_bus)
 301                 return 0;
 302
 303         r = bus_job_allocate_bus_track(j);
 304         if (r < 0)
 305                 return r;
 306
 307         return bus_track_add_name_many(j->bus_track, deserialized_clients);
 308 }
 309
 310 int bus_job_track_sender(Job *j, sd_bus_message *m) {
 311         int r;
 312
 313         assert(j);
 314         assert(m);
 315
 316         if (sd_bus_message_get_bus(m) != j->unit->manager->api_bus) {
 317                 j->ref_by_private_bus = true;
 318                 return 0;
 319         }
 320
 321         r = bus_job_allocate_bus_track(j);
 322         if (r < 0)
 323                 return r;
 324
 325         return sd_bus_track_add_sender(j->bus_track, m);
 326 }