X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fdbus.c;h=576f7850b244ab11b01c8241e55f8d3f89f0bfd3;hp=5caf1eb19176dfafd579986ec1cc085f56561b56;hb=7b97f4773207d9e1301f5263229ceba26b515756;hpb=4288f619215e3dda0b75113d78e4fb7ba219ed58 diff --git a/src/dbus.c b/src/dbus.c index 5caf1eb19..576f7850b 100644 --- a/src/dbus.c +++ b/src/dbus.c @@ -40,6 +40,10 @@ #include "dbus-automount.h" #include "dbus-snapshot.h" #include "dbus-swap.h" +#include "dbus-timer.h" +#include "dbus-path.h" + +#define CONNECTIONS_MAX 52 static const char bus_properties_interface[] = BUS_PROPERTIES_INTERFACE; static const char bus_introspectable_interface[] = BUS_INTROSPECTABLE_INTERFACE; @@ -58,35 +62,30 @@ const char *const bus_interface_table[] = { "org.freedesktop.systemd1.Automount", bus_automount_interface, "org.freedesktop.systemd1.Snapshot", bus_snapshot_interface, "org.freedesktop.systemd1.Swap", bus_swap_interface, + "org.freedesktop.systemd1.Timer", bus_timer_interface, + "org.freedesktop.systemd1.Path", bus_path_interface, NULL }; -static void api_bus_dispatch_status(DBusConnection *bus, DBusDispatchStatus status, void *data) { - Manager *m = data; - - assert(bus); - assert(m); - - if (!m->api_bus) - return; - - assert(m->api_bus == bus); - - m->request_api_bus_dispatch = status != DBUS_DISPATCH_COMPLETE; -} +static const char *error_to_dbus(int error); +static void bus_done_api(Manager *m); +static void bus_done_system(Manager *m); +static void bus_done_private(Manager *m); -static void system_bus_dispatch_status(DBusConnection *bus, DBusDispatchStatus status, void *data) { +static void bus_dispatch_status(DBusConnection *bus, DBusDispatchStatus status, void *data) { Manager *m = data; assert(bus); assert(m); - if (!m->system_bus) - return; - - assert(m->system_bus == bus); + /* We maintain two sets, one for those connections where we + * requested a dispatch, and another where we didn't. And then, + * we move the connections between the two sets. */ - m->request_system_bus_dispatch = status != DBUS_DISPATCH_COMPLETE; + if (status == DBUS_DISPATCH_COMPLETE) + set_move_one(m->bus_connections, m->bus_connections_for_dispatch, bus); + else + set_move_one(m->bus_connections_for_dispatch, m->bus_connections, bus); } static uint32_t bus_flags_to_events(DBusWatch *bus_watch) { @@ -326,9 +325,10 @@ static void bus_toggle_timeout(DBusTimeout *timeout, void *data) { log_error("Failed to rearm timer: %s", strerror(-r)); } -static DBusHandlerResult api_bus_message_filter(DBusConnection *connection, DBusMessage *message, void *data) { +static DBusHandlerResult api_bus_message_filter(DBusConnection *connection, DBusMessage *message, void *data) { Manager *m = data; DBusError error; + DBusMessage *reply = NULL; assert(connection); assert(message); @@ -355,8 +355,8 @@ static DBusHandlerResult api_bus_message_filter(DBusConnection *connection, DBu DBUS_TYPE_INVALID)) log_error("Failed to parse NameOwnerChanged message: %s", error.message); else { - if (set_remove(m->subscribed, (char*) name)) - log_debug("Subscription client vanished: %s (left: %u)", name, set_size(m->subscribed)); + if (set_remove(BUS_CONNECTION_SUBSCRIBED(m, connection), (char*) name)) + log_debug("Subscription client vanished: %s (left: %u)", name, set_size(BUS_CONNECTION_SUBSCRIBED(m, connection))); if (old_owner[0] == 0) old_owner = NULL; @@ -366,13 +366,72 @@ static DBusHandlerResult api_bus_message_filter(DBusConnection *connection, DBu manager_dispatch_bus_name_owner_changed(m, name, old_owner, new_owner); } + } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Activator", "ActivationRequest")) { + const char *name; + + if (!dbus_message_get_args(message, &error, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_INVALID)) + log_error("Failed to parse ActivationRequest message: %s", error.message); + else { + int r; + Unit *u; + + log_debug("Got D-Bus activation request for %s", name); + + r = manager_load_unit(m, name, NULL, &u); + + if (r >= 0 && u->meta.only_by_dependency) + r = -EPERM; + + if (r >= 0) + r = manager_add_job(m, JOB_START, u, JOB_REPLACE, true, NULL); + + if (r < 0) { + const char *id, *text; + + log_warning("D-Bus activation failed for %s: %s", name, strerror(-r)); + + if (!(reply = dbus_message_new_signal("/org/freedesktop/systemd1", "org.freedesktop.systemd1.Activator", "ActivationFailure"))) + goto oom; + + id = error_to_dbus(r); + text = strerror(-r); + + if (!dbus_message_set_destination(reply, DBUS_SERVICE_DBUS) || + !dbus_message_append_args(reply, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_STRING, &id, + DBUS_TYPE_STRING, &text, + DBUS_TYPE_INVALID)) + goto oom; + } + + /* On success we don't do anything, the service will be spwaned now */ + } } dbus_error_free(&error); + + if (reply) { + if (!dbus_connection_send(connection, reply, NULL)) + goto oom; + + dbus_message_unref(reply); + } + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + +oom: + if (reply) + dbus_message_unref(reply); + + dbus_error_free(&error); + + return DBUS_HANDLER_RESULT_NEED_MEMORY; } -static DBusHandlerResult system_bus_message_filter(DBusConnection *connection, DBusMessage *message, void *data) { +static DBusHandlerResult system_bus_message_filter(DBusConnection *connection, DBusMessage *message, void *data) { Manager *m = data; DBusError error; @@ -391,7 +450,7 @@ static DBusHandlerResult system_bus_message_filter(DBusConnection *connection, log_error("Warning! System D-Bus connection terminated."); bus_done_system(m); - } if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Agent", "Released")) { + } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Agent", "Released")) { const char *cgroup; if (!dbus_message_get_args(message, &error, @@ -406,7 +465,30 @@ static DBusHandlerResult system_bus_message_filter(DBusConnection *connection, return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } +static DBusHandlerResult private_bus_message_filter(DBusConnection *connection, DBusMessage *message, void *data) { + Manager *m = data; + + assert(connection); + assert(message); + assert(m); + + /* log_debug("Got D-Bus request: %s.%s() on %s", */ + /* dbus_message_get_interface(message), */ + /* dbus_message_get_member(message), */ + /* dbus_message_get_path(message)); */ + + if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) { + set_remove(m->bus_connections, connection); + set_remove(m->bus_connections_for_dispatch, connection); + dbus_connection_unref(connection); + } + + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} + unsigned bus_dispatch(Manager *m) { + DBusConnection *c; + assert(m); if (m->queued_message) { @@ -414,23 +496,18 @@ unsigned bus_dispatch(Manager *m) { * dispatch any D-Bus messages, so that we won't end * up wanting to queue another message. */ - if (!dbus_connection_send(m->api_bus, m->queued_message, NULL)) - return 0; + if (m->queued_message_connection) + if (!dbus_connection_send(m->queued_message_connection, m->queued_message, NULL)) + return 0; dbus_message_unref(m->queued_message); m->queued_message = NULL; + m->queued_message_connection = NULL; } - if (m->request_api_bus_dispatch) { - if (dbus_connection_dispatch(m->api_bus) == DBUS_DISPATCH_COMPLETE) - m->request_api_bus_dispatch = false; - - return 1; - } - - if (m->request_system_bus_dispatch) { - if (dbus_connection_dispatch(m->system_bus) == DBUS_DISPATCH_COMPLETE) - m->request_system_bus_dispatch = false; + if ((c = set_first(m->bus_connections_for_dispatch))) { + if (dbus_connection_dispatch(c) == DBUS_DISPATCH_COMPLETE) + set_move_one(m->bus_connections, m->bus_connections_for_dispatch, c); return 1; } @@ -527,6 +604,95 @@ oom: return -ENOMEM; } +static void query_name_list_pending_cb(DBusPendingCall *pending, void *userdata) { + DBusMessage *reply; + DBusError error; + Manager *m = userdata; + + assert(m); + + dbus_error_init(&error); + + assert_se(reply = dbus_pending_call_steal_reply(pending)); + + switch (dbus_message_get_type(reply)) { + + case DBUS_MESSAGE_TYPE_ERROR: + + assert_se(dbus_set_error_from_message(&error, reply)); + log_warning("ListNames() failed: %s", error.message); + break; + + case DBUS_MESSAGE_TYPE_METHOD_RETURN: { + int r; + char **l; + + if ((r = bus_parse_strv(reply, &l)) < 0) + log_warning("Failed to parse ListNames() reply: %s", strerror(-r)); + else { + char **t; + + STRV_FOREACH(t, l) + /* This is a bit hacky, we say the + * owner of the name is the name + * itself, because we don't want the + * extra traffic to figure out the + * real owner. */ + manager_dispatch_bus_name_owner_changed(m, *t, NULL, *t); + + strv_free(l); + } + + break; + } + + default: + assert_not_reached("Invalid reply message"); + } + + dbus_message_unref(reply); + dbus_error_free(&error); +} + +static int query_name_list(Manager *m) { + DBusMessage *message = NULL; + DBusPendingCall *pending = NULL; + + /* Asks for the currently installed bus names */ + + if (!(message = dbus_message_new_method_call( + DBUS_SERVICE_DBUS, + DBUS_PATH_DBUS, + DBUS_INTERFACE_DBUS, + "ListNames"))) + goto oom; + + if (!dbus_connection_send_with_reply(m->api_bus, message, &pending, -1)) + goto oom; + + if (!dbus_pending_call_set_notify(pending, query_name_list_pending_cb, m, NULL)) + goto oom; + + dbus_message_unref(message); + dbus_pending_call_unref(pending); + + /* We simple ask for the list and don't wait for it. Sooner or + * later we'll get it. */ + + return 0; + +oom: + if (pending) { + dbus_pending_call_cancel(pending); + dbus_pending_call_unref(pending); + } + + if (message) + dbus_message_unref(message); + + return -ENOMEM; +} + static int bus_setup_loop(Manager *m, DBusConnection *bus) { assert(m); assert(bus); @@ -534,13 +700,57 @@ static int bus_setup_loop(Manager *m, DBusConnection *bus) { dbus_connection_set_exit_on_disconnect(bus, FALSE); if (!dbus_connection_set_watch_functions(bus, bus_add_watch, bus_remove_watch, bus_toggle_watch, m, NULL) || - !dbus_connection_set_timeout_functions(bus, bus_add_timeout, bus_remove_timeout, bus_toggle_timeout, m, NULL)) + !dbus_connection_set_timeout_functions(bus, bus_add_timeout, bus_remove_timeout, bus_toggle_timeout, m, NULL)) { + log_error("Not enough memory"); return -ENOMEM; + } + if (set_put(m->bus_connections_for_dispatch, bus) < 0) { + log_error("Not enough memory"); + return -ENOMEM; + } + + dbus_connection_set_dispatch_status_function(bus, bus_dispatch_status, m, NULL); return 0; } -int bus_init_system(Manager *m) { +static dbus_bool_t allow_only_root(DBusConnection *connection, unsigned long uid, void *data) { + return uid == 0; +} + +static void bus_new_connection( + DBusServer *server, + DBusConnection *new_connection, + void *data) { + + Manager *m = data; + + assert(m); + + if (set_size(m->bus_connections) >= CONNECTIONS_MAX) { + log_error("Too many concurrent connections."); + return; + } + + dbus_connection_set_unix_user_function(new_connection, allow_only_root, NULL, NULL); + + if (bus_setup_loop(m, new_connection) < 0) + return; + + if (!dbus_connection_register_object_path(new_connection, "/org/freedesktop/systemd1", &bus_manager_vtable, m) || + !dbus_connection_register_fallback(new_connection, "/org/freedesktop/systemd1/unit", &bus_unit_vtable, m) || + !dbus_connection_register_fallback(new_connection, "/org/freedesktop/systemd1/job", &bus_job_vtable, m) || + !dbus_connection_add_filter(new_connection, private_bus_message_filter, m, NULL)) { + log_error("Not enough memory."); + return; + } + + log_debug("Accepted connection on private bus."); + + dbus_connection_ref(new_connection); +} + +static int bus_init_system(Manager *m) { DBusError error; char *id; int r; @@ -552,40 +762,36 @@ int bus_init_system(Manager *m) { if (m->system_bus) return 0; - if (m->running_as != MANAGER_SESSION && m->api_bus) + if (m->running_as == MANAGER_SYSTEM && m->api_bus) m->system_bus = m->api_bus; else { if (!(m->system_bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error))) { log_debug("Failed to get system D-Bus connection, retrying later: %s", error.message); - dbus_error_free(&error); - return 0; + r = 0; + goto fail; } - dbus_connection_set_dispatch_status_function(m->system_bus, system_bus_dispatch_status, m, NULL); - m->request_system_bus_dispatch = true; - - if ((r = bus_setup_loop(m, m->system_bus)) < 0) { - bus_done_system(m); - return r; - } + if ((r = bus_setup_loop(m, m->system_bus)) < 0) + goto fail; } if (!dbus_connection_add_filter(m->system_bus, system_bus_message_filter, m, NULL)) { - bus_done_system(m); - return -ENOMEM; + log_error("Not enough memory"); + r = -EIO; + goto fail; } dbus_bus_add_match(m->system_bus, "type='signal'," "interface='org.freedesktop.systemd1.Agent'," + "member='Released'," "path='/org/freedesktop/systemd1/agent'", &error); if (dbus_error_is_set(&error)) { log_error("Failed to register match: %s", error.message); - dbus_error_free(&error); - bus_done_system(m); - return -ENOMEM; + r = -EIO; + goto fail; } log_debug("Successfully connected to system D-Bus bus %s as %s", @@ -594,9 +800,15 @@ int bus_init_system(Manager *m) { dbus_free(id); return 0; + +fail: + bus_done_system(m); + dbus_error_free(&error); + + return r; } -int bus_init_api(Manager *m) { +static int bus_init_api(Manager *m) { DBusError error; char *id; int r; @@ -608,93 +820,204 @@ int bus_init_api(Manager *m) { if (m->api_bus) return 0; - if (m->name_data_slot < 0) - if (!dbus_pending_call_allocate_data_slot(&m->name_data_slot)) - return -ENOMEM; - - if (m->running_as != MANAGER_SESSION && m->system_bus) + if (m->running_as == MANAGER_SYSTEM && m->system_bus) m->api_bus = m->system_bus; else { if (!(m->api_bus = dbus_bus_get_private(m->running_as == MANAGER_SESSION ? DBUS_BUS_SESSION : DBUS_BUS_SYSTEM, &error))) { log_debug("Failed to get API D-Bus connection, retrying later: %s", error.message); - dbus_error_free(&error); - return 0; + r = 0; + goto fail; } - dbus_connection_set_dispatch_status_function(m->api_bus, api_bus_dispatch_status, m, NULL); - m->request_api_bus_dispatch = true; - - if ((r = bus_setup_loop(m, m->api_bus)) < 0) { - bus_done_api(m); - return r; - } + if ((r = bus_setup_loop(m, m->api_bus)) < 0) + goto fail; } if (!dbus_connection_register_object_path(m->api_bus, "/org/freedesktop/systemd1", &bus_manager_vtable, m) || !dbus_connection_register_fallback(m->api_bus, "/org/freedesktop/systemd1/unit", &bus_unit_vtable, m) || !dbus_connection_register_fallback(m->api_bus, "/org/freedesktop/systemd1/job", &bus_job_vtable, m) || !dbus_connection_add_filter(m->api_bus, api_bus_message_filter, m, NULL)) { - bus_done_api(m); - return -ENOMEM; + log_error("Not enough memory"); + r = -ENOMEM; + goto fail; } + /* Get NameOwnerChange messages */ dbus_bus_add_match(m->api_bus, "type='signal'," "sender='"DBUS_SERVICE_DBUS"'," "interface='"DBUS_INTERFACE_DBUS"'," + "member='NameOwnerChanged'," "path='"DBUS_PATH_DBUS"'", &error); if (dbus_error_is_set(&error)) { log_error("Failed to register match: %s", error.message); - dbus_error_free(&error); - bus_done_api(m); - return -ENOMEM; + r = -EIO; + goto fail; } - if ((r = request_name(m)) < 0) { - bus_done_api(m); - return r; + /* Get activation requests */ + dbus_bus_add_match(m->api_bus, + "type='signal'," + "sender='"DBUS_SERVICE_DBUS"'," + "interface='org.freedesktop.systemd1.Activator'," + "member='ActivationRequest'," + "path='"DBUS_PATH_DBUS"'", + &error); + + if (dbus_error_is_set(&error)) { + log_error("Failed to register match: %s", error.message); + r = -EIO; + goto fail; } + if ((r = request_name(m)) < 0) + goto fail; + + if ((r = query_name_list(m)) < 0) + goto fail; + log_debug("Successfully connected to API D-Bus bus %s as %s", strnull((id = dbus_connection_get_server_id(m->api_bus))), strnull(dbus_bus_get_unique_name(m->api_bus))); dbus_free(id); - if (!m->subscribed) - if (!(m->subscribed = set_new(string_hash_func, string_compare_func))) + return 0; + +fail: + bus_done_api(m); + dbus_error_free(&error); + + return r; +} + +static int bus_init_private(Manager *m) { + DBusError error; + int r; + const char *const external_only[] = { + "EXTERNAL", + NULL + }; + + assert(m); + + dbus_error_init(&error); + + if (m->private_bus) + return 0; + + /* We want the private bus only when running as init */ + if (m->running_as != MANAGER_SYSTEM) + return 0; + + if (!(m->private_bus = dbus_server_listen("unix:abstract=/org/freedesktop/systemd1/private", &error))) { + log_error("Failed to create private D-Bus server: %s", error.message); + r = -EIO; + goto fail; + } + + if (!dbus_server_set_auth_mechanisms(m->private_bus, (const char**) external_only) || + !dbus_server_set_watch_functions(m->private_bus, bus_add_watch, bus_remove_watch, bus_toggle_watch, m, NULL) || + !dbus_server_set_timeout_functions(m->private_bus, bus_add_timeout, bus_remove_timeout, bus_toggle_timeout, m, NULL)) { + log_error("Not enough memory"); + r = -ENOMEM; + goto fail; + } + + dbus_server_set_new_connection_function(m->private_bus, bus_new_connection, m, NULL); + + log_debug("Successfully create private D-Bus server."); + + return 0; + +fail: + bus_done_private(m); + dbus_error_free(&error); + + return r; +} + +int bus_init(Manager *m) { + int r; + + if (set_ensure_allocated(&m->bus_connections, trivial_hash_func, trivial_compare_func) < 0 || + set_ensure_allocated(&m->bus_connections_for_dispatch, trivial_hash_func, trivial_compare_func) < 0) { + log_error("Not enough memory"); + return -ENOMEM; + } + + if (m->name_data_slot < 0) + if (!dbus_pending_call_allocate_data_slot(&m->name_data_slot)) { + log_error("Not enough memory"); return -ENOMEM; + } + + if (m->subscribed_data_slot < 0) + if (!dbus_pending_call_allocate_data_slot(&m->subscribed_data_slot)) { + log_error("Not enough memory"); + return -ENOMEM; + } + + if ((r = bus_init_system(m)) < 0 || + (r = bus_init_api(m)) < 0 || + (r = bus_init_private(m)) < 0) + return r; return 0; } -void bus_done_api(Manager *m) { +static void shutdown_connection(Manager *m, DBusConnection *c) { + Set *s; + Job *j; + Iterator i; + + HASHMAP_FOREACH(j, m->jobs, i) + if (j->bus == c) { + free(j->bus_client); + j->bus_client = NULL; + + j->bus = NULL; + } + + set_remove(m->bus_connections, c); + set_remove(m->bus_connections_for_dispatch, c); + + if ((s = BUS_CONNECTION_SUBSCRIBED(m, c))) { + char *t; + + while ((t = set_steal_first(s))) + free(t); + + set_free(s); + } + + if (m->queued_message_connection == c) { + m->queued_message_connection = NULL; + + if (m->queued_message) { + dbus_message_unref(m->queued_message); + m->queued_message = NULL; + } + } + + dbus_connection_set_dispatch_status_function(c, NULL, NULL, NULL); + dbus_connection_flush(c); + dbus_connection_close(c); + dbus_connection_unref(c); +} + +static void bus_done_api(Manager *m) { assert(m); if (m->api_bus) { if (m->system_bus == m->api_bus) m->system_bus = NULL; - dbus_connection_set_dispatch_status_function(m->api_bus, NULL, NULL, NULL); - dbus_connection_flush(m->api_bus); - dbus_connection_close(m->api_bus); - dbus_connection_unref(m->api_bus); + shutdown_connection(m, m->api_bus); m->api_bus = NULL; } - if (m->subscribed) { - char *c; - - while ((c = set_steal_first(m->subscribed))) - free(c); - - set_free(m->subscribed); - m->subscribed = NULL; - } - - if (m->name_data_slot >= 0) - dbus_pending_call_free_data_slot(&m->name_data_slot); if (m->queued_message) { dbus_message_unref(m->queued_message); @@ -702,21 +1025,50 @@ void bus_done_api(Manager *m) { } } -void bus_done_system(Manager *m) { +static void bus_done_system(Manager *m) { assert(m); if (m->system_bus == m->api_bus) bus_done_api(m); if (m->system_bus) { - dbus_connection_set_dispatch_status_function(m->system_bus, NULL, NULL, NULL); - dbus_connection_flush(m->system_bus); - dbus_connection_close(m->system_bus); - dbus_connection_unref(m->system_bus); + shutdown_connection(m, m->system_bus); m->system_bus = NULL; } } +static void bus_done_private(Manager *m) { + + if (m->private_bus) { + dbus_server_disconnect(m->private_bus); + dbus_server_unref(m->private_bus); + m->private_bus = NULL; + } +} + +void bus_done(Manager *m) { + DBusConnection *c; + + bus_done_api(m); + bus_done_system(m); + bus_done_private(m); + + while ((c = set_steal_first(m->bus_connections))) + shutdown_connection(m, c); + + while ((c = set_steal_first(m->bus_connections_for_dispatch))) + shutdown_connection(m, c); + + set_free(m->bus_connections); + set_free(m->bus_connections_for_dispatch); + + if (m->name_data_slot >= 0) + dbus_pending_call_free_data_slot(&m->name_data_slot); + + if (m->subscribed_data_slot >= 0) + dbus_pending_call_free_data_slot(&m->subscribed_data_slot); +} + static void query_pid_pending_cb(DBusPendingCall *pending, void *userdata) { Manager *m = userdata; DBusMessage *reply; @@ -725,7 +1077,7 @@ static void query_pid_pending_cb(DBusPendingCall *pending, void *userdata) { dbus_error_init(&error); - assert_se(name = dbus_pending_call_get_data(pending, m->name_data_slot)); + assert_se(name = BUS_PENDING_CALL_NAME(m, pending)); assert_se(reply = dbus_pending_call_steal_reply(pending)); switch (dbus_message_get_type(reply)) { @@ -813,7 +1165,7 @@ oom: return -ENOMEM; } -DBusHandlerResult bus_default_message_handler(Manager *m, DBusMessage *message, const char*introspection, const BusProperty *properties) { +DBusHandlerResult bus_default_message_handler(Manager *m, DBusConnection *c, DBusMessage *message, const char*introspection, const BusProperty *properties) { DBusError error; DBusMessage *reply = NULL; int r; @@ -841,7 +1193,7 @@ DBusHandlerResult bus_default_message_handler(Manager *m, DBusMessage *message, DBUS_TYPE_STRING, &interface, DBUS_TYPE_STRING, &property, DBUS_TYPE_INVALID)) - return bus_send_error_reply(m, message, &error, -EINVAL); + return bus_send_error_reply(m, c, message, &error, -EINVAL); for (p = properties; p->property; p++) if (streq(p->interface, interface) && streq(p->property, property)) @@ -864,7 +1216,7 @@ DBusHandlerResult bus_default_message_handler(Manager *m, DBusMessage *message, goto oom; dbus_message_unref(reply); - return bus_send_error_reply(m, message, NULL, r); + return bus_send_error_reply(m, c, message, NULL, r); } if (!dbus_message_iter_close_container(&iter, &sub)) @@ -874,14 +1226,13 @@ DBusHandlerResult bus_default_message_handler(Manager *m, DBusMessage *message, const char *interface; const BusProperty *p; DBusMessageIter iter, sub, sub2, sub3; - bool any = false; if (!dbus_message_get_args( message, &error, DBUS_TYPE_STRING, &interface, DBUS_TYPE_INVALID)) - return bus_send_error_reply(m, message, &error, -EINVAL); + return bus_send_error_reply(m, c, message, &error, -EINVAL); if (!(reply = dbus_message_new_method_return(message))) goto oom; @@ -892,7 +1243,7 @@ DBusHandlerResult bus_default_message_handler(Manager *m, DBusMessage *message, goto oom; for (p = properties; p->property; p++) { - if (!streq(p->interface, interface)) + if (interface[0] && !streq(p->interface, interface)) continue; if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY, NULL, &sub2) || @@ -906,14 +1257,12 @@ DBusHandlerResult bus_default_message_handler(Manager *m, DBusMessage *message, goto oom; dbus_message_unref(reply); - return bus_send_error_reply(m, message, NULL, r); + return bus_send_error_reply(m, c, message, NULL, r); } if (!dbus_message_iter_close_container(&sub2, &sub3) || !dbus_message_iter_close_container(&sub, &sub2)) goto oom; - - any = true; } if (!dbus_message_iter_close_container(&iter, &sub)) @@ -921,7 +1270,7 @@ DBusHandlerResult bus_default_message_handler(Manager *m, DBusMessage *message, } if (reply) { - if (!dbus_connection_send(m->api_bus, reply, NULL)) + if (!dbus_connection_send(c, reply, NULL)) goto oom; dbus_message_unref(reply); @@ -977,7 +1326,7 @@ static const char *error_to_dbus(int error) { return DBUS_ERROR_FAILED; } -DBusHandlerResult bus_send_error_reply(Manager *m, DBusMessage *message, DBusError *bus_error, int error) { +DBusHandlerResult bus_send_error_reply(Manager *m, DBusConnection *c, DBusMessage *message, DBusError *bus_error, int error) { DBusMessage *reply = NULL; const char *name, *text; @@ -992,7 +1341,7 @@ DBusHandlerResult bus_send_error_reply(Manager *m, DBusMessage *message, DBusErr if (!(reply = dbus_message_new_error(message, name, text))) goto oom; - if (!dbus_connection_send(m->api_bus, reply, NULL)) + if (!dbus_connection_send(c, reply, NULL)) goto oom; dbus_message_unref(reply); @@ -1012,6 +1361,25 @@ oom: return DBUS_HANDLER_RESULT_NEED_MEMORY; } +int bus_broadcast(Manager *m, DBusMessage *message) { + bool oom = false; + Iterator i; + DBusConnection *c; + + assert(m); + assert(message); + + SET_FOREACH(c, m->bus_connections_for_dispatch, i) + if (c != m->system_bus || m->running_as == MANAGER_SYSTEM) + oom = !dbus_connection_send(c, message, NULL); + + SET_FOREACH(c, m->bus_connections, i) + if (c != m->system_bus || m->running_as == MANAGER_SYSTEM) + oom = !dbus_connection_send(c, message, NULL); + + return oom ? -ENOMEM : 0; +} + int bus_property_append_string(Manager *m, DBusMessageIter *i, const char *property, void *data) { const char *t = data; @@ -1114,6 +1482,38 @@ int bus_property_append_int32(Manager *m, DBusMessageIter *i, const char *proper return 0; } +int bus_property_append_size(Manager *m, DBusMessageIter *i, const char *property, void *data) { + uint64_t u; + + assert(m); + assert(i); + assert(property); + assert(data); + + u = (uint64_t) *(size_t*) data; + + if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u)) + return -ENOMEM; + + return 0; +} + +int bus_property_append_ul(Manager *m, DBusMessageIter *i, const char *property, void *data) { + uint64_t u; + + assert(m); + assert(i); + assert(property); + assert(data); + + u = (uint64_t) *(unsigned long*) data; + + if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u)) + return -ENOMEM; + + return 0; +} + int bus_parse_strv(DBusMessage *m, char ***_l) { DBusMessageIter iter, sub; unsigned n = 0, i = 0; @@ -1162,3 +1562,27 @@ int bus_parse_strv(DBusMessage *m, char ***_l) { return 0; } + +bool bus_has_subscriber(Manager *m) { + Iterator i; + DBusConnection *c; + + assert(m); + + SET_FOREACH(c, m->bus_connections_for_dispatch, i) + if (bus_connection_has_subscriber(m, c)) + return true; + + SET_FOREACH(c, m->bus_connections, i) + if (bus_connection_has_subscriber(m, c)) + return true; + + return false; +} + +bool bus_connection_has_subscriber(Manager *m, DBusConnection *c) { + assert(m); + assert(c); + + return !set_isempty(BUS_CONNECTION_SUBSCRIBED(m, c)); +}