chiark / gitweb /
core: priorize notification fd processing over notification fd process via sd-event...
[elogind.git] / src / core / dbus-job.c
index 4ab88d0..8c12b52 100644 (file)
   along with systemd; If not, see <http://www.gnu.org/licenses/>.
 ***/
 
-#include <errno.h>
-
-#include "dbus.h"
 #include "log.h"
-#include "dbus-job.h"
-#include "dbus-common.h"
+#include "sd-bus.h"
 #include "selinux-access.h"
+#include "job.h"
+#include "dbus-job.h"
+#include "dbus-client-track.h"
+
+static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, job_type, JobType);
+static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_state, job_state, JobState);
+
+static int property_get_unit(
+                sd_bus *bus,
+                const char *path,
+                const char *interface,
+                const char *property,
+                sd_bus_message *reply,
+                void *userdata,
+                sd_bus_error *error) {
 
-#define BUS_JOB_INTERFACE                                             \
-        " <interface name=\"org.freedesktop.systemd1.Job\">\n"        \
-        "  <method name=\"Cancel\"/>\n"                               \
-        "  <property name=\"Id\" type=\"u\" access=\"read\"/>\n"      \
-        "  <property name=\"Unit\" type=\"(so)\" access=\"read\"/>\n" \
-        "  <property name=\"JobType\" type=\"s\" access=\"read\"/>\n" \
-        "  <property name=\"State\" type=\"s\" access=\"read\"/>\n"   \
-        " </interface>\n"
-
-#define INTROSPECTION                                                 \
-        DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE                     \
-        "<node>\n"                                                    \
-        BUS_JOB_INTERFACE                                             \
-        BUS_PROPERTIES_INTERFACE                                      \
-        BUS_PEER_INTERFACE                                            \
-        BUS_INTROSPECTABLE_INTERFACE                                  \
-        "</node>\n"
-
-const char bus_job_interface[] _introspect_("Job") = BUS_JOB_INTERFACE;
-
-#define INTERFACES_LIST                              \
-        BUS_GENERIC_INTERFACES_LIST                  \
-        "org.freedesktop.systemd1.Job\0"
-
-#define INVALIDATING_PROPERTIES                 \
-        "State\0"
-
-static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_job_append_state, job_state, JobState);
-static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_job_append_type, job_type, JobType);
-
-static int bus_job_append_unit(DBusMessageIter *i, const char *property, void *data) {
-        Job *j = data;
-        DBusMessageIter sub;
         _cleanup_free_ char *p = NULL;
+        Job *j = userdata;
 
-        assert(i);
-        assert(property);
+        assert(bus);
+        assert(reply);
         assert(j);
 
-        if (!dbus_message_iter_open_container(i, DBUS_TYPE_STRUCT, NULL, &sub))
-                return -ENOMEM;
-
         p = unit_dbus_path(j->unit);
         if (!p)
                 return -ENOMEM;
 
-        if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &j->unit->id) ||
-            !dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &p)) {
-                return -ENOMEM;
-        }
-
-        if (!dbus_message_iter_close_container(i, &sub))
-                return -ENOMEM;
-
-        return 0;
-}
-
-static const BusProperty bus_job_properties[] = {
-        { "Id",      bus_property_append_uint32, "u", offsetof(Job, id)    },
-        { "State",   bus_job_append_state,       "s", offsetof(Job, state) },
-        { "JobType", bus_job_append_type,        "s", offsetof(Job, type)  },
-        { "Unit",    bus_job_append_unit,     "(so)", 0 },
-        { NULL, }
-};
-
-static DBusHandlerResult bus_job_message_dispatch(Job *j, DBusConnection *connection, DBusMessage *message) {
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
-
-        if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Job", "Cancel")) {
-
-                SELINUX_UNIT_ACCESS_CHECK(j->unit, connection, message, "stop");
-                job_finish_and_invalidate(j, JOB_CANCELED, true);
-
-                reply = dbus_message_new_method_return(message);
-                if (!reply)
-                        return DBUS_HANDLER_RESULT_NEED_MEMORY;
-        } else {
-                const BusBoundProperties bps[] = {
-                        { "org.freedesktop.systemd1.Job", bus_job_properties, j },
-                        { NULL, }
-                };
-
-                SELINUX_UNIT_ACCESS_CHECK(j->unit, connection, message, "status");
-                return bus_default_message_handler(connection, message, INTROSPECTION, INTERFACES_LIST, bps);
-        }
-
-        if (!bus_maybe_send_reply(connection, message, reply))
-                return DBUS_HANDLER_RESULT_NEED_MEMORY;
-
-        return DBUS_HANDLER_RESULT_HANDLED;
+        return sd_bus_message_append(reply, "(so)", j->unit->id, p);
 }
 
-static DBusHandlerResult bus_job_message_handler(DBusConnection *connection, DBusMessage  *message, void *data) {
-        Manager *m = data;
-        Job *j;
+static int method_cancel(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
+        Job *j = userdata;
         int r;
-        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
 
-        assert(connection);
+        assert(bus);
         assert(message);
-        assert(m);
-
-        if (streq(dbus_message_get_path(message), "/org/freedesktop/systemd1/job")) {
-                /* Be nice to gdbus and return introspection data for our mid-level paths */
-
-                if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
-                        _cleanup_free_ char *introspection = NULL;
-                        FILE *f;
-                        Iterator i;
-                        size_t size;
-
-                        SELINUX_ACCESS_CHECK(connection, message, "status");
-
-                        reply = dbus_message_new_method_return(message);
-                        if (!reply)
-                                goto oom;
-
-                        /* We roll our own introspection code here, instead of
-                         * relying on bus_default_message_handler() because we
-                         * need to generate our introspection string
-                         * dynamically. */
-
-                        f = open_memstream(&introspection, &size);
-                        if (!f)
-                                goto oom;
-
-                        fputs(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
-                              "<node>\n", f);
-
-                        fputs(BUS_INTROSPECTABLE_INTERFACE, f);
-                        fputs(BUS_PEER_INTERFACE, f);
-
-                        HASHMAP_FOREACH(j, m->jobs, i)
-                                fprintf(f, "<node name=\"job/%lu\"/>", (unsigned long) j->id);
-
-                        fputs("</node>\n", f);
-
-                        if (ferror(f)) {
-                                fclose(f);
-                                goto oom;
-                        }
-
-                        fclose(f);
-
-                        if (!introspection)
-                                goto oom;
-
-                        if (!dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection, DBUS_TYPE_INVALID)) {
-                                goto oom;
-                        }
-
-                        if (!bus_maybe_send_reply(connection, message, reply))
-                                goto oom;
-
-                        return DBUS_HANDLER_RESULT_HANDLED;
-                }
-
-                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-        }
-
-        r = manager_get_job_from_dbus_path(m, dbus_message_get_path(message), &j);
-        if (r == -ENOMEM)
-                goto oom;
-        if (r == -ENOENT) {
-                DBusError e;
+        assert(j);
 
-                dbus_error_init(&e);
-                dbus_set_error_const(&e, DBUS_ERROR_UNKNOWN_OBJECT, "Unknown job");
-                return bus_send_error_reply(connection, message, &e, r);
-        }
+        r = selinux_unit_access_check(j->unit, bus, message, "stop", error);
         if (r < 0)
-                return bus_send_error_reply(connection, message, NULL, r);
+                return r;
 
-        return bus_job_message_dispatch(j, connection, message);
+        job_finish_and_invalidate(j, JOB_CANCELED, true);
 
-oom:
-        return DBUS_HANDLER_RESULT_NEED_MEMORY;
+        return sd_bus_reply_method_return(message, NULL);
 }
 
-const DBusObjectPathVTable bus_job_vtable = {
-        .message_function = bus_job_message_handler
+const sd_bus_vtable bus_job_vtable[] = {
+        SD_BUS_VTABLE_START(0),
+        SD_BUS_METHOD("Cancel", NULL, NULL, method_cancel, 0),
+        SD_BUS_PROPERTY("Id", "u", NULL, offsetof(Job, id), 0),
+        SD_BUS_PROPERTY("Unit", "(so)", property_get_unit, 0, 0),
+        SD_BUS_PROPERTY("JobType", "s", property_get_type, offsetof(Job, type), 0),
+        SD_BUS_PROPERTY("State", "s", property_get_state, offsetof(Job, state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+        SD_BUS_VTABLE_END
 };
 
-static int job_send_message(Job *j, DBusMessage* (*new_message)(Job *j)) {
-        _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
-        int r;
+static int foreach_client(Job *j, int (*send_message)(sd_bus *bus, const char *name, Job *j)) {
+        BusTrackedClient *one_destination = NULL;
+        Iterator i;
+        sd_bus *b;
+        unsigned n, m;
+        int r, ret;
 
         assert(j);
-        assert(new_message);
-
-        if (bus_has_subscriber(j->manager) || j->forgot_bus_clients) {
-                m = new_message(j);
-                if (!m)
-                        return -ENOMEM;
+        assert(send_message);
 
-                r = bus_broadcast(j->manager, m);
-                if (r < 0)
-                        return r;
+        n = set_size(j->manager->subscribed);
+        m = set_size(j->subscribed);
 
-        } else {
-                /* If nobody is subscribed, we just send the message
-                 * to the client(s) which created the job */
-                JobBusClient *cl;
-                assert(j->bus_client_list);
+        if (n <= 0 && m <= 0)
+                return 0;
 
-                LIST_FOREACH(client, cl, j->bus_client_list) {
-                        assert(cl->bus);
+        if (n == 1 && m == 0)
+                one_destination = set_first(j->manager->subscribed);
+        else if (n == 0 && m == 1)
+                one_destination = set_first(j->subscribed);
+        else
+                one_destination = NULL;
 
-                        m = new_message(j);
-                        if (!m)
-                                return -ENOMEM;
+        if (one_destination)
+                return send_message(one_destination->bus, isempty(one_destination->name) ? NULL : one_destination->name, j);
 
-                        if (!dbus_message_set_destination(m, cl->name))
-                                return -ENOMEM;
+        ret = 0;
 
-                        if (!dbus_connection_send(cl->bus, m, NULL))
-                                return -ENOMEM;
+        /* Send to everybody */
+        SET_FOREACH(b, j->manager->private_buses, i) {
+                r = send_message(b, NULL, j);
+                if (r < 0)
+                        ret = r;
+        }
 
-                        dbus_message_unref(m);
-                        m = NULL;
-                }
+        if (j->manager->api_bus) {
+                r = send_message(j->manager->api_bus, NULL, j);
+                if (r < 0)
+                        ret = r;
         }
 
-        return 0;
+        return ret;
 }
 
-static DBusMessage* new_change_signal_message(Job *j) {
+static int send_new_signal(sd_bus *bus, const char *destination, Job *j) {
+        _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
         _cleanup_free_ char *p = NULL;
-        DBusMessage *m;
+        int r;
+
+        assert(bus);
+        assert(j);
 
         p = job_dbus_path(j);
         if (!p)
-                return NULL;
-
-        if (j->sent_dbus_new_signal) {
-                /* Send a properties changed signal */
-                m = bus_properties_changed_new(p, "org.freedesktop.systemd1.Job", INVALIDATING_PROPERTIES);
-                if (!m)
-                        return NULL;
-
-        } else {
-                /* Send a new signal */
-
-                m = dbus_message_new_signal("/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "JobNew");
-                if (!m)
-                        return NULL;
-
-                if (!dbus_message_append_args(m,
-                                              DBUS_TYPE_UINT32, &j->id,
-                                              DBUS_TYPE_OBJECT_PATH, &p,
-                                              DBUS_TYPE_STRING, &j->unit->id,
-                                              DBUS_TYPE_INVALID)) {
-                        dbus_message_unref(m);
-                        return NULL;
-                }
-        }
+                return -ENOMEM;
 
-        return m;
+        r = sd_bus_message_new_signal(
+                        bus,
+                        "/org/freedesktop/systemd1",
+                        "org.freedesktop.systemd1.Manager",
+                        "JobNew",
+                        &m);
+        if (r < 0)
+                return r;
+
+        r = sd_bus_message_append(m, "uos", j->id, p, j->unit->id);
+        if (r < 0)
+                return r;
+
+        return sd_bus_send_to(bus, m, destination, NULL);
 }
 
-static DBusMessage* new_removed_signal_message(Job *j) {
+static int send_changed_signal(sd_bus *bus, const char *destination, Job *j) {
         _cleanup_free_ char *p = NULL;
-        DBusMessage *m;
-        const char *r;
+
+        assert(bus);
+        assert(j);
 
         p = job_dbus_path(j);
         if (!p)
-                return NULL;
-
-        m = dbus_message_new_signal("/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "JobRemoved");
-        if (!m)
-                return NULL;
-
-        r = job_result_to_string(j->result);
-
-        if (!dbus_message_append_args(m,
-                                      DBUS_TYPE_UINT32, &j->id,
-                                      DBUS_TYPE_OBJECT_PATH, &p,
-                                      DBUS_TYPE_STRING, &j->unit->id,
-                                      DBUS_TYPE_STRING, &r,
-                                      DBUS_TYPE_INVALID)) {
-                dbus_message_unref(m);
-                return NULL;
-        }
+                return -ENOMEM;
 
-        return m;
+        return sd_bus_emit_properties_changed(bus, p, "org.freedesktop.systemd1.Job", "State", NULL);
 }
 
 void bus_job_send_change_signal(Job *j) {
+        int r;
+
         assert(j);
 
         if (j->in_dbus_queue) {
-                LIST_REMOVE(Job, dbus_queue, j->manager->dbus_job_queue, j);
+                LIST_REMOVE(dbus_queue, j->manager->dbus_job_queue, j);
                 j->in_dbus_queue = false;
         }
 
-        if (!bus_has_subscriber(j->manager) && !j->bus_client_list && !j->forgot_bus_clients) {
-                j->sent_dbus_new_signal = true;
-                return;
-        }
-
-        if (job_send_message(j, new_change_signal_message) < 0)
-                goto oom;
+        r = foreach_client(j, j->sent_dbus_new_signal ? send_changed_signal : send_new_signal);
+        if (r < 0)
+                log_debug("Failed to send job change signal for %u: %s", j->id, strerror(-r));
 
         j->sent_dbus_new_signal = true;
+}
+
+static int send_removed_signal(sd_bus *bus, const char *destination, Job *j) {
+        _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
+        _cleanup_free_ char *p = NULL;
+        int r;
+
+        assert(bus);
+        assert(j);
+
+        p = job_dbus_path(j);
+        if (!p)
+                return -ENOMEM;
+
+
+        r = sd_bus_message_new_signal(
+                        bus,
+                        "/org/freedesktop/systemd1",
+                        "org.freedesktop.systemd1.Manager",
+                        "JobRemoved",
+                        &m);
+        if (r < 0)
+                return r;
 
-        return;
+        r = sd_bus_message_append(m, "uoss", j->id, p, j->unit->id, job_result_to_string(j->result));
+        if (r < 0)
+                return r;
 
-oom:
-        log_error("Failed to allocate job change signal.");
+        return sd_bus_send_to(bus, m, destination, NULL);
 }
 
 void bus_job_send_removed_signal(Job *j) {
-        assert(j);
+        int r;
 
-        if (!bus_has_subscriber(j->manager) && !j->bus_client_list && !j->forgot_bus_clients)
-                return;
+        assert(j);
 
         if (!j->sent_dbus_new_signal)
                 bus_job_send_change_signal(j);
 
-        if (job_send_message(j, new_removed_signal_message) < 0)
-                goto oom;
-
-        return;
-
-oom:
-        log_error("Failed to allocate job remove signal.");
+        r = foreach_client(j, send_removed_signal);
+        if (r < 0)
+                log_debug("Failed to send job remove signal for %u: %s", j->id, strerror(-r));
 }