src/core/dbus-job.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include "sd-bus.h"
   4
   5 #include "alloc-util.h"
   6 #include "bus-get-properties.h"
   7 #include "bus-util.h"
   8 #include "dbus-job.h"
   9 #include "dbus-unit.h"
  10 #include "dbus-util.h"
  11 #include "dbus.h"
  12 #include "job.h"
  13 #include "log.h"
  14 #include "selinux-access.h"
  15 #include "string-util.h"
  16 #include "strv.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 polkit */
  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, 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 (int 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
 124         SD_BUS_METHOD("Cancel", NULL, NULL, bus_job_method_cancel, SD_BUS_VTABLE_UNPRIVILEGED),
 125         SD_BUS_METHOD_WITH_ARGS("GetAfter",
 126                                  SD_BUS_NO_ARGS,
 127                                  SD_BUS_RESULT("a(usssoo)", jobs),
 128                                  bus_job_method_get_waiting_jobs,
 129                                  SD_BUS_VTABLE_UNPRIVILEGED),
 130         SD_BUS_METHOD_WITH_ARGS("GetBefore",
 131                                  SD_BUS_NO_ARGS,
 132                                  SD_BUS_RESULT("a(usssoo)", 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_PROPERTY("ActivationDetails", "a(ss)", bus_property_get_activation_details, offsetof(Job, activation_details), SD_BUS_VTABLE_PROPERTY_CONST),
 141         SD_BUS_VTABLE_END
 142 };
 143
 144 static int bus_job_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
 145         Manager *m = userdata;
 146         Job *j;
 147         int r;
 148
 149         assert(bus);
 150         assert(path);
 151         assert(interface);
 152         assert(found);
 153         assert(m);
 154
 155         r = manager_get_job_from_dbus_path(m, path, &j);
 156         if (r < 0)
 157                 return 0;
 158
 159         *found = j;
 160         return 1;
 161 }
 162
 163 static int bus_job_enumerate(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
 164         _cleanup_strv_free_ char **l = NULL;
 165         Manager *m = userdata;
 166         unsigned k = 0;
 167         Job *j;
 168
 169         l = new0(char*, hashmap_size(m->jobs)+1);
 170         if (!l)
 171                 return -ENOMEM;
 172
 173         HASHMAP_FOREACH(j, m->jobs) {
 174                 l[k] = job_dbus_path(j);
 175                 if (!l[k])
 176                         return -ENOMEM;
 177
 178                 k++;
 179         }
 180
 181         assert(hashmap_size(m->jobs) == k);
 182
 183         *nodes = TAKE_PTR(l);
 184
 185         return k;
 186 }
 187
 188 const BusObjectImplementation job_object = {
 189         "/org/freedesktop/systemd1/job",
 190         "org.freedesktop.systemd1.Job",
 191         .fallback_vtables = BUS_FALLBACK_VTABLES({bus_job_vtable, bus_job_find}),
 192         .node_enumerator = bus_job_enumerate,
 193 };
 194
 195 static int send_new_signal(sd_bus *bus, void *userdata) {
 196         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
 197         _cleanup_free_ char *p = NULL;
 198         Job *j = userdata;
 199         int r;
 200
 201         assert(bus);
 202         assert(j);
 203
 204         p = job_dbus_path(j);
 205         if (!p)
 206                 return -ENOMEM;
 207
 208         r = sd_bus_message_new_signal(
 209                         bus,
 210                         &m,
 211                         "/org/freedesktop/systemd1",
 212                         "org.freedesktop.systemd1.Manager",
 213                         "JobNew");
 214         if (r < 0)
 215                 return r;
 216
 217         r = sd_bus_message_append(m, "uos", j->id, p, j->unit->id);
 218         if (r < 0)
 219                 return r;
 220
 221         return sd_bus_send(bus, m, NULL);
 222 }
 223
 224 static int send_changed_signal(sd_bus *bus, void *userdata) {
 225         _cleanup_free_ char *p = NULL;
 226         Job *j = userdata;
 227
 228         assert(bus);
 229         assert(j);
 230
 231         p = job_dbus_path(j);
 232         if (!p)
 233                 return -ENOMEM;
 234
 235         return sd_bus_emit_properties_changed(bus, p, "org.freedesktop.systemd1.Job", "State", NULL);
 236 }
 237
 238 void bus_job_send_change_signal(Job *j) {
 239         int r;
 240
 241         assert(j);
 242
 243         /* Make sure that any change signal on the unit is reflected before we send out the change signal on the job */
 244         bus_unit_send_pending_change_signal(j->unit, true);
 245
 246         if (j->in_dbus_queue) {
 247                 LIST_REMOVE(dbus_queue, j->manager->dbus_job_queue, j);
 248                 j->in_dbus_queue = false;
 249         }
 250
 251         r = bus_foreach_bus(j->manager, j->bus_track, j->sent_dbus_new_signal ? send_changed_signal : send_new_signal, j);
 252         if (r < 0)
 253                 log_debug_errno(r, "Failed to send job change signal for %u: %m", j->id);
 254
 255         j->sent_dbus_new_signal = true;
 256 }
 257
 258 void bus_job_send_pending_change_signal(Job *j, bool including_new) {
 259         assert(j);
 260
 261         if (!j->in_dbus_queue)
 262                 return;
 263
 264         if (!j->sent_dbus_new_signal && !including_new)
 265                 return;
 266
 267         if (MANAGER_IS_RELOADING(j->unit->manager))
 268                 return;
 269
 270         bus_job_send_change_signal(j);
 271 }
 272
 273 static int send_removed_signal(sd_bus *bus, void *userdata) {
 274         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
 275         _cleanup_free_ char *p = NULL;
 276         Job *j = userdata;
 277         int r;
 278
 279         assert(bus);
 280         assert(j);
 281
 282         p = job_dbus_path(j);
 283         if (!p)
 284                 return -ENOMEM;
 285
 286         r = sd_bus_message_new_signal(
 287                         bus,
 288                         &m,
 289                         "/org/freedesktop/systemd1",
 290                         "org.freedesktop.systemd1.Manager",
 291                         "JobRemoved");
 292         if (r < 0)
 293                 return r;
 294
 295         r = sd_bus_message_append(m, "uoss", j->id, p, j->unit->id, job_result_to_string(j->result));
 296         if (r < 0)
 297                 return r;
 298
 299         return sd_bus_send(bus, m, NULL);
 300 }
 301
 302 void bus_job_send_removed_signal(Job *j) {
 303         int r;
 304
 305         assert(j);
 306
 307         if (!j->sent_dbus_new_signal)
 308                 bus_job_send_change_signal(j);
 309
 310         /* Make sure that any change signal on the unit is reflected before we send out the change signal on the job */
 311         bus_unit_send_pending_change_signal(j->unit, true);
 312
 313         r = bus_foreach_bus(j->manager, j->bus_track, send_removed_signal, j);
 314         if (r < 0)
 315                 log_debug_errno(r, "Failed to send job remove signal for %u: %m", j->id);
 316 }
 317
 318 static int bus_job_track_handler(sd_bus_track *t, void *userdata) {
 319         Job *j = userdata;
 320
 321         assert(t);
 322         assert(j);
 323
 324         j->bus_track = sd_bus_track_unref(j->bus_track); /* make sure we aren't called again */
 325
 326         /* Last client dropped off the bus, maybe we should GC this now? */
 327         job_add_to_gc_queue(j);
 328         return 0;
 329 }
 330
 331 static int bus_job_allocate_bus_track(Job *j) {
 332
 333         assert(j);
 334
 335         if (j->bus_track)
 336                 return 0;
 337
 338         return sd_bus_track_new(j->unit->manager->api_bus, &j->bus_track, bus_job_track_handler, j);
 339 }
 340
 341 int bus_job_coldplug_bus_track(Job *j) {
 342         int r;
 343         _cleanup_strv_free_ char **deserialized_clients = NULL;
 344
 345         assert(j);
 346
 347         deserialized_clients = TAKE_PTR(j->deserialized_clients);
 348
 349         if (strv_isempty(deserialized_clients))
 350                 return 0;
 351
 352         if (!j->manager->api_bus)
 353                 return 0;
 354
 355         r = bus_job_allocate_bus_track(j);
 356         if (r < 0)
 357                 return r;
 358
 359         return bus_track_add_name_many(j->bus_track, deserialized_clients);
 360 }
 361
 362 int bus_job_track_sender(Job *j, sd_bus_message *m) {
 363         int r;
 364
 365         assert(j);
 366         assert(m);
 367
 368         if (sd_bus_message_get_bus(m) != j->unit->manager->api_bus) {
 369                 j->ref_by_private_bus = true;
 370                 return 0;
 371         }
 372
 373         r = bus_job_allocate_bus_track(j);
 374         if (r < 0)
 375                 return r;
 376
 377         return sd_bus_track_add_sender(j->bus_track, m);
 378 }