src/core/dbus-job.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include "log.h"
  23 #include "sd-bus.h"
  24 #include "selinux-access.h"
  25 #include "job.h"
  26 #include "dbus-job.h"
  27 #include "dbus-client-track.h"
  28
  29 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, job_type, JobType);
  30 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_state, job_state, JobState);
  31
  32 static int property_get_unit(
  33                 sd_bus *bus,
  34                 const char *path,
  35                 const char *interface,
  36                 const char *property,
  37                 sd_bus_message *reply,
  38                 sd_bus_error *error,
  39                 void *userdata) {
  40
  41         _cleanup_free_ char *p = NULL;
  42         Job *j = userdata;
  43
  44         assert(bus);
  45         assert(reply);
  46         assert(j);
  47
  48         p = unit_dbus_path(j->unit);
  49         if (!p)
  50                 return -ENOMEM;
  51
  52         return sd_bus_message_append(reply, "(so)", j->unit->id, p);
  53 }
  54
  55 static int method_cancel(sd_bus *bus, sd_bus_message *message, void *userdata) {
  56         Job *j = userdata;
  57
  58         assert(bus);
  59         assert(message);
  60         assert(j);
  61
  62         SELINUX_UNIT_ACCESS_CHECK(j->unit, bus, message, "stop");
  63         job_finish_and_invalidate(j, JOB_CANCELED, true);
  64
  65         return sd_bus_reply_method_return(message, NULL);
  66 }
  67
  68 const sd_bus_vtable bus_job_vtable[] = {
  69         SD_BUS_VTABLE_START(0),
  70         SD_BUS_METHOD("Cancel", NULL, NULL, method_cancel, 0),
  71         SD_BUS_PROPERTY("Id", "u", NULL, offsetof(Job, id), 0),
  72         SD_BUS_PROPERTY("Unit", "(so)", property_get_unit, 0, 0),
  73         SD_BUS_PROPERTY("JobType", "s", property_get_type, offsetof(Job, type), 0),
  74         SD_BUS_PROPERTY("State", "s", property_get_state, offsetof(Job, state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  75         SD_BUS_VTABLE_END
  76 };
  77
  78 static int foreach_client(Job *j, int (*send_message)(sd_bus *bus, const char *name, Job *j)) {
  79         BusTrackedClient *one_destination = NULL;
  80         Iterator i;
  81         sd_bus *b;
  82         unsigned n, m;
  83         int r;
  84
  85         assert(j);
  86         assert(send_message);
  87
  88         n = set_size(j->manager->subscribed);
  89         m = set_size(j->subscribed);
  90
  91         if (n <= 0 && m <= 0)
  92                 return 0;
  93
  94         if (n == 1 && m == 0)
  95                 one_destination = set_first(j->manager->subscribed);
  96         else if (n == 0 && m == 1)
  97                 one_destination = set_first(j->subscribed);
  98         else
  99                 one_destination = NULL;
 100
 101         if (one_destination)
 102                 return send_message(one_destination->bus, isempty(one_destination->name) ? NULL : one_destination->name, j);
 103
 104         /* Send to everybody */
 105         SET_FOREACH(b, j->manager->private_buses, i) {
 106                 r = send_message(b, NULL, j);
 107                 if (r < 0)
 108                         return r;
 109         }
 110
 111         if (j->manager->api_bus)
 112                 return send_message(j->manager->api_bus, NULL, j);
 113
 114         return 0;
 115 }
 116
 117 static int send_new_signal(sd_bus *bus, const char *destination, Job *j) {
 118         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 119         _cleanup_free_ char *p = NULL;
 120         int r;
 121
 122         assert(bus);
 123         assert(j);
 124
 125         p = job_dbus_path(j);
 126         if (!p)
 127                 return -ENOMEM;
 128
 129         r = sd_bus_message_new_signal(
 130                         bus,
 131                         "/org/freedesktop/systemd1",
 132                         "org.freedesktop.systemd1.Manager",
 133                         "JobNew",
 134                         &m);
 135         if (r < 0)
 136                 return r;
 137
 138         r = sd_bus_message_append(m, "uos", j->id, p, j->unit->id);
 139         if (r < 0)
 140                 return r;
 141
 142         return sd_bus_send_to(bus, m, destination, NULL);
 143 }
 144
 145 static int send_changed_signal(sd_bus *bus, const char *destination, Job *j) {
 146         _cleanup_free_ char *p = NULL;
 147
 148         assert(bus);
 149         assert(j);
 150
 151         p = job_dbus_path(j);
 152         if (!p)
 153                 return -ENOMEM;
 154
 155         return sd_bus_emit_properties_changed(bus, p, "org.freedesktop.systemd1.Job", "State", NULL);
 156 }
 157
 158 void bus_job_send_change_signal(Job *j) {
 159         int r;
 160
 161         assert(j);
 162
 163         if (j->in_dbus_queue) {
 164                 LIST_REMOVE(dbus_queue, j->manager->dbus_job_queue, j);
 165                 j->in_dbus_queue = false;
 166         }
 167
 168         r = foreach_client(j, j->sent_dbus_new_signal ? send_changed_signal : send_new_signal);
 169         if (r < 0)
 170                 log_warning("Failed to send job change signal for %u/%s: %s", j->id, j->unit->id, strerror(-r));
 171
 172         j->sent_dbus_new_signal = true;
 173 }
 174
 175 static int send_removed_signal(sd_bus *bus, const char *destination, Job *j) {
 176         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 177         _cleanup_free_ char *p = NULL;
 178         int r;
 179
 180         assert(bus);
 181         assert(j);
 182
 183         p = job_dbus_path(j);
 184         if (!p)
 185                 return -ENOMEM;
 186
 187
 188         r = sd_bus_message_new_signal(
 189                         bus,
 190                         "/org/freedesktop/systemd1",
 191                         "org.freedesktop.systemd1.Manager",
 192                         "JobRemoved",
 193                         &m);
 194         if (r < 0)
 195                 return r;
 196
 197         r = sd_bus_message_append(m, "uoss", j->id, p, j->unit->id, job_result_to_string(j->result));
 198         if (r < 0)
 199                 return r;
 200
 201         return sd_bus_send_to(bus, m, destination, NULL);
 202 }
 203
 204 void bus_job_send_removed_signal(Job *j) {
 205         int r;
 206
 207         assert(j);
 208
 209         if (!j->sent_dbus_new_signal)
 210                 bus_job_send_change_signal(j);
 211
 212         r = foreach_client(j, send_removed_signal);
 213         if (r < 0)
 214                 log_warning("Failed to send job removal signal for %u/%s: %s", j->id, j->unit->id, strerror(-r));
 215                 return;
 216 }