-/*-*- Mode: C; c-basic-offset: 8 -*-*/
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
/***
This file is part of systemd.
#include "dbus-swap.h"
#include "dbus-timer.h"
#include "dbus-path.h"
+#include "bus-errors.h"
+#include "special.h"
+#include "dbus-common.h"
#define CONNECTIONS_MAX 52
+/* Well-known address (http://dbus.freedesktop.org/doc/dbus-specification.html#message-bus-types) */
+#define DBUS_SYSTEM_BUS_DEFAULT_ADDRESS "unix:path=/var/run/dbus/system_bus_socket"
+/* Only used as a fallback */
+#define DBUS_SESSION_BUS_DEFAULT_ADDRESS "autolaunch:"
+
static const char bus_properties_interface[] = BUS_PROPERTIES_INTERFACE;
static const char bus_introspectable_interface[] = BUS_INTROSPECTABLE_INTERFACE;
NULL
};
-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 shutdown_connection(Manager *m, DBusConnection *c);
static void bus_dispatch_status(DBusConnection *bus, DBusDispatchStatus status, void *data) {
Manager *m = data;
set_move_one(m->bus_connections_for_dispatch, m->bus_connections, bus);
}
-static uint32_t bus_flags_to_events(DBusWatch *bus_watch) {
- unsigned flags;
- uint32_t events = 0;
-
- assert(bus_watch);
-
- /* no watch flags for disabled watches */
- if (!dbus_watch_get_enabled(bus_watch))
- return 0;
-
- flags = dbus_watch_get_flags(bus_watch);
-
- if (flags & DBUS_WATCH_READABLE)
- events |= EPOLLIN;
- if (flags & DBUS_WATCH_WRITABLE)
- events |= EPOLLOUT;
-
- return events | EPOLLHUP | EPOLLERR;
-}
-
-static unsigned events_to_bus_flags(uint32_t events) {
- unsigned flags = 0;
-
- if (events & EPOLLIN)
- flags |= DBUS_WATCH_READABLE;
- if (events & EPOLLOUT)
- flags |= DBUS_WATCH_WRITABLE;
- if (events & EPOLLHUP)
- flags |= DBUS_WATCH_HANGUP;
- if (events & EPOLLERR)
- flags |= DBUS_WATCH_ERROR;
-
- return flags;
-}
-
void bus_watch_event(Manager *m, Watch *w, int events) {
assert(m);
assert(w);
if (!dbus_watch_get_enabled(w->data.bus_watch))
return;
- dbus_watch_handle(w->data.bus_watch, events_to_bus_flags(events));
+ dbus_watch_handle(w->data.bus_watch, bus_events_to_flags(events));
}
static dbus_bool_t bus_add_watch(DBusWatch *bus_watch, void *data) {
}
if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, w->fd, &ev) < 0) {
- free(w);
close_nointr_nofail(w->fd);
+ free(w);
return FALSE;
}
assert(bus_watch);
assert(m);
- if (!(w = dbus_watch_get_data(bus_watch)))
+ w = dbus_watch_get_data(bus_watch);
+ if (!w)
return;
assert(w->type == WATCH_DBUS_WATCH);
assert(bus_watch);
assert(m);
- assert_se(w = dbus_watch_get_data(bus_watch));
+ w = dbus_watch_get_data(bus_watch);
+ if (!w)
+ return;
+
assert(w->type == WATCH_DBUS_WATCH);
zero(ev);
if (dbus_timeout_get_enabled(w->data.bus_timeout)) {
timespec_store(&its.it_value, dbus_timeout_get_interval(w->data.bus_timeout) * USEC_PER_MSEC);
- its.it_interval = its.it_interval;
+ its.it_interval = its.it_value;
}
if (timerfd_settime(w->fd, 0, &its, NULL) < 0)
if (!(w = new0(Watch, 1)))
return FALSE;
- if (!(w->fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0)
+ if ((w->fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0)
goto fail;
w->type = WATCH_DBUS_TIMEOUT;
assert(timeout);
assert(m);
- if (!(w = dbus_timeout_get_data(timeout)))
+ w = dbus_timeout_get_data(timeout);
+ if (!w)
return;
assert(w->type == WATCH_DBUS_TIMEOUT);
+
assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
close_nointr_nofail(w->fd);
free(w);
assert(timeout);
assert(m);
- assert_se(w = dbus_timeout_get_data(timeout));
+ w = dbus_timeout_get_data(timeout);
+ if (!w)
+ return;
+
assert(w->type == WATCH_DBUS_TIMEOUT);
if ((r = bus_timeout_arm(m, w)) < 0)
dbus_error_init(&error);
- /* 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_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL ||
+ dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_SIGNAL)
+ 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")) {
- log_error("Warning! API D-Bus connection terminated.");
+ log_debug("API D-Bus connection terminated.");
bus_done_api(m);
} else if (dbus_message_is_signal(message, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) {
DBUS_TYPE_STRING, &old_owner,
DBUS_TYPE_STRING, &new_owner,
DBUS_TYPE_INVALID))
- log_error("Failed to parse NameOwnerChanged message: %s", error.message);
+ log_error("Failed to parse NameOwnerChanged message: %s", bus_error_message(&error));
else {
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 (!dbus_message_get_args(message, &error,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID))
- log_error("Failed to parse ActivationRequest message: %s", error.message);
+ log_error("Failed to parse ActivationRequest message: %s", bus_error_message(&error));
else {
int r;
Unit *u;
log_debug("Got D-Bus activation request for %s", name);
- r = manager_load_unit(m, name, NULL, &u);
+ if (manager_unit_pending_inactive(m, SPECIAL_DBUS_SERVICE) ||
+ manager_unit_pending_inactive(m, SPECIAL_DBUS_SOCKET)) {
+ r = -EADDRNOTAVAIL;
+ dbus_set_error(&error, BUS_ERROR_SHUTTING_DOWN, "Refusing activation, D-Bus is shutting down.");
+ } else {
+ r = manager_load_unit(m, name, NULL, &error, &u);
- if (r >= 0 && u->meta.only_by_dependency)
- r = -EPERM;
+ if (r >= 0 && u->refuse_manual_start)
+ r = -EPERM;
- if (r >= 0)
- r = manager_add_job(m, JOB_START, u, JOB_REPLACE, true, NULL);
+ if (r >= 0)
+ r = manager_add_job(m, JOB_START, u, JOB_REPLACE, true, &error, NULL);
+ }
if (r < 0) {
const char *id, *text;
- log_warning("D-Bus activation failed for %s: %s", name, strerror(-r));
+ log_debug("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);
+ id = error.name ? error.name : bus_errno_to_dbus(r);
+ text = bus_error(&error, r);
if (!dbus_message_set_destination(reply, DBUS_SERVICE_DBUS) ||
!dbus_message_append_args(reply,
goto oom;
}
- /* On success we don't do anything, the service will be spwaned now */
+ /* On success we don't do anything, the service will be spawned now */
}
}
dbus_error_init(&error);
- /* 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 (m->api_bus != m->system_bus &&
+ (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL ||
+ dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_SIGNAL))
+ log_debug("Got D-Bus request on system bus: %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")) {
- log_error("Warning! System D-Bus connection terminated.");
+ log_debug("System D-Bus connection terminated.");
bus_done_system(m);
- } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Agent", "Released")) {
+ } else if (m->running_as != MANAGER_SYSTEM &&
+ dbus_message_is_signal(message, "org.freedesktop.systemd1.Agent", "Released")) {
+
const char *cgroup;
if (!dbus_message_get_args(message, &error,
DBUS_TYPE_STRING, &cgroup,
DBUS_TYPE_INVALID))
- log_error("Failed to parse Released message: %s", error.message);
+ log_error("Failed to parse Released message: %s", bus_error_message(&error));
else
cgroup_notify_empty(m, cgroup);
}
static DBusHandlerResult private_bus_message_filter(DBusConnection *connection, DBusMessage *message, void *data) {
Manager *m = data;
+ DBusError error;
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)); */
+ dbus_error_init(&error);
- 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);
+ if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL ||
+ dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_SIGNAL)
+ 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"))
+ shutdown_connection(m, connection);
+ else if (m->running_as == MANAGER_SYSTEM &&
+ dbus_message_is_signal(message, "org.freedesktop.systemd1.Agent", "Released")) {
+
+ const char *cgroup;
+
+ if (!dbus_message_get_args(message, &error,
+ DBUS_TYPE_STRING, &cgroup,
+ DBUS_TYPE_INVALID))
+ log_error("Failed to parse Released message: %s", bus_error_message(&error));
+ else
+ cgroup_notify_empty(m, cgroup);
+
+ /* Forward the message to the system bus, so that user
+ * instances are notified as well */
+
+ if (m->system_bus)
+ dbus_connection_send(m->system_bus, message, NULL);
}
+ dbus_error_free(&error);
+
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
* dispatch any D-Bus messages, so that we won't end
* up wanting to queue another message. */
- if (m->api_bus)
- if (!dbus_connection_send(m->api_bus, m->queued_message, NULL))
+ 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 ((c = set_first(m->bus_connections_for_dispatch))) {
case DBUS_MESSAGE_TYPE_ERROR:
assert_se(dbus_set_error_from_message(&error, reply));
- log_warning("RequestName() failed: %s", error.message);
+ log_warning("RequestName() failed: %s", bus_error_message(&error));
break;
case DBUS_MESSAGE_TYPE_METHOD_RETURN: {
&error,
DBUS_TYPE_UINT32, &r,
DBUS_TYPE_INVALID)) {
- log_error("Failed to parse RequestName() reply: %s", error.message);
+ log_error("Failed to parse RequestName() reply: %s", bus_error_message(&error));
break;
}
static int request_name(Manager *m) {
const char *name = "org.freedesktop.systemd1";
- uint32_t flags = 0;
+ /* Allow replacing of our name, to ease implementation of
+ * reexecution, where we keep the old connection open until
+ * after the new connection is set up and the name installed
+ * to allow clients to synchronously wait for reexecution to
+ * finish */
+ uint32_t flags = DBUS_NAME_FLAG_ALLOW_REPLACEMENT|DBUS_NAME_FLAG_REPLACE_EXISTING;
DBusMessage *message = NULL;
DBusPendingCall *pending = NULL;
case DBUS_MESSAGE_TYPE_ERROR:
assert_se(dbus_set_error_from_message(&error, reply));
- log_warning("ListNames() failed: %s", error.message);
+ log_warning("ListNames() failed: %s", bus_error_message(&error));
break;
case DBUS_MESSAGE_TYPE_METHOD_RETURN: {
return 0;
}
-static dbus_bool_t allow_only_root(DBusConnection *connection, unsigned long uid, void *data) {
- return uid == 0;
+static dbus_bool_t allow_only_same_user(DBusConnection *connection, unsigned long uid, void *data) {
+ return uid == 0 || uid == geteuid();
}
static void bus_new_connection(
return;
}
- dbus_connection_set_unix_user_function(new_connection, allow_only_root, NULL, NULL);
+ dbus_connection_set_unix_user_function(new_connection, allow_only_same_user, NULL, NULL);
if (bus_setup_loop(m, new_connection) < 0)
return;
dbus_connection_ref(new_connection);
}
-static int bus_init_system(Manager *m) {
- DBusError error;
+static int init_registered_system_bus(Manager *m) {
char *id;
- int r;
-
- assert(m);
-
- dbus_error_init(&error);
-
- if (m->system_bus)
- return 0;
-
- 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);
- r = 0;
- goto fail;
- }
-
- 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)) {
log_error("Not enough memory");
- r = -EIO;
- goto fail;
+ return -ENOMEM;
}
- dbus_bus_add_match(m->system_bus,
- "type='signal',"
- "interface='org.freedesktop.systemd1.Agent',"
- "member='Released',"
- "path='/org/freedesktop/systemd1/agent'",
- &error);
+ if (m->running_as != MANAGER_SYSTEM) {
+ DBusError error;
- if (dbus_error_is_set(&error)) {
- log_error("Failed to register match: %s", error.message);
- r = -EIO;
- goto fail;
+ dbus_error_init(&error);
+
+ 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", bus_error_message(&error));
+ dbus_error_free(&error);
+ return -1;
+ }
}
log_debug("Successfully connected to system D-Bus bus %s as %s",
- strnull((id = dbus_connection_get_server_id(m->system_bus))),
- strnull(dbus_bus_get_unique_name(m->system_bus)));
+ strnull((id = dbus_connection_get_server_id(m->system_bus))),
+ strnull(dbus_bus_get_unique_name(m->system_bus)));
dbus_free(id);
return 0;
-
-fail:
- bus_done_system(m);
- dbus_error_free(&error);
-
- return r;
}
-static int bus_init_api(Manager *m) {
- DBusError error;
- char *id;
+static int init_registered_api_bus(Manager *m) {
int r;
- assert(m);
-
- dbus_error_init(&error);
-
- if (m->api_bus)
- return 0;
-
- 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);
- r = 0;
- goto fail;
- }
-
- 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)) {
log_error("Not enough memory");
- r = -ENOMEM;
- goto fail;
+ return -ENOMEM;
}
/* Get NameOwnerChange messages */
"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);
- r = -EIO;
- goto fail;
- }
+ NULL);
/* Get activation requests */
dbus_bus_add_match(m->api_bus,
"interface='org.freedesktop.systemd1.Activator',"
"member='ActivationRequest',"
"path='"DBUS_PATH_DBUS"'",
- &error);
+ NULL);
- if (dbus_error_is_set(&error)) {
- log_error("Failed to register match: %s", error.message);
- r = -EIO;
+ r = request_name(m);
+ if (r < 0)
+ return r;
+
+ r = query_name_list(m);
+ if (r < 0)
+ return r;
+
+ if (m->running_as == MANAGER_USER) {
+ char *id;
+ 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);
+ } else
+ log_debug("Successfully initialized API on the system bus");
+
+ return 0;
+}
+
+static void bus_register_cb(DBusPendingCall *pending, void *userdata) {
+ Manager *m = userdata;
+ DBusConnection **conn;
+ DBusMessage *reply;
+ DBusError error;
+ const char *name;
+ int r = 0;
+
+ dbus_error_init(&error);
+
+ conn = dbus_pending_call_get_data(pending, m->conn_data_slot);
+ assert(conn == &m->system_bus || conn == &m->api_bus);
+
+ 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("Failed to register to bus: %s", bus_error_message(&error));
+ r = -1;
+ break;
+ case DBUS_MESSAGE_TYPE_METHOD_RETURN:
+ if (!dbus_message_get_args(reply, &error,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_INVALID)) {
+ log_error("Failed to parse Hello reply: %s", bus_error_message(&error));
+ r = -1;
+ break;
+ }
+
+ log_debug("Received name %s in reply to Hello", name);
+ if (!dbus_bus_set_unique_name(*conn, name)) {
+ log_error("Failed to set unique name");
+ r = -1;
+ break;
+ }
+
+ if (conn == &m->system_bus) {
+ r = init_registered_system_bus(m);
+ if (r == 0 && m->running_as == MANAGER_SYSTEM)
+ r = init_registered_api_bus(m);
+ } else
+ r = init_registered_api_bus(m);
+
+ break;
+ default:
+ assert_not_reached("Invalid reply message");
+ }
+
+ dbus_message_unref(reply);
+ dbus_error_free(&error);
+
+ if (r < 0) {
+ if (conn == &m->system_bus) {
+ log_debug("Failed setting up the system bus");
+ bus_done_system(m);
+ } else {
+ log_debug("Failed setting up the API bus");
+ bus_done_api(m);
+ }
+ }
+}
+
+static int manager_bus_async_register(Manager *m, DBusConnection **conn) {
+ DBusMessage *message = NULL;
+ DBusPendingCall *pending = NULL;
+
+ message = dbus_message_new_method_call(DBUS_SERVICE_DBUS,
+ DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
+ "Hello");
+ if (!message)
+ goto oom;
+
+ if (!dbus_connection_send_with_reply(*conn, message, &pending, -1))
+ goto oom;
+
+ if (!dbus_pending_call_set_data(pending, m->conn_data_slot, conn, NULL))
+ goto oom;
+
+ if (!dbus_pending_call_set_notify(pending, bus_register_cb, m, NULL))
+ goto oom;
+
+ dbus_message_unref(message);
+ dbus_pending_call_unref(pending);
+
+ return 0;
+oom:
+ if (pending) {
+ dbus_pending_call_cancel(pending);
+ dbus_pending_call_unref(pending);
+ }
+
+ if (message)
+ dbus_message_unref(message);
+
+ return -ENOMEM;
+}
+
+static DBusConnection* manager_bus_connect_private(Manager *m, DBusBusType type) {
+ const char *address;
+ DBusConnection *connection;
+ DBusError error;
+
+ switch (type) {
+ case DBUS_BUS_SYSTEM:
+ address = getenv("DBUS_SYSTEM_BUS_ADDRESS");
+ if (!address || !address[0])
+ address = DBUS_SYSTEM_BUS_DEFAULT_ADDRESS;
+ break;
+ case DBUS_BUS_SESSION:
+ address = getenv("DBUS_SESSION_BUS_ADDRESS");
+ if (!address || !address[0])
+ address = DBUS_SESSION_BUS_DEFAULT_ADDRESS;
+ break;
+ default:
+ assert_not_reached("Invalid bus type");
+ }
+
+ dbus_error_init(&error);
+
+ connection = dbus_connection_open_private(address, &error);
+ if (!connection) {
+ log_warning("Failed to open private bus connection: %s", bus_error_message(&error));
goto fail;
}
- if ((r = request_name(m)) < 0)
+ return connection;
+fail:
+ if (connection)
+ dbus_connection_close(connection);
+ dbus_error_free(&error);
+ return NULL;
+}
+
+static int bus_init_system(Manager *m) {
+ int r;
+
+ if (m->system_bus)
+ return 0;
+
+ m->system_bus = manager_bus_connect_private(m, DBUS_BUS_SYSTEM);
+ if (!m->system_bus) {
+ log_debug("Failed to connect to system D-Bus, retrying later");
+ r = 0;
goto fail;
+ }
- if ((r = query_name_list(m)) < 0)
+ r = bus_setup_loop(m, m->system_bus);
+ if (r < 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);
+ r = manager_bus_async_register(m, &m->system_bus);
+ if (r < 0)
+ goto fail;
return 0;
+fail:
+ bus_done_system(m);
+
+ return r;
+}
+
+static int bus_init_api(Manager *m) {
+ int r;
+
+ if (m->api_bus)
+ return 0;
+
+ if (m->running_as == MANAGER_SYSTEM) {
+ m->api_bus = m->system_bus;
+ /* In this mode there is no distinct connection to the API bus,
+ * the API is published on the system bus.
+ * bus_register_cb() is aware of that and will init the API
+ * when the system bus gets registered.
+ * No need to setup anything here. */
+ return 0;
+ }
+
+ m->api_bus = manager_bus_connect_private(m, DBUS_BUS_SESSION);
+ if (!m->api_bus) {
+ log_debug("Failed to connect to API D-Bus, retrying later");
+ r = 0;
+ goto fail;
+ }
+
+ r = bus_setup_loop(m, m->api_bus);
+ if (r < 0)
+ goto fail;
+
+ r = manager_bus_async_register(m, &m->api_bus);
+ if (r < 0)
+ goto fail;
+ return 0;
fail:
bus_done_api(m);
- dbus_error_free(&error);
return r;
}
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->running_as == MANAGER_SYSTEM) {
+
+ /* We want the private bus only when running as init */
+ if (getpid() != 1)
+ return 0;
+
+ unlink("/run/systemd/private");
+ m->private_bus = dbus_server_listen("unix:path=/run/systemd/private", &error);
+ } else {
+ const char *e;
+ char *p;
- 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);
+ e = getenv("XDG_RUNTIME_DIR");
+ if (!e)
+ return 0;
+
+ if (asprintf(&p, "unix:path=%s/systemd/private", e) < 0) {
+ log_error("Not enough memory");
+ r = -ENOMEM;
+ goto fail;
+ }
+
+ mkdir_parents(p+10, 0755);
+ unlink(p+10);
+ m->private_bus = dbus_server_listen(p, &error);
+ free(p);
+ }
+
+ if (!m->private_bus) {
+ log_error("Failed to create private D-Bus server: %s", bus_error_message(&error));
r = -EIO;
goto fail;
}
dbus_server_set_new_connection_function(m->private_bus, bus_new_connection, m, NULL);
- log_debug("Successfully create private D-Bus server.");
+ log_debug("Successfully created private D-Bus server.");
return 0;
return r;
}
-int bus_init(Manager *m) {
+int bus_init(Manager *m, bool try_bus_connect) {
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;
- }
+ set_ensure_allocated(&m->bus_connections_for_dispatch, trivial_hash_func, trivial_compare_func) < 0)
+ goto oom;
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 (!dbus_pending_call_allocate_data_slot(&m->name_data_slot))
+ goto oom;
+
+ if (m->conn_data_slot < 0)
+ if (!dbus_pending_call_allocate_data_slot(&m->conn_data_slot))
+ goto oom;
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 (!dbus_connection_allocate_data_slot(&m->subscribed_data_slot))
+ goto oom;
+
+ if (try_bus_connect) {
+ if ((r = bus_init_system(m)) < 0 ||
+ (r = bus_init_api(m)) < 0)
+ return r;
+ }
- if ((r = bus_init_system(m)) < 0 ||
- (r = bus_init_api(m)) < 0 ||
- (r = bus_init_private(m)) < 0)
+ if ((r = bus_init_private(m)) < 0)
return r;
return 0;
+oom:
+ log_error("Not enough memory");
+ return -ENOMEM;
}
static void shutdown_connection(Manager *m, DBusConnection *c) {
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);
+ /* system manager cannot afford to block on DBus */
+ if (m->running_as != MANAGER_SYSTEM)
+ 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;
+ if (!m->api_bus)
+ return;
+ if (m->running_as == MANAGER_USER)
shutdown_connection(m, m->api_bus);
- m->api_bus = NULL;
- }
+ m->api_bus = NULL;
- if (m->queued_message) {
- dbus_message_unref(m->queued_message);
- m->queued_message = NULL;
- }
+ if (m->queued_message) {
+ dbus_message_unref(m->queued_message);
+ m->queued_message = NULL;
+ }
}
static void bus_done_system(Manager *m) {
- assert(m);
+ if (!m->system_bus)
+ return;
- if (m->system_bus == m->api_bus)
+ if (m->running_as == MANAGER_SYSTEM)
bus_done_api(m);
- if (m->system_bus) {
- shutdown_connection(m, m->system_bus);
- m->system_bus = NULL;
- }
+ shutdown_connection(m, m->system_bus);
+ m->system_bus = NULL;
}
static void bus_done_private(Manager *m) {
+ if (!m->private_bus)
+ return;
- if (m->private_bus) {
- dbus_server_disconnect(m->private_bus);
- dbus_server_unref(m->private_bus);
- m->private_bus = NULL;
- }
+ dbus_server_disconnect(m->private_bus);
+ dbus_server_unref(m->private_bus);
+ m->private_bus = NULL;
}
void bus_done(Manager *m) {
if (m->name_data_slot >= 0)
dbus_pending_call_free_data_slot(&m->name_data_slot);
+ if (m->conn_data_slot >= 0)
+ dbus_pending_call_free_data_slot(&m->conn_data_slot);
+
if (m->subscribed_data_slot >= 0)
- dbus_pending_call_free_data_slot(&m->subscribed_data_slot);
+ dbus_connection_free_data_slot(&m->subscribed_data_slot);
}
static void query_pid_pending_cb(DBusPendingCall *pending, void *userdata) {
case DBUS_MESSAGE_TYPE_ERROR:
assert_se(dbus_set_error_from_message(&error, reply));
- log_warning("GetConnectionUnixProcessID() failed: %s", error.message);
+ log_warning("GetConnectionUnixProcessID() failed: %s", bus_error_message(&error));
break;
case DBUS_MESSAGE_TYPE_METHOD_RETURN: {
&error,
DBUS_TYPE_UINT32, &r,
DBUS_TYPE_INVALID)) {
- log_error("Failed to parse GetConnectionUnixProcessID() reply: %s", error.message);
+ log_error("Failed to parse GetConnectionUnixProcessID() reply: %s", bus_error_message(&error));
break;
}
return -ENOMEM;
}
-DBusHandlerResult bus_default_message_handler(Manager *m, DBusConnection *c, DBusMessage *message, const char*introspection, const BusProperty *properties) {
- DBusError error;
- DBusMessage *reply = NULL;
- int r;
-
- assert(m);
- assert(message);
-
- dbus_error_init(&error);
-
- if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Introspectable", "Introspect") && introspection) {
-
- if (!(reply = dbus_message_new_method_return(message)))
- goto oom;
-
- if (!dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection, DBUS_TYPE_INVALID))
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Properties", "Get") && properties) {
- const char *interface, *property;
- const BusProperty *p;
-
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_STRING, &interface,
- DBUS_TYPE_STRING, &property,
- DBUS_TYPE_INVALID))
- 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))
- break;
-
- if (p->property) {
- DBusMessageIter iter, sub;
-
- if (!(reply = dbus_message_new_method_return(message)))
- goto oom;
-
- dbus_message_iter_init_append(reply, &iter);
-
- if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, p->signature, &sub))
- goto oom;
-
- if ((r = p->append(m, &sub, property, (void*) p->data)) < 0) {
-
- if (r == -ENOMEM)
- goto oom;
-
- dbus_message_unref(reply);
- return bus_send_error_reply(m, c, message, NULL, r);
- }
-
- if (!dbus_message_iter_close_container(&iter, &sub))
- goto oom;
- }
- } else if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Properties", "GetAll") && properties) {
- const char *interface;
- const BusProperty *p;
- DBusMessageIter iter, sub, sub2, sub3;
-
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_STRING, &interface,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(m, c, message, &error, -EINVAL);
-
- if (!(reply = dbus_message_new_method_return(message)))
- goto oom;
-
- dbus_message_iter_init_append(reply, &iter);
-
- if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub))
- goto oom;
-
- for (p = properties; p->property; p++) {
- if (interface[0] && !streq(p->interface, interface))
- continue;
-
- if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY, NULL, &sub2) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &p->property) ||
- !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, p->signature, &sub3))
- goto oom;
-
- if ((r = p->append(m, &sub3, p->property, (void*) p->data)) < 0) {
-
- if (r == -ENOMEM)
- goto oom;
-
- dbus_message_unref(reply);
- 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;
- }
-
- if (!dbus_message_iter_close_container(&iter, &sub))
- goto oom;
- }
-
- if (reply) {
- if (!dbus_connection_send(c, reply, NULL))
- goto oom;
-
- dbus_message_unref(reply);
- return DBUS_HANDLER_RESULT_HANDLED;
- }
-
- 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 const char *error_to_dbus(int error) {
-
- switch(error) {
-
- case -EINVAL:
- return DBUS_ERROR_INVALID_ARGS;
-
- case -ENOMEM:
- return DBUS_ERROR_NO_MEMORY;
-
- case -EPERM:
- case -EACCES:
- return DBUS_ERROR_ACCESS_DENIED;
-
- case -ESRCH:
- return DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN;
-
- case -ENOENT:
- return DBUS_ERROR_FILE_NOT_FOUND;
-
- case -EEXIST:
- return DBUS_ERROR_FILE_EXISTS;
-
- case -ETIMEDOUT:
- return DBUS_ERROR_TIMEOUT;
-
- case -EIO:
- return DBUS_ERROR_IO_ERROR;
-
- case -ENETRESET:
- case -ECONNABORTED:
- case -ECONNRESET:
- return DBUS_ERROR_DISCONNECTED;
- }
-
- return DBUS_ERROR_FAILED;
-}
-
-DBusHandlerResult bus_send_error_reply(Manager *m, DBusConnection *c, DBusMessage *message, DBusError *bus_error, int error) {
- DBusMessage *reply = NULL;
- const char *name, *text;
-
- if (bus_error && dbus_error_is_set(bus_error)) {
- name = bus_error->name;
- text = bus_error->message;
- } else {
- name = error_to_dbus(error);
- text = strerror(-error);
- }
-
- if (!(reply = dbus_message_new_error(message, name, text)))
- goto oom;
-
- if (!dbus_connection_send(c, reply, NULL))
- goto oom;
-
- dbus_message_unref(reply);
-
- if (bus_error)
- dbus_error_free(bus_error);
-
- return DBUS_HANDLER_RESULT_HANDLED;
-
-oom:
- if (reply)
- dbus_message_unref(reply);
-
- if (bus_error)
- dbus_error_free(bus_error);
-
- return DBUS_HANDLER_RESULT_NEED_MEMORY;
-}
-
int bus_broadcast(Manager *m, DBusMessage *message) {
bool oom = false;
Iterator i;
return oom ? -ENOMEM : 0;
}
-int bus_property_append_string(Manager *m, DBusMessageIter *i, const char *property, void *data) {
- const char *t = data;
-
- assert(m);
- assert(i);
- assert(property);
-
- if (!t)
- t = "";
-
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &t))
- return -ENOMEM;
-
- return 0;
-}
-
-int bus_property_append_strv(Manager *m, DBusMessageIter *i, const char *property, void *data) {
- DBusMessageIter sub;
- char **t = data;
-
- assert(m);
- assert(i);
- assert(property);
-
- if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "s", &sub))
- return -ENOMEM;
-
- STRV_FOREACH(t, t)
- if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, t))
- return -ENOMEM;
-
- if (!dbus_message_iter_close_container(i, &sub))
- return -ENOMEM;
-
- return 0;
-}
-
-int bus_property_append_bool(Manager *m, DBusMessageIter *i, const char *property, void *data) {
- bool *b = data;
- dbus_bool_t db;
-
- assert(m);
- assert(i);
- assert(property);
- assert(b);
-
- db = *b;
-
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &db))
- return -ENOMEM;
-
- return 0;
-}
-
-int bus_property_append_uint64(Manager *m, DBusMessageIter *i, const char *property, void *data) {
- assert(m);
- assert(i);
- assert(property);
- assert(data);
-
- /* Let's ensure that pid_t is actually 64bit, and hence this
- * function can be used for usec_t */
- assert_cc(sizeof(uint64_t) == sizeof(usec_t));
-
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, data))
- return -ENOMEM;
-
- return 0;
-}
-
-int bus_property_append_uint32(Manager *m, DBusMessageIter *i, const char *property, void *data) {
- assert(m);
- assert(i);
- assert(property);
- assert(data);
-
- /* Let's ensure that pid_t and mode_t is actually 32bit, and
- * hence this function can be used for pid_t/mode_t */
- assert_cc(sizeof(uint32_t) == sizeof(pid_t));
- assert_cc(sizeof(uint32_t) == sizeof(mode_t));
- assert_cc(sizeof(uint32_t) == sizeof(unsigned));
-
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT32, data))
- return -ENOMEM;
-
- return 0;
-}
+bool bus_has_subscriber(Manager *m) {
+ Iterator i;
+ DBusConnection *c;
-int bus_property_append_int32(Manager *m, DBusMessageIter *i, const char *property, void *data) {
assert(m);
- assert(i);
- assert(property);
- assert(data);
- assert_cc(sizeof(int32_t) == sizeof(int));
+ SET_FOREACH(c, m->bus_connections_for_dispatch, i)
+ if (bus_connection_has_subscriber(m, c))
+ return true;
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, data))
- return -ENOMEM;
+ SET_FOREACH(c, m->bus_connections, i)
+ if (bus_connection_has_subscriber(m, c))
+ return true;
- return 0;
+ return false;
}
-int bus_property_append_size(Manager *m, DBusMessageIter *i, const char *property, void *data) {
- uint64_t u;
-
+bool bus_connection_has_subscriber(Manager *m, DBusConnection *c) {
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;
+ assert(c);
- return 0;
+ return !set_isempty(BUS_CONNECTION_SUBSCRIBED(m, c));
}
-int bus_property_append_ul(Manager *m, DBusMessageIter *i, const char *property, void *data) {
- uint64_t u;
+int bus_fdset_add_all(Manager *m, FDSet *fds) {
+ Iterator i;
+ DBusConnection *c;
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;
+ assert(fds);
- return 0;
-}
+ /* When we are about to reexecute we add all D-Bus fds to the
+ * set to pass over to the newly executed systemd. They won't
+ * be used there however, except that they are closed at the
+ * very end of deserialization, those making it possible for
+ * clients to synchronously wait for systemd to reexec by
+ * simply waiting for disconnection */
-int bus_parse_strv(DBusMessage *m, char ***_l) {
- DBusMessageIter iter, sub;
- unsigned n = 0, i = 0;
- char **l;
-
- assert(m);
- assert(_l);
+ SET_FOREACH(c, m->bus_connections_for_dispatch, i) {
+ int fd;
- if (!dbus_message_iter_init(m, &iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
- dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRING)
- return -EINVAL;
+ if (dbus_connection_get_unix_fd(c, &fd)) {
+ fd = fdset_put_dup(fds, fd);
- dbus_message_iter_recurse(&iter, &sub);
-
- while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
- n++;
- dbus_message_iter_next(&sub);
+ if (fd < 0)
+ return fd;
+ }
}
- if (!(l = new(char*, n+1)))
- return -ENOMEM;
+ SET_FOREACH(c, m->bus_connections, i) {
+ int fd;
- assert_se(dbus_message_iter_init(m, &iter));
- dbus_message_iter_recurse(&iter, &sub);
+ if (dbus_connection_get_unix_fd(c, &fd)) {
+ fd = fdset_put_dup(fds, fd);
- while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
- const char *s;
-
- assert_se(dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING);
- dbus_message_iter_get_basic(&sub, &s);
-
- if (!(l[i++] = strdup(s))) {
- strv_free(l);
- return -ENOMEM;
+ if (fd < 0)
+ return fd;
}
-
- dbus_message_iter_next(&sub);
}
- assert(i == n);
- l[i] = NULL;
-
- if (_l)
- *_l = l;
-
return 0;
}
-bool bus_has_subscriber(Manager *m) {
- Iterator i;
- DBusConnection *c;
+void bus_broadcast_finished(
+ Manager *m,
+ usec_t kernel_usec,
+ usec_t initrd_usec,
+ usec_t userspace_usec,
+ usec_t total_usec) {
+
+ DBusMessage *message;
assert(m);
- SET_FOREACH(c, m->bus_connections_for_dispatch, i)
- if (bus_connection_has_subscriber(m, c))
- return true;
+ message = dbus_message_new_signal("/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "StartupFinished");
+ if (!message) {
+ log_error("Out of memory.");
+ return;
+ }
- SET_FOREACH(c, m->bus_connections, i)
- if (bus_connection_has_subscriber(m, c))
- return true;
+ assert_cc(sizeof(usec_t) == sizeof(uint64_t));
+ if (!dbus_message_append_args(message,
+ DBUS_TYPE_UINT64, &kernel_usec,
+ DBUS_TYPE_UINT64, &initrd_usec,
+ DBUS_TYPE_UINT64, &userspace_usec,
+ DBUS_TYPE_UINT64, &total_usec,
+ DBUS_TYPE_INVALID)) {
+ log_error("Out of memory.");
+ goto finish;
+ }
- return false;
-}
-bool bus_connection_has_subscriber(Manager *m, DBusConnection *c) {
- assert(m);
- assert(c);
+ if (bus_broadcast(m, message) < 0) {
+ log_error("Out of memory.");
+ goto finish;
+ }
- return !set_isempty(BUS_CONNECTION_SUBSCRIBED(m, c));
+finish:
+ if (message)
+ dbus_message_unref(message);
}
~ianmdlvl / elogind.git / blobdiff