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 <errno.h>
  23
  24 #include "dbus.h"
  25 #include "log.h"
  26 #include "dbus-job.h"
  27 #include "dbus-common.h"
  28 #include "selinux-access.h"
  29
  30 #define BUS_JOB_INTERFACE                                             \
  31         " <interface name=\"org.freedesktop.systemd1.Job\">\n"        \
  32         "  <method name=\"Cancel\"/>\n"                               \
  33         "  <property name=\"Id\" type=\"u\" access=\"read\"/>\n"      \
  34         "  <property name=\"Unit\" type=\"(so)\" access=\"read\"/>\n" \
  35         "  <property name=\"JobType\" type=\"s\" access=\"read\"/>\n" \
  36         "  <property name=\"State\" type=\"s\" access=\"read\"/>\n"   \
  37         " </interface>\n"
  38
  39 #define INTROSPECTION                                                 \
  40         DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE                     \
  41         "<node>\n"                                                    \
  42         BUS_JOB_INTERFACE                                             \
  43         BUS_PROPERTIES_INTERFACE                                      \
  44         BUS_PEER_INTERFACE                                            \
  45         BUS_INTROSPECTABLE_INTERFACE                                  \
  46         "</node>\n"
  47
  48 const char bus_job_interface[] _introspect_("Job") = BUS_JOB_INTERFACE;
  49
  50 #define INTERFACES_LIST                              \
  51         BUS_GENERIC_INTERFACES_LIST                  \
  52         "org.freedesktop.systemd1.Job\0"
  53
  54 #define INVALIDATING_PROPERTIES                 \
  55         "State\0"
  56
  57 static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_job_append_state, job_state, JobState);
  58 static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_job_append_type, job_type, JobType);
  59
  60 static int bus_job_append_unit(DBusMessageIter *i, const char *property, void *data) {
  61         Job *j = data;
  62         DBusMessageIter sub;
  63         char *p;
  64
  65         assert(i);
  66         assert(property);
  67         assert(j);
  68
  69         if (!dbus_message_iter_open_container(i, DBUS_TYPE_STRUCT, NULL, &sub))
  70                 return -ENOMEM;
  71
  72         p = unit_dbus_path(j->unit);
  73         if (!p)
  74                 return -ENOMEM;
  75
  76         if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &j->unit->id) ||
  77             !dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &p)) {
  78                 free(p);
  79                 return -ENOMEM;
  80         }
  81
  82         free(p);
  83
  84         if (!dbus_message_iter_close_container(i, &sub))
  85                 return -ENOMEM;
  86
  87         return 0;
  88 }
  89
  90 static const BusProperty bus_job_properties[] = {
  91         { "Id",      bus_property_append_uint32, "u", offsetof(Job, id)    },
  92         { "State",   bus_job_append_state,       "s", offsetof(Job, state) },
  93         { "JobType", bus_job_append_type,        "s", offsetof(Job, type)  },
  94         { "Unit",    bus_job_append_unit,     "(so)", 0 },
  95         { NULL, }
  96 };
  97
  98 static DBusHandlerResult bus_job_message_dispatch(Job *j, DBusConnection *connection, DBusMessage *message) {
  99         _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
 100
 101         if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Job", "Cancel")) {
 102
 103                 SELINUX_UNIT_ACCESS_CHECK(j->unit, connection, message, "stop");
 104                 job_finish_and_invalidate(j, JOB_CANCELED, true);
 105
 106                 reply = dbus_message_new_method_return(message);
 107                 if (!reply)
 108                         return DBUS_HANDLER_RESULT_NEED_MEMORY;
 109         } else {
 110                 const BusBoundProperties bps[] = {
 111                         { "org.freedesktop.systemd1.Job", bus_job_properties, j },
 112                         { NULL, }
 113                 };
 114
 115                 SELINUX_UNIT_ACCESS_CHECK(j->unit, connection, message, "status");
 116                 return bus_default_message_handler(connection, message, INTROSPECTION, INTERFACES_LIST, bps);
 117         }
 118
 119         if (!bus_maybe_send_reply(connection, message, reply))
 120                 return DBUS_HANDLER_RESULT_NEED_MEMORY;
 121
 122         return DBUS_HANDLER_RESULT_HANDLED;
 123 }
 124
 125 static DBusHandlerResult bus_job_message_handler(DBusConnection *connection, DBusMessage  *message, void *data) {
 126         Manager *m = data;
 127         Job *j;
 128         int r;
 129         _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
 130
 131         assert(connection);
 132         assert(message);
 133         assert(m);
 134
 135         if (streq(dbus_message_get_path(message), "/org/freedesktop/systemd1/job")) {
 136                 /* Be nice to gdbus and return introspection data for our mid-level paths */
 137
 138                 if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
 139                         char *introspection = NULL;
 140                         FILE *f;
 141                         Iterator i;
 142                         size_t size;
 143
 144                         SELINUX_ACCESS_CHECK(connection, message, "status");
 145
 146                         reply = dbus_message_new_method_return(message);
 147                         if (!reply)
 148                                 goto oom;
 149
 150                         /* We roll our own introspection code here, instead of
 151                          * relying on bus_default_message_handler() because we
 152                          * need to generate our introspection string
 153                          * dynamically. */
 154
 155                         f = open_memstream(&introspection, &size);
 156                         if (!f)
 157                                 goto oom;
 158
 159                         fputs(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
 160                               "<node>\n", f);
 161
 162                         fputs(BUS_INTROSPECTABLE_INTERFACE, f);
 163                         fputs(BUS_PEER_INTERFACE, f);
 164
 165                         HASHMAP_FOREACH(j, m->jobs, i)
 166                                 fprintf(f, "<node name=\"job/%lu\"/>", (unsigned long) j->id);
 167
 168                         fputs("</node>\n", f);
 169
 170                         if (ferror(f)) {
 171                                 fclose(f);
 172                                 free(introspection);
 173                                 goto oom;
 174                         }
 175
 176                         fclose(f);
 177
 178                         if (!introspection)
 179                                 goto oom;
 180
 181                         if (!dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection, DBUS_TYPE_INVALID)) {
 182                                 free(introspection);
 183                                 goto oom;
 184                         }
 185
 186                         free(introspection);
 187
 188                         if (!bus_maybe_send_reply(connection, message, reply))
 189                                 goto oom;
 190
 191                         return DBUS_HANDLER_RESULT_HANDLED;
 192                 }
 193
 194                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 195         }
 196
 197         r = manager_get_job_from_dbus_path(m, dbus_message_get_path(message), &j);
 198         if (r == -ENOMEM)
 199                 goto oom;
 200         if (r == -ENOENT) {
 201                 DBusError e;
 202
 203                 dbus_error_init(&e);
 204                 dbus_set_error_const(&e, DBUS_ERROR_UNKNOWN_OBJECT, "Unknown job");
 205                 return bus_send_error_reply(connection, message, &e, r);
 206         }
 207         if (r < 0)
 208                 return bus_send_error_reply(connection, message, NULL, r);
 209
 210         return bus_job_message_dispatch(j, connection, message);
 211
 212 oom:
 213         return DBUS_HANDLER_RESULT_NEED_MEMORY;
 214 }
 215
 216 const DBusObjectPathVTable bus_job_vtable = {
 217         .message_function = bus_job_message_handler
 218 };
 219
 220 static int job_send_message(Job *j, DBusMessage* (*new_message)(Job *j)) {
 221         _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
 222         int r;
 223
 224         assert(j);
 225         assert(new_message);
 226
 227         if (bus_has_subscriber(j->manager) || j->forgot_bus_clients) {
 228                 m = new_message(j);
 229                 if (!m)
 230                         return -ENOMEM;
 231
 232                 r = bus_broadcast(j->manager, m);
 233                 if (r < 0)
 234                         return r;
 235
 236         } else {
 237                 /* If nobody is subscribed, we just send the message
 238                  * to the client(s) which created the job */
 239                 JobBusClient *cl;
 240                 assert(j->bus_client_list);
 241
 242                 LIST_FOREACH(client, cl, j->bus_client_list) {
 243                         assert(cl->bus);
 244
 245                         m = new_message(j);
 246                         if (!m)
 247                                 return -ENOMEM;
 248
 249                         if (!dbus_message_set_destination(m, cl->name))
 250                                 return -ENOMEM;
 251
 252                         if (!dbus_connection_send(cl->bus, m, NULL))
 253                                 return -ENOMEM;
 254
 255                         dbus_message_unref(m);
 256                         m = NULL;
 257                 }
 258         }
 259
 260         return 0;
 261 }
 262
 263 static DBusMessage* new_change_signal_message(Job *j) {
 264         DBusMessage *m = NULL;
 265         char *p = NULL;
 266
 267         p = job_dbus_path(j);
 268         if (!p)
 269                 goto oom;
 270
 271         if (j->sent_dbus_new_signal) {
 272                 /* Send a properties changed signal */
 273                 m = bus_properties_changed_new(p, "org.freedesktop.systemd1.Job", INVALIDATING_PROPERTIES);
 274                 if (!m)
 275                         goto oom;
 276
 277         } else {
 278                 /* Send a new signal */
 279
 280                 m = dbus_message_new_signal("/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "JobNew");
 281                 if (!m)
 282                         goto oom;
 283
 284                 if (!dbus_message_append_args(m,
 285                                               DBUS_TYPE_UINT32, &j->id,
 286                                               DBUS_TYPE_OBJECT_PATH, &p,
 287                                               DBUS_TYPE_STRING, &j->unit->id,
 288                                               DBUS_TYPE_INVALID))
 289                         goto oom;
 290         }
 291
 292         return m;
 293
 294 oom:
 295         if (m)
 296                 dbus_message_unref(m);
 297         free(p);
 298         return NULL;
 299 }
 300
 301 static DBusMessage* new_removed_signal_message(Job *j) {
 302         DBusMessage *m = NULL;
 303         char *p = NULL;
 304         const char *r;
 305
 306         p = job_dbus_path(j);
 307         if (!p)
 308                 goto oom;
 309
 310         m = dbus_message_new_signal("/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "JobRemoved");
 311         if (!m)
 312                 goto oom;
 313
 314         r = job_result_to_string(j->result);
 315
 316         if (!dbus_message_append_args(m,
 317                                       DBUS_TYPE_UINT32, &j->id,
 318                                       DBUS_TYPE_OBJECT_PATH, &p,
 319                                       DBUS_TYPE_STRING, &j->unit->id,
 320                                       DBUS_TYPE_STRING, &r,
 321                                       DBUS_TYPE_INVALID))
 322                 goto oom;
 323
 324         return m;
 325
 326 oom:
 327         if (m)
 328                 dbus_message_unref(m);
 329         free(p);
 330         return NULL;
 331 }
 332
 333 void bus_job_send_change_signal(Job *j) {
 334         assert(j);
 335
 336         if (j->in_dbus_queue) {
 337                 LIST_REMOVE(Job, dbus_queue, j->manager->dbus_job_queue, j);
 338                 j->in_dbus_queue = false;
 339         }
 340
 341         if (!bus_has_subscriber(j->manager) && !j->bus_client_list && !j->forgot_bus_clients) {
 342                 j->sent_dbus_new_signal = true;
 343                 return;
 344         }
 345
 346         if (job_send_message(j, new_change_signal_message) < 0)
 347                 goto oom;
 348
 349         j->sent_dbus_new_signal = true;
 350
 351         return;
 352
 353 oom:
 354         log_error("Failed to allocate job change signal.");
 355 }
 356
 357 void bus_job_send_removed_signal(Job *j) {
 358         assert(j);
 359
 360         if (!bus_has_subscriber(j->manager) && !j->bus_client_list && !j->forgot_bus_clients)
 361                 return;
 362
 363         if (!j->sent_dbus_new_signal)
 364                 bus_job_send_change_signal(j);
 365
 366         if (job_send_message(j, new_removed_signal_message) < 0)
 367                 goto oom;
 368
 369         return;
 370
 371 oom:
 372         log_error("Failed to allocate job remove signal.");
 373 }