#include "path-util.h"
#include "polkit.h"
#include "special.h"
+#include "sleep-config.h"
#include "systemd/sd-id128.h"
#include "systemd/sd-messages.h"
+#include "fileio-label.h"
+#include "label.h"
+#include "utf8.h"
+#include "unit-name.h"
+#include "bus-errors.h"
+#include "virt.h"
#define BUS_MANAGER_INTERFACE \
" <interface name=\"org.freedesktop.login1.Manager\">\n" \
" <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n" \
" <arg name=\"user\" type=\"o\" direction=\"out\"/>\n" \
" </method>\n" \
+ " <method name=\"GetUserByPID\">\n" \
+ " <arg name=\"pid\" type=\"u\" direction=\"in\"/>\n" \
+ " <arg name=\"user\" type=\"o\" direction=\"out\"/>\n" \
+ " </method>\n" \
" <method name=\"GetSeat\">\n" \
" <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"seat\" type=\"o\" direction=\"out\"/>\n" \
" <method name=\"CreateSession\">\n" \
" <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n" \
" <arg name=\"leader\" type=\"u\" direction=\"in\"/>\n" \
- " <arg name=\"sevice\" type=\"s\" direction=\"in\"/>\n" \
+ " <arg name=\"service\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"type\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"class\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"seat\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"remote\" type=\"b\" direction=\"in\"/>\n" \
" <arg name=\"remote_user\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"remote_host\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"controllers\" type=\"as\" direction=\"in\"/>\n" \
- " <arg name=\"reset_controllers\" type=\"as\" direction=\"in\"/>\n" \
- " <arg name=\"kill_processes\" type=\"b\" direction=\"in\"/>\n" \
+ " <arg name=\"scope_properties\" type=\"a(sv)\" direction=\"in\"/>\n" \
" <arg name=\"id\" type=\"s\" direction=\"out\"/>\n" \
" <arg name=\"path\" type=\"o\" direction=\"out\"/>\n" \
" <arg name=\"runtime_path\" type=\"o\" direction=\"out\"/>\n" \
" <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"LockSessions\"/>\n" \
+ " <method name=\"UnlockSessions\"/>\n" \
" <method name=\"KillSession\">\n" \
" <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"who\" type=\"s\" direction=\"in\"/>\n" \
" <signal name=\"PrepareForSleep\">\n" \
" <arg name=\"active\" type=\"b\"/>\n" \
" </signal>\n" \
- " <property name=\"ControlGroupHierarchy\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"Controllers\" type=\"as\" access=\"read\"/>\n" \
- " <property name=\"ResetControllers\" type=\"as\" access=\"read\"/>\n" \
" <property name=\"NAutoVTs\" type=\"u\" access=\"read\"/>\n" \
" <property name=\"KillOnlyUsers\" type=\"as\" access=\"read\"/>\n" \
" <property name=\"KillExcludeUsers\" type=\"as\" access=\"read\"/>\n" \
" <property name=\"HandleSuspendKey\" type=\"s\" access=\"read\"/>\n" \
" <property name=\"HandleHibernateKey\" type=\"s\" access=\"read\"/>\n" \
" <property name=\"HandleLidSwitch\" type=\"s\" access=\"read\"/>\n" \
+ " <property name=\"IdleAction\" type=\"s\" access=\"read\"/>\n" \
+ " <property name=\"IdleActionUSec\" type=\"t\" access=\"read\"/>\n" \
" <property name=\"PreparingForShutdown\" type=\"b\" access=\"read\"/>\n" \
" <property name=\"PreparingForSleep\" type=\"b\" access=\"read\"/>\n" \
" </interface>\n"
assert(property);
if (streq(property, "PreparingForShutdown"))
- b = !!(m->delayed_what & INHIBIT_SHUTDOWN);
+ b = !!(m->action_what & INHIBIT_SHUTDOWN);
else
- b = !!(m->delayed_what & INHIBIT_SLEEP);
+ b = !!(m->action_what & INHIBIT_SLEEP);
dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b);
return 0;
}
-static int bus_manager_create_session(Manager *m, DBusMessage *message, DBusMessage **_reply) {
+static int bus_manager_create_session(Manager *m, DBusMessage *message) {
+
+ const char *type, *class, *cseat, *tty, *display, *remote_user, *remote_host, *service;
+ uint32_t uid, leader, audit_id = 0;
+ _cleanup_free_ char *id = NULL;
Session *session = NULL;
User *user = NULL;
- const char *type, *class, *seat, *tty, *display, *remote_user, *remote_host, *service;
- uint32_t uid, leader, audit_id = 0;
- dbus_bool_t remote, kill_processes, exists;
- char **controllers = NULL, **reset_controllers = NULL;
- SessionType t;
- SessionClass c;
- Seat *s;
+ Seat *seat = NULL;
DBusMessageIter iter;
- int r;
- char *id = NULL, *p;
+ dbus_bool_t remote;
uint32_t vtnr = 0;
- int fifo_fd = -1;
- DBusMessage *reply = NULL;
+ SessionType t;
+ SessionClass c;
bool b;
+ int r;
assert(m);
assert(message);
- assert(_reply);
if (!dbus_message_iter_init(message, &iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
dbus_message_iter_get_basic(&iter, &leader);
- if (leader <= 0 ||
- !dbus_message_iter_next(&iter) ||
+ if (!dbus_message_iter_next(&iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return -EINVAL;
return -EINVAL;
dbus_message_iter_get_basic(&iter, &type);
- t = session_type_from_string(type);
+ if (isempty(type))
+ t = _SESSION_TYPE_INVALID;
+ else {
+ t = session_type_from_string(type);
+ if (t < 0)
+ return -EINVAL;
+ }
- if (t < 0 ||
- !dbus_message_iter_next(&iter) ||
+ if (!dbus_message_iter_next(&iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return -EINVAL;
dbus_message_iter_get_basic(&iter, &class);
if (isempty(class))
- c = SESSION_USER;
- else
+ c = _SESSION_CLASS_INVALID;
+ else {
c = session_class_from_string(class);
+ if (c < 0)
+ return -EINVAL;
+ }
- if (c < 0 ||
- !dbus_message_iter_next(&iter) ||
+ if (!dbus_message_iter_next(&iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return -EINVAL;
- dbus_message_iter_get_basic(&iter, &seat);
+ dbus_message_iter_get_basic(&iter, &cseat);
- if (isempty(seat))
- s = NULL;
+ if (isempty(cseat))
+ seat = NULL;
else {
- s = hashmap_get(m->seats, seat);
- if (!s)
+ seat = hashmap_get(m->seats, cseat);
+ if (!seat)
return -ENOENT;
}
if (tty_is_vc(tty)) {
int v;
- if (!s)
- s = m->vtconsole;
- else if (s != m->vtconsole)
+ if (!seat)
+ seat = m->vtconsole;
+ else if (seat != m->vtconsole)
return -EINVAL;
v = vtnr_from_tty(tty);
return -EINVAL;
} else if (tty_is_console(tty)) {
- if (!s)
- s = m->vtconsole;
- else if (s != m->vtconsole)
+ if (!seat)
+ seat = m->vtconsole;
+ else if (seat != m->vtconsole)
return -EINVAL;
if (vtnr != 0)
return -EINVAL;
+ }
- } else if (!isempty(tty) && s && seat_is_vtconsole(s))
- return -EINVAL;
-
- if (s) {
- if (seat_can_multi_session(s)) {
+ if (seat) {
+ if (seat_can_multi_session(seat)) {
if (vtnr > 63)
return -EINVAL;
} else {
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN)
return -EINVAL;
+ if (t == _SESSION_TYPE_INVALID) {
+ if (!isempty(display))
+ t = SESSION_X11;
+ else if (!isempty(tty))
+ t = SESSION_TTY;
+ else
+ t = SESSION_UNSPECIFIED;
+ }
+
+ if (c == _SESSION_CLASS_INVALID) {
+ if (!isempty(display) || !isempty(tty))
+ c = SESSION_USER;
+ else
+ c = SESSION_BACKGROUND;
+ }
+
dbus_message_iter_get_basic(&iter, &remote);
if (!dbus_message_iter_next(&iter) ||
dbus_message_iter_get_basic(&iter, &remote_host);
- if (!dbus_message_iter_next(&iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
- dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRING)
- return -EINVAL;
-
- r = bus_parse_strv_iter(&iter, &controllers);
- if (r < 0)
- return -EINVAL;
-
- if (strv_contains(controllers, "systemd") ||
- !dbus_message_iter_next(&iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
- dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRING) {
- r = -EINVAL;
- goto fail;
- }
-
- r = bus_parse_strv_iter(&iter, &reset_controllers);
- if (r < 0)
- goto fail;
-
- if (strv_contains(reset_controllers, "systemd") ||
- !dbus_message_iter_next(&iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN) {
- r = -EINVAL;
- goto fail;
+ if (leader <= 0) {
+ leader = bus_get_unix_process_id(m->bus, dbus_message_get_sender(message), NULL);
+ if (leader == 0)
+ return -EINVAL;
}
- dbus_message_iter_get_basic(&iter, &kill_processes);
-
- r = manager_add_user_by_uid(m, uid, &user);
- if (r < 0)
- goto fail;
+ r = manager_get_session_by_pid(m, leader, &session);
+ if (session) {
+ _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+ _cleanup_free_ char *path = NULL;
+ _cleanup_close_ int fifo_fd = -1;
+ dbus_bool_t exists;
- audit_session_from_pid(leader, &audit_id);
+ /* Session already exists, client is probably
+ * something like "su" which changes uid but is still
+ * the same session */
- if (audit_id > 0) {
- asprintf(&id, "%lu", (unsigned long) audit_id);
+ fifo_fd = session_create_fifo(session);
+ if (fifo_fd < 0) {
+ r = fifo_fd;
+ goto fail;
+ }
- if (!id) {
+ path = session_bus_path(session);
+ if (!path) {
r = -ENOMEM;
goto fail;
}
- session = hashmap_get(m->sessions, id);
-
- if (session) {
- free(id);
-
- fifo_fd = session_create_fifo(session);
- if (fifo_fd < 0) {
- r = fifo_fd;
- goto fail;
- }
+ reply = dbus_message_new_method_return(message);
+ if (!reply) {
+ r = -ENOMEM;
+ goto fail;
+ }
- /* Session already exists, client is probably
- * something like "su" which changes uid but
- * is still the same audit session */
+ cseat = session->seat ? session->seat->id : "";
+ vtnr = session->vtnr;
+ exists = true;
- reply = dbus_message_new_method_return(message);
- if (!reply) {
- r = -ENOMEM;
- goto fail;
- }
+ b = dbus_message_append_args(
+ reply,
+ DBUS_TYPE_STRING, &session->id,
+ DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_STRING, &session->user->runtime_path,
+ DBUS_TYPE_UNIX_FD, &fifo_fd,
+ DBUS_TYPE_STRING, &cseat,
+ DBUS_TYPE_UINT32, &vtnr,
+ DBUS_TYPE_BOOLEAN, &exists,
+ DBUS_TYPE_INVALID);
+ if (!b) {
+ r = -ENOMEM;
+ goto fail;
+ }
- p = session_bus_path(session);
- if (!p) {
- r = -ENOMEM;
- goto fail;
- }
+ if (!dbus_connection_send(m->bus, reply, NULL)) {
+ r = -ENOMEM;
+ goto fail;
+ }
- seat = session->seat ? session->seat->id : "";
- vtnr = session->vtnr;
- exists = true;
-
- b = dbus_message_append_args(
- reply,
- DBUS_TYPE_STRING, &session->id,
- DBUS_TYPE_OBJECT_PATH, &p,
- DBUS_TYPE_STRING, &session->user->runtime_path,
- DBUS_TYPE_UNIX_FD, &fifo_fd,
- DBUS_TYPE_STRING, &seat,
- DBUS_TYPE_UINT32, &vtnr,
- DBUS_TYPE_BOOLEAN, &exists,
- DBUS_TYPE_INVALID);
- free(p);
+ return 0;
+ }
- if (!b) {
- r = -ENOMEM;
- goto fail;
- }
+ audit_session_from_pid(leader, &audit_id);
+ if (audit_id > 0) {
+ /* Keep our session IDs and the audit session IDs in sync */
- close_nointr_nofail(fifo_fd);
- *_reply = reply;
+ if (asprintf(&id, "%lu", (unsigned long) audit_id) < 0) {
+ r = -ENOMEM;
+ goto fail;
+ }
- strv_free(controllers);
- strv_free(reset_controllers);
+ /* Wut? There's already a session by this name and we
+ * didn't find it above? Weird, then let's not trust
+ * the audit data and let's better register a new
+ * ID */
+ if (hashmap_get(m->sessions, id)) {
+ audit_id = 0;
- return 0;
+ free(id);
+ id = NULL;
}
+ }
- } else {
+ if (!id) {
do {
free(id);
id = NULL;
} while (hashmap_get(m->sessions, id));
}
- r = manager_add_session(m, user, id, &session);
- free(id);
+ r = manager_add_user_by_uid(m, uid, &user);
if (r < 0)
goto fail;
+ r = manager_add_session(m, id, &session);
+ if (r < 0)
+ goto fail;
+
+ session_set_user(session, user);
+
session->leader = leader;
session->audit_id = audit_id;
session->type = t;
session->class = c;
session->remote = remote;
- session->controllers = controllers;
- session->reset_controllers = reset_controllers;
- session->kill_processes = kill_processes;
session->vtnr = vtnr;
- controllers = reset_controllers = NULL;
-
if (!isempty(tty)) {
session->tty = strdup(tty);
if (!session->tty) {
}
}
- fifo_fd = session_create_fifo(session);
- if (fifo_fd < 0) {
- r = fifo_fd;
- goto fail;
- }
-
- if (s) {
- r = seat_attach_session(s, session);
+ if (seat) {
+ r = seat_attach_session(seat, session);
if (r < 0)
goto fail;
}
if (r < 0)
goto fail;
- reply = dbus_message_new_method_return(message);
- if (!reply) {
- r = -ENOMEM;
- goto fail;
- }
-
- p = session_bus_path(session);
- if (!p) {
- r = -ENOMEM;
- goto fail;
- }
-
- seat = s ? s->id : "";
- exists = false;
- b = dbus_message_append_args(
- reply,
- DBUS_TYPE_STRING, &session->id,
- DBUS_TYPE_OBJECT_PATH, &p,
- DBUS_TYPE_STRING, &session->user->runtime_path,
- DBUS_TYPE_UNIX_FD, &fifo_fd,
- DBUS_TYPE_STRING, &seat,
- DBUS_TYPE_UINT32, &vtnr,
- DBUS_TYPE_BOOLEAN, &exists,
- DBUS_TYPE_INVALID);
- free(p);
-
- if (!b) {
- r = -ENOMEM;
- goto fail;
- }
+ session->create_message = dbus_message_ref(message);
- close_nointr_nofail(fifo_fd);
- *_reply = reply;
+ /* Now, let's wait until the slice unit and stuff got
+ * created. We send the reply back from
+ * session_send_create_reply().*/
return 0;
fail:
- strv_free(controllers);
- strv_free(reset_controllers);
-
if (session)
session_add_to_gc_queue(session);
if (user)
user_add_to_gc_queue(user);
- if (fifo_fd >= 0)
- close_nointr_nofail(fifo_fd);
-
- if (reply)
- dbus_message_unref(reply);
-
return r;
}
-static int bus_manager_inhibit(Manager *m, DBusConnection *connection, DBusMessage *message, DBusError *error, DBusMessage **_reply) {
+static int bus_manager_inhibit(
+ Manager *m,
+ DBusConnection *connection,
+ DBusMessage *message,
+ DBusError *error,
+ DBusMessage **_reply) {
+
Inhibitor *i = NULL;
char *id = NULL;
const char *who, *why, *what, *mode;
InhibitMode mm;
unsigned long ul;
int r, fifo_fd = -1;
- DBusMessage *reply = NULL;
+ _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
assert(m);
assert(connection);
goto fail;
}
+ /* Don't allow taking delay locks while we are already
+ * executing the operation. We shouldn't create the impression
+ * that the lock was successful if the machine is about to go
+ * down/suspend any moment. */
+ if (m->action_what & w) {
+ r = -EALREADY;
+ goto fail;
+ }
+
r = verify_polkit(connection, message,
w == INHIBIT_SHUTDOWN ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-shutdown" : "org.freedesktop.login1.inhibit-delay-shutdown") :
w == INHIBIT_SLEEP ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-sleep" : "org.freedesktop.login1.inhibit-delay-sleep") :
close_nointr_nofail(fifo_fd);
*_reply = reply;
+ reply = NULL;
inhibitor_start(i);
if (fifo_fd >= 0)
close_nointr_nofail(fifo_fd);
- if (reply)
- dbus_message_unref(reply);
-
return r;
}
goto finish;
}
- write_one_line_file(t, "change");
+ write_string_file(t, "change");
free(t);
}
static int attach_device(Manager *m, const char *seat, const char *sysfs) {
struct udev_device *d;
- char *rule = NULL, *file = NULL;
+ _cleanup_free_ char *rule = NULL, *file = NULL;
const char *id_for_seat;
int r;
}
mkdir_p_label("/etc/udev/rules.d", 0755);
- r = write_one_line_file_atomic(file, rule);
+ label_init("/etc");
+ r = write_string_file_atomic_label(file, rule);
if (r < 0)
goto finish;
r = trigger_device(m, d);
finish:
- free(rule);
- free(file);
-
if (d)
udev_device_unref(d);
}
static int flush_devices(Manager *m) {
- DIR *d;
+ _cleanup_closedir_ DIR *d;
assert(m);
if (unlinkat(dirfd(d), de->d_name, 0) < 0)
log_warning("Failed to unlink %s: %m", de->d_name);
}
-
- closedir(d);
}
return trigger_device(m, NULL);
assert(m);
- /* Check for other users' sessions. Greeter sessions do not count. */
+ /* Check for other users' sessions. Greeter sessions do not
+ * count, and non-login sessions do not count either. */
HASHMAP_FOREACH(session, m->sessions, i)
- if (session->class == SESSION_USER && session->user->uid != uid)
+ if (session->class == SESSION_USER &&
+ session->user->uid != uid)
return true;
return false;
}
-static int send_start_unit(DBusConnection *connection, const char *unit_name, DBusError *error) {
- const char *mode = "replace";
+static int bus_manager_log_shutdown(
+ Manager *m,
+ InhibitWhat w,
+ const char *unit_name) {
+
+ const char *p, *q;
+
+ assert(m);
+ assert(unit_name);
+
+ if (w != INHIBIT_SHUTDOWN)
+ return 0;
+
+ if (streq(unit_name, SPECIAL_POWEROFF_TARGET)) {
+ p = "MESSAGE=System is powering down.";
+ q = "SHUTDOWN=power-off";
+ } else if (streq(unit_name, SPECIAL_HALT_TARGET)) {
+ p = "MESSAGE=System is halting.";
+ q = "SHUTDOWN=halt";
+ } else if (streq(unit_name, SPECIAL_REBOOT_TARGET)) {
+ p = "MESSAGE=System is rebooting.";
+ q = "SHUTDOWN=reboot";
+ } else if (streq(unit_name, SPECIAL_KEXEC_TARGET)) {
+ p = "MESSAGE=System is rebooting with kexec.";
+ q = "SHUTDOWN=kexec";
+ } else {
+ p = "MESSAGE=System is shutting down.";
+ q = NULL;
+ }
+
+ return log_struct(LOG_NOTICE, MESSAGE_ID(SD_MESSAGE_SHUTDOWN),
+ p,
+ q, NULL);
+}
+
+static int execute_shutdown_or_sleep(
+ Manager *m,
+ InhibitWhat w,
+ const char *unit_name,
+ DBusError *error) {
+
+ _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+ const char *mode = "replace-irreversibly", *p;
+ int r;
+ char *c;
+ assert(m);
+ assert(w >= 0);
+ assert(w < _INHIBIT_WHAT_MAX);
assert(unit_name);
- return bus_method_call_with_reply (
- connection,
+ bus_manager_log_shutdown(m, w, unit_name);
+
+ r = bus_method_call_with_reply(
+ m->bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"StartUnit",
- NULL,
- NULL,
+ &reply,
+ error,
DBUS_TYPE_STRING, &unit_name,
DBUS_TYPE_STRING, &mode,
DBUS_TYPE_INVALID);
-}
-
-static int send_prepare_for(Manager *m, InhibitWhat w, bool _active) {
- static const char * const signal_name[_INHIBIT_WHAT_MAX] = {
- [INHIBIT_SHUTDOWN] = "PrepareForShutdown",
- [INHIBIT_SLEEP] = "PrepareForSleep"
- };
-
- dbus_bool_t active = _active;
- DBusMessage *message;
- int r = 0;
+ if (r < 0)
+ return r;
- assert(m);
- assert(w >= 0);
- assert(w < _INHIBIT_WHAT_MAX);
- assert(signal_name[w]);
+ if (!dbus_message_get_args(
+ reply,
+ error,
+ DBUS_TYPE_OBJECT_PATH, &p,
+ DBUS_TYPE_INVALID))
+ return -EINVAL;
- message = dbus_message_new_signal("/org/freedesktop/login1", "org.freedesktop.login1.Manager", signal_name[w]);
- if (!message)
+ c = strdup(p);
+ if (!c)
return -ENOMEM;
- if (!dbus_message_append_args(message, DBUS_TYPE_BOOLEAN, &active, DBUS_TYPE_INVALID) ||
- !dbus_connection_send(m->bus, message, NULL))
- r = -ENOMEM;
+ m->action_unit = unit_name;
+ free(m->action_job);
+ m->action_job = c;
+ m->action_what = w;
- dbus_message_unref(message);
- return r;
+ return 0;
}
-static int delay_shutdown_or_sleep(Manager *m, InhibitWhat w, const char *unit_name) {
+static int delay_shutdown_or_sleep(
+ Manager *m,
+ InhibitWhat w,
+ const char *unit_name) {
+
assert(m);
assert(w >= 0);
assert(w < _INHIBIT_WHAT_MAX);
+ assert(unit_name);
- /* Tell everybody to prepare for shutdown/sleep */
- send_prepare_for(m, w, true);
-
- /* Update timestamp for timeout */
- if (!m->delayed_unit)
- m->delayed_timestamp = now(CLOCK_MONOTONIC);
-
- /* Remember what we want to do, possibly overriding what kind
- * of unit we previously queued. */
- m->delayed_unit = unit_name;
- m->delayed_what = w;
+ m->action_timestamp = now(CLOCK_MONOTONIC);
+ m->action_unit = unit_name;
+ m->action_what = w;
return 0;
}
const char *action,
const char *action_multiple_sessions,
const char *action_ignore_inhibit,
- const char *sleep_type,
- const char *sleep_disk_type,
+ const char *sleep_verb,
DBusError *error,
DBusMessage **_reply) {
bool multiple_sessions, challenge, blocked, b;
- const char *result;
- DBusMessage *reply = NULL;
+ const char *result = NULL;
+ _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
int r;
unsigned long ul;
assert(error);
assert(_reply);
- if (sleep_type) {
- r = can_sleep(sleep_type);
- if (r < 0)
- return r;
-
- if (r == 0) {
- result = "na";
- goto finish;
- }
- }
-
- if (sleep_disk_type) {
- r = can_sleep_disk(sleep_disk_type);
+ if (sleep_verb) {
+ r = can_sleep(sleep_verb);
if (r < 0)
return r;
-
if (r == 0) {
result = "na";
goto finish;
reply,
DBUS_TYPE_STRING, &result,
DBUS_TYPE_INVALID);
- if (!b) {
- dbus_message_unref(reply);
+ if (!b)
return -ENOMEM;
- }
*_reply = reply;
+ reply = NULL;
return 0;
}
-static int bus_manager_log_shutdown(
- Manager *m,
- InhibitWhat w,
- const char *unit_name) {
+static int send_prepare_for(Manager *m, InhibitWhat w, bool _active) {
+ static const char * const signal_name[_INHIBIT_WHAT_MAX] = {
+ [INHIBIT_SHUTDOWN] = "PrepareForShutdown",
+ [INHIBIT_SLEEP] = "PrepareForSleep"
+ };
- const char *p, *q;
+ dbus_bool_t active = _active;
+ _cleanup_dbus_message_unref_ DBusMessage *message = NULL;
assert(m);
- assert(unit_name);
+ assert(w >= 0);
+ assert(w < _INHIBIT_WHAT_MAX);
+ assert(signal_name[w]);
- if (w != INHIBIT_SHUTDOWN)
- return 0;
+ message = dbus_message_new_signal("/org/freedesktop/login1", "org.freedesktop.login1.Manager", signal_name[w]);
+ if (!message)
+ return -ENOMEM;
- if (streq(unit_name, SPECIAL_POWEROFF_TARGET)) {
- p = "MESSAGE=System is powering down.";
- q = "SHUTDOWN=power-off";
- } else if (streq(unit_name, SPECIAL_HALT_TARGET)) {
- p = "MESSAGE=System is halting.";
- q = "SHUTDOWN=halt";
- } else if (streq(unit_name, SPECIAL_REBOOT_TARGET)) {
- p = "MESSAGE=System is rebooting.";
- q = "SHUTDOWN=reboot";
- } else if (streq(unit_name, SPECIAL_KEXEC_TARGET)) {
- p = "MESSAGE=System is rebooting with kexec.";
- q = "SHUTDOWN=kexec";
- } else {
- p = "MESSAGE=System is shutting down.";
- q = NULL;
- }
+ if (!dbus_message_append_args(message, DBUS_TYPE_BOOLEAN, &active, DBUS_TYPE_INVALID) ||
+ !dbus_connection_send(m->bus, message, NULL))
+ return -ENOMEM;
- return log_struct(LOG_NOTICE, MESSAGE_ID(SD_MESSAGE_SHUTDOWN),
- p,
- q, NULL);
+ return 0;
}
int bus_manager_shutdown_or_sleep_now_or_later(
assert(unit_name);
assert(w >= 0);
assert(w <= _INHIBIT_WHAT_MAX);
+ assert(!m->action_job);
+
+ /* Tell everybody to prepare for shutdown/sleep */
+ send_prepare_for(m, w, true);
delayed =
m->inhibit_delay_max > 0 &&
/* Shutdown is delayed, keep in mind what we
* want to do, and start a timeout */
r = delay_shutdown_or_sleep(m, w, unit_name);
- else {
- bus_manager_log_shutdown(m, w, unit_name);
-
+ else
/* Shutdown is not delayed, execute it
* immediately */
- r = send_start_unit(m->bus, unit_name, error);
- }
+ r = execute_shutdown_or_sleep(m, w, unit_name, error);
return r;
}
const char *action,
const char *action_multiple_sessions,
const char *action_ignore_inhibit,
- const char *sleep_type,
- const char *sleep_disk_type,
+ const char *sleep_verb,
DBusError *error,
DBusMessage **_reply) {
assert(error);
assert(_reply);
+ /* Don't allow multiple jobs being executed at the same time */
+ if (m->action_what)
+ return -EALREADY;
+
if (!dbus_message_get_args(
message,
error,
DBUS_TYPE_INVALID))
return -EINVAL;
- if (sleep_type) {
- r = can_sleep(sleep_type);
- if (r < 0)
- return r;
-
- if (r == 0)
- return -ENOTSUP;
- }
-
- if (sleep_disk_type) {
- r = can_sleep_disk(sleep_disk_type);
+ if (sleep_verb) {
+ r = can_sleep(sleep_verb);
if (r < 0)
return r;
return 0;
}
-static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_manager_append_handle_button, handle_button, HandleButton);
+static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_manager_append_handle_action, handle_action, HandleAction);
static const BusProperty bus_login_manager_properties[] = {
- { "ControlGroupHierarchy", bus_property_append_string, "s", offsetof(Manager, cgroup_path), true },
- { "Controllers", bus_property_append_strv, "as", offsetof(Manager, controllers), true },
- { "ResetControllers", bus_property_append_strv, "as", offsetof(Manager, reset_controllers), true },
{ "NAutoVTs", bus_property_append_unsigned, "u", offsetof(Manager, n_autovts) },
{ "KillOnlyUsers", bus_property_append_strv, "as", offsetof(Manager, kill_only_users), true },
{ "KillExcludeUsers", bus_property_append_strv, "as", offsetof(Manager, kill_exclude_users), true },
{ "BlockInhibited", bus_manager_append_inhibited, "s", 0 },
{ "DelayInhibited", bus_manager_append_inhibited, "s", 0 },
{ "InhibitDelayMaxUSec", bus_property_append_usec, "t", offsetof(Manager, inhibit_delay_max) },
- { "HandlePowerKey", bus_manager_append_handle_button, "s", offsetof(Manager, handle_power_key) },
- { "HandleSuspendKey", bus_manager_append_handle_button, "s", offsetof(Manager, handle_suspend_key) },
- { "HandleHibernateKey", bus_manager_append_handle_button, "s", offsetof(Manager, handle_hibernate_key)},
- { "HandleLidSwitch", bus_manager_append_handle_button, "s", offsetof(Manager, handle_lid_switch) },
+ { "HandlePowerKey", bus_manager_append_handle_action, "s", offsetof(Manager, handle_power_key) },
+ { "HandleSuspendKey", bus_manager_append_handle_action, "s", offsetof(Manager, handle_suspend_key) },
+ { "HandleHibernateKey", bus_manager_append_handle_action, "s", offsetof(Manager, handle_hibernate_key)},
+ { "HandleLidSwitch", bus_manager_append_handle_action, "s", offsetof(Manager, handle_lid_switch) },
+ { "IdleAction", bus_manager_append_handle_action, "s", offsetof(Manager, idle_action) },
+ { "IdleActionUSec", bus_property_append_usec, "t", offsetof(Manager, idle_action_usec) },
{ "PreparingForShutdown", bus_manager_append_preparing, "b", 0 },
{ "PreparingForSleep", bus_manager_append_preparing, "b", 0 },
{ NULL, }
Manager *m = userdata;
DBusError error;
- DBusMessage *reply = NULL;
+ _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
int r;
assert(connection);
if (!b)
goto oom;
+ } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetUserByPID")) {
+ uint32_t pid;
+ char *p;
+ User *user;
+ bool b;
+
+ if (!dbus_message_get_args(
+ message,
+ &error,
+ DBUS_TYPE_UINT32, &pid,
+ DBUS_TYPE_INVALID))
+ return bus_send_error_reply(connection, message, &error, -EINVAL);
+
+ r = manager_get_user_by_pid(m, pid, &user);
+ if (r <= 0)
+ return bus_send_error_reply(connection, message, NULL, r < 0 ? r : -ENOENT);
+
+ reply = dbus_message_new_method_return(message);
+ if (!reply)
+ goto oom;
+
+ p = user_bus_path(user);
+ if (!p)
+ goto oom;
+
+ b = dbus_message_append_args(
+ reply,
+ DBUS_TYPE_OBJECT_PATH, &p,
+ DBUS_TYPE_INVALID);
+ free(p);
+
+ if (!b)
+ goto oom;
+
} else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetSeat")) {
const char *name;
char *p;
goto oom;
} else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListUsers")) {
- char *p;
User *user;
Iterator i;
DBusMessageIter iter, sub;
goto oom;
HASHMAP_FOREACH(user, m->users, i) {
+ _cleanup_free_ char *p = NULL;
DBusMessageIter sub2;
uint32_t uid;
goto oom;
}
- free(p);
-
if (!dbus_message_iter_close_container(&sub, &sub2))
goto oom;
}
goto oom;
} else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListSeats")) {
- char *p;
Seat *seat;
Iterator i;
DBusMessageIter iter, sub;
goto oom;
HASHMAP_FOREACH(seat, m->seats, i) {
+ _cleanup_free_ char *p = NULL;
DBusMessageIter sub2;
if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
goto oom;
}
- free(p);
-
if (!dbus_message_iter_close_container(&sub, &sub2))
goto oom;
}
if (!dbus_message_iter_close_container(&iter, &sub))
goto oom;
+
} else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "Inhibit")) {
r = bus_manager_inhibit(m, connection, message, &error, &reply);
} else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CreateSession")) {
- r = bus_manager_create_session(m, message, &reply);
+ r = bus_manager_create_session(m, message);
/* Don't delay the work on OOM here, since it might be
* triggered by a low RLIMIT_NOFILE here (since we
session = hashmap_get(m->sessions, name);
if (!session)
- return bus_send_error_reply(connection, message, &error, -ENOENT);
+ return bus_send_error_reply(connection, message, NULL, -ENOENT);
if (session_send_lock(session, streq(dbus_message_get_member(message), "LockSession")) < 0)
goto oom;
if (!reply)
goto oom;
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "LockSessions")) {
- Session *session;
- Iterator i;
+ } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "LockSessions") ||
+ dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "UnlockSessions")) {
- HASHMAP_FOREACH(session, m->sessions, i)
- if (session_send_lock(session, true) < 0)
- goto oom;
+ r = session_send_lock_all(m, streq(dbus_message_get_member(message), "LockSessions"));
+ if (r < 0)
+ bus_send_error_reply(connection, message, NULL, r);
reply = dbus_message_new_method_return(message);
if (!reply)
"org.freedesktop.login1.power-off",
"org.freedesktop.login1.power-off-multiple-sessions",
"org.freedesktop.login1.power-off-ignore-inhibit",
- NULL, NULL,
+ NULL,
&error, &reply);
if (r < 0)
return bus_send_error_reply(connection, message, &error, r);
"org.freedesktop.login1.reboot",
"org.freedesktop.login1.reboot-multiple-sessions",
"org.freedesktop.login1.reboot-ignore-inhibit",
- NULL, NULL,
+ NULL,
&error, &reply);
if (r < 0)
return bus_send_error_reply(connection, message, &error, r);
"org.freedesktop.login1.suspend",
"org.freedesktop.login1.suspend-multiple-sessions",
"org.freedesktop.login1.suspend-ignore-inhibit",
- "mem", NULL,
+ "suspend",
&error, &reply);
if (r < 0)
return bus_send_error_reply(connection, message, &error, r);
"org.freedesktop.login1.hibernate",
"org.freedesktop.login1.hibernate-multiple-sessions",
"org.freedesktop.login1.hibernate-ignore-inhibit",
- "disk", NULL,
+ "hibernate",
&error, &reply);
if (r < 0)
return bus_send_error_reply(connection, message, &error, r);
"org.freedesktop.login1.hibernate",
"org.freedesktop.login1.hibernate-multiple-sessions",
"org.freedesktop.login1.hibernate-ignore-inhibit",
- "disk", "suspend",
+ "hybrid-sleep",
&error, &reply);
if (r < 0)
return bus_send_error_reply(connection, message, &error, r);
"org.freedesktop.login1.power-off",
"org.freedesktop.login1.power-off-multiple-sessions",
"org.freedesktop.login1.power-off-ignore-inhibit",
- NULL, NULL,
+ NULL,
&error, &reply);
if (r < 0)
return bus_send_error_reply(connection, message, &error, r);
"org.freedesktop.login1.reboot",
"org.freedesktop.login1.reboot-multiple-sessions",
"org.freedesktop.login1.reboot-ignore-inhibit",
- NULL, NULL,
+ NULL,
&error, &reply);
if (r < 0)
return bus_send_error_reply(connection, message, &error, r);
"org.freedesktop.login1.suspend",
"org.freedesktop.login1.suspend-multiple-sessions",
"org.freedesktop.login1.suspend-ignore-inhibit",
- "mem", NULL,
+ "suspend",
&error, &reply);
if (r < 0)
return bus_send_error_reply(connection, message, &error, r);
"org.freedesktop.login1.hibernate",
"org.freedesktop.login1.hibernate-multiple-sessions",
"org.freedesktop.login1.hibernate-ignore-inhibit",
- "disk", NULL,
+ "hibernate",
&error, &reply);
if (r < 0)
return bus_send_error_reply(connection, message, &error, r);
"org.freedesktop.login1.hibernate",
"org.freedesktop.login1.hibernate-multiple-sessions",
"org.freedesktop.login1.hibernate-ignore-inhibit",
- "disk", "suspend",
+ "hybrid-sleep",
&error, &reply);
if (r < 0)
return bus_send_error_reply(connection, message, &error, r);
}
if (reply) {
- if (!dbus_connection_send(connection, reply, NULL))
+ if (!bus_maybe_send_reply(connection, message, reply))
goto oom;
-
- dbus_message_unref(reply);
}
return DBUS_HANDLER_RESULT_HANDLED;
oom:
- if (reply)
- dbus_message_unref(reply);
-
dbus_error_free(&error);
return DBUS_HANDLER_RESULT_NEED_MEMORY;
dbus_error_init(&error);
- if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Agent", "Released")) {
- const char *cgroup;
+ log_debug("Got message: %s %s %s", strna(dbus_message_get_sender(message)), strna(dbus_message_get_interface(message)), strna(dbus_message_get_member(message)));
+
+ if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobRemoved")) {
+ const char *path, *result, *unit;
+ uint32_t id;
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
- manager_cgroup_notify_empty(m, cgroup);
+ DBUS_TYPE_UINT32, &id,
+ DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_STRING, &unit,
+ DBUS_TYPE_STRING, &result,
+ DBUS_TYPE_INVALID)) {
+ log_error("Failed to parse JobRemoved message: %s", bus_error_message(&error));
+ goto finish;
+ }
+
+ if (m->action_job && streq(m->action_job, path)) {
+ log_info("Operation finished.");
+
+ /* Tell people that they now may take a lock again */
+ send_prepare_for(m, m->action_what, false);
+
+ free(m->action_job);
+ m->action_job = NULL;
+ m->action_unit = NULL;
+ m->action_what = 0;
+
+ } else {
+ Session *s;
+ User *u;
+
+ s = hashmap_get(m->session_units, unit);
+ if (s) {
+ if (streq_ptr(path, s->scope_job)) {
+ free(s->scope_job);
+ s->scope_job = NULL;
+
+ if (s->started) {
+ if (streq(result, "done"))
+ session_send_create_reply(s, NULL);
+ else {
+ dbus_set_error(&error, BUS_ERROR_JOB_FAILED, "Start job for unit %s failed with '%s'", unit, result);
+ session_send_create_reply(s, &error);
+ }
+ } else
+ session_save(s);
+ }
+
+ session_add_to_gc_queue(s);
+ }
+
+ u = hashmap_get(m->user_units, unit);
+ if (u) {
+ if (streq_ptr(path, u->service_job)) {
+ free(u->service_job);
+ u->service_job = NULL;
+ }
+
+ if (streq_ptr(path, u->slice_job)) {
+ free(u->slice_job);
+ u->slice_job = NULL;
+ }
+
+ user_save(u);
+ user_add_to_gc_queue(u);
+ }
+ }
+
+ } else if (dbus_message_is_signal(message, "org.freedesktop.DBus.Properties", "PropertiesChanged")) {
+
+ _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+ _cleanup_free_ char *unit = NULL;
+ const char *path;
+
+ path = dbus_message_get_path(message);
+ if (!path)
+ goto finish;
+
+ unit_name_from_dbus_path(path, &unit);
+ if (unit) {
+ Session *s;
+ User *u;
+
+ s = hashmap_get(m->session_units, unit);
+ if (s)
+ session_add_to_gc_queue(s);
+
+ u = hashmap_get(m->user_units, unit);
+ if (u)
+ user_add_to_gc_queue(u);
+ }
+
+ } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "UnitRemoved")) {
+
+ const char *path, *unit;
+ Session *session;
+ User *user;
+
+ if (!dbus_message_get_args(message, &error,
+ DBUS_TYPE_STRING, &unit,
+ DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID)) {
+ log_error("Failed to parse UnitRemoved message: %s", bus_error_message(&error));
+ goto finish;
+ }
+
+ session = hashmap_get(m->session_units, unit);
+ if (session)
+ session_add_to_gc_queue(session);
+
+ user = hashmap_get(m->user_units, unit);
+ if (user)
+ user_add_to_gc_queue(user);
+
+ } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "Reloading")) {
+ dbus_bool_t b;
+
+ if (!dbus_message_get_args(message, &error,
+ DBUS_TYPE_BOOLEAN, &b,
+ DBUS_TYPE_INVALID)) {
+ log_error("Failed to parse Reloading message: %s", bus_error_message(&error));
+ goto finish;
+ }
+
+ /* systemd finished reloading, let's recheck all our sessions */
+ if (!b) {
+ Session *session;
+ Iterator i;
+
+ log_debug("System manager has been reloaded, rechecking sessions...");
+
+ HASHMAP_FOREACH(session, m->sessions, i)
+ session_add_to_gc_queue(session);
+ }
}
+finish:
dbus_error_free(&error);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
int manager_send_changed(Manager *manager, const char *properties) {
- DBusMessage *m;
- int r = -ENOMEM;
+ _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
assert(manager);
- m = bus_properties_changed_new("/org/freedesktop/login1", "org.freedesktop.login1.Manager", properties);
+ m = bus_properties_changed_new("/org/freedesktop/login1",
+ "org.freedesktop.login1.Manager",
+ properties);
if (!m)
- goto finish;
+ return -ENOMEM;
if (!dbus_connection_send(manager->bus, m, NULL))
- goto finish;
-
- r = 0;
-
-finish:
- if (m)
- dbus_message_unref(m);
+ return -ENOMEM;
- return r;
+ return 0;
}
int manager_dispatch_delayed(Manager *manager) {
- const char *unit_name;
DBusError error;
- bool delayed;
int r;
assert(manager);
- if (!manager->delayed_unit)
+ if (manager->action_what == 0 || manager->action_job)
return 0;
/* Continue delay? */
- delayed =
- manager->delayed_timestamp + manager->inhibit_delay_max > now(CLOCK_MONOTONIC) &&
- manager_is_inhibited(manager, manager->delayed_what, INHIBIT_DELAY, NULL, false, false, 0);
- if (delayed)
- return 0;
+ if (manager_is_inhibited(manager, manager->action_what, INHIBIT_DELAY, NULL, false, false, 0)) {
- bus_manager_log_shutdown(manager, manager->delayed_what, manager->delayed_unit);
+ if (manager->action_timestamp + manager->inhibit_delay_max > now(CLOCK_MONOTONIC))
+ return 0;
- /* Reset delay data */
- unit_name = manager->delayed_unit;
- manager->delayed_unit = NULL;
+ log_info("Delay lock is active but inhibitor timeout is reached.");
+ }
- /* Actually do the shutdown */
+ /* Actually do the operation */
dbus_error_init(&error);
- r = send_start_unit(manager->bus, unit_name, &error);
+ r = execute_shutdown_or_sleep(manager, manager->action_what, manager->action_unit, &error);
if (r < 0) {
- log_warning("Failed to send delayed message: %s", bus_error_message_or_strerror(&error, -r));
+ log_warning("Failed to send delayed message: %s", bus_error(&error, r));
dbus_error_free(&error);
+
+ manager->action_unit = NULL;
+ manager->action_what = 0;
return r;
}
- /* Tell people about it */
- send_prepare_for(manager, manager->delayed_what, false);
+ return 1;
+}
+
+int manager_start_scope(
+ Manager *manager,
+ const char *scope,
+ pid_t pid,
+ const char *slice,
+ const char *description,
+ const char *after,
+ DBusError *error,
+ char **job) {
+
+ _cleanup_dbus_message_unref_ DBusMessage *m = NULL, *reply = NULL;
+ DBusMessageIter iter, sub, sub2, sub3, sub4;
+ const char *timeout_stop_property = "TimeoutStopUSec";
+ const char *pids_property = "PIDs";
+ uint64_t timeout = 500 * USEC_PER_MSEC;
+ const char *fail = "fail";
+ uint32_t u;
+
+ assert(manager);
+ assert(scope);
+ assert(pid > 1);
+
+ if (!slice)
+ slice = "";
+
+ m = dbus_message_new_method_call(
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "StartTransientUnit");
+ if (!m)
+ return log_oom();
+
+ dbus_message_iter_init_append(m, &iter);
+
+ if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &scope) ||
+ !dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &fail) ||
+ !dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sv)", &sub))
+ return log_oom();
+
+ if (!isempty(slice)) {
+ const char *slice_property = "Slice";
+
+ if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
+ !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &slice_property) ||
+ !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "s", &sub3) ||
+ !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_STRING, &slice) ||
+ !dbus_message_iter_close_container(&sub2, &sub3) ||
+ !dbus_message_iter_close_container(&sub, &sub2))
+ return log_oom();
+ }
+
+ if (!isempty(description)) {
+ const char *description_property = "Description";
+
+ if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
+ !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &description_property) ||
+ !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "s", &sub3) ||
+ !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_STRING, &description) ||
+ !dbus_message_iter_close_container(&sub2, &sub3) ||
+ !dbus_message_iter_close_container(&sub, &sub2))
+ return log_oom();
+ }
+
+ if (!isempty(after)) {
+ const char *after_property = "After";
+
+ if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
+ !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &after_property) ||
+ !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "as", &sub3) ||
+ !dbus_message_iter_open_container(&sub3, DBUS_TYPE_ARRAY, "s", &sub4) ||
+ !dbus_message_iter_append_basic(&sub4, DBUS_TYPE_STRING, &after) ||
+ !dbus_message_iter_close_container(&sub3, &sub4) ||
+ !dbus_message_iter_close_container(&sub2, &sub3) ||
+ !dbus_message_iter_close_container(&sub, &sub2))
+ return log_oom();
+ }
+
+ /* cgroup empty notification is not available in containers
+ * currently. To make this less problematic, let's shorten the
+ * stop timeout for sessions, so that we don't wait
+ * forever. */
+
+ if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
+ !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &timeout_stop_property) ||
+ !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "t", &sub3) ||
+ !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_UINT64, &timeout) ||
+ !dbus_message_iter_close_container(&sub2, &sub3) ||
+ !dbus_message_iter_close_container(&sub, &sub2))
+ return log_oom();
+
+ u = pid;
+ if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
+ !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &pids_property) ||
+ !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "au", &sub3) ||
+ !dbus_message_iter_open_container(&sub3, DBUS_TYPE_ARRAY, "u", &sub4) ||
+ !dbus_message_iter_append_basic(&sub4, DBUS_TYPE_UINT32, &u) ||
+ !dbus_message_iter_close_container(&sub3, &sub4) ||
+ !dbus_message_iter_close_container(&sub2, &sub3) ||
+ !dbus_message_iter_close_container(&sub, &sub2) ||
+ !dbus_message_iter_close_container(&iter, &sub))
+ return log_oom();
+
+ reply = dbus_connection_send_with_reply_and_block(manager->bus, m, -1, error);
+ if (!reply)
+ return -EIO;
+
+ if (job) {
+ const char *j;
+ char *copy;
+
+ if (!dbus_message_get_args(reply, error, DBUS_TYPE_OBJECT_PATH, &j, DBUS_TYPE_INVALID))
+ return -EIO;
+
+ copy = strdup(j);
+ if (!copy)
+ return -ENOMEM;
+
+ *job = copy;
+ }
+
+ return 0;
+}
+
+int manager_start_unit(Manager *manager, const char *unit, DBusError *error, char **job) {
+ _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+ const char *fail = "fail";
+ int r;
+
+ assert(manager);
+ assert(unit);
+
+ r = bus_method_call_with_reply(
+ manager->bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "StartUnit",
+ &reply,
+ error,
+ DBUS_TYPE_STRING, &unit,
+ DBUS_TYPE_STRING, &fail,
+ DBUS_TYPE_INVALID);
+ if (r < 0) {
+ log_error("Failed to start unit %s: %s", unit, bus_error(error, r));
+ return r;
+ }
+
+ if (job) {
+ const char *j;
+ char *copy;
+
+ if (!dbus_message_get_args(reply, error,
+ DBUS_TYPE_OBJECT_PATH, &j,
+ DBUS_TYPE_INVALID)) {
+ log_error("Failed to parse reply.");
+ return -EIO;
+ }
+
+ copy = strdup(j);
+ if (!copy)
+ return -ENOMEM;
+
+ *job = copy;
+ }
+
+ return 0;
+}
+
+int manager_stop_unit(Manager *manager, const char *unit, DBusError *error, char **job) {
+ _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+ const char *fail = "fail";
+ int r;
+
+ assert(manager);
+ assert(unit);
+
+ r = bus_method_call_with_reply(
+ manager->bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "StopUnit",
+ &reply,
+ error,
+ DBUS_TYPE_STRING, &unit,
+ DBUS_TYPE_STRING, &fail,
+ DBUS_TYPE_INVALID);
+ if (r < 0) {
+ if (dbus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
+ dbus_error_has_name(error, BUS_ERROR_LOAD_FAILED)) {
+
+ if (job)
+ *job = NULL;
+
+ dbus_error_free(error);
+ return 0;
+ }
+
+ log_error("Failed to stop unit %s: %s", unit, bus_error(error, r));
+ return r;
+ }
+
+ if (job) {
+ const char *j;
+ char *copy;
+
+ if (!dbus_message_get_args(reply, error,
+ DBUS_TYPE_OBJECT_PATH, &j,
+ DBUS_TYPE_INVALID)) {
+ log_error("Failed to parse reply.");
+ return -EIO;
+ }
+
+ copy = strdup(j);
+ if (!copy)
+ return -ENOMEM;
+
+ *job = copy;
+ }
return 1;
}
+
+int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, DBusError *error) {
+ _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+ const char *w;
+ int r;
+
+ assert(manager);
+ assert(unit);
+
+ w = who == KILL_LEADER ? "process" : "cgroup";
+ assert_cc(sizeof(signo) == sizeof(int32_t));
+
+ r = bus_method_call_with_reply(
+ manager->bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "KillUnit",
+ &reply,
+ error,
+ DBUS_TYPE_STRING, &unit,
+ DBUS_TYPE_STRING, &w,
+ DBUS_TYPE_INT32, &signo,
+ DBUS_TYPE_INVALID);
+ if (r < 0) {
+ log_error("Failed to stop unit %s: %s", unit, bus_error(error, r));
+ return r;
+ }
+
+ return 0;
+}
+
+int manager_unit_is_active(Manager *manager, const char *unit) {
+
+ const char *interface = "org.freedesktop.systemd1.Unit";
+ const char *property = "ActiveState";
+ _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+ _cleanup_free_ char *path = NULL;
+ DBusMessageIter iter, sub;
+ const char *state;
+ DBusError error;
+ int r;
+
+ assert(manager);
+ assert(unit);
+
+ dbus_error_init(&error);
+
+ path = unit_dbus_path_from_name(unit);
+ if (!path)
+ return -ENOMEM;
+
+ r = bus_method_call_with_reply(
+ manager->bus,
+ "org.freedesktop.systemd1",
+ path,
+ "org.freedesktop.DBus.Properties",
+ "Get",
+ &reply,
+ &error,
+ DBUS_TYPE_STRING, &interface,
+ DBUS_TYPE_STRING, &property,
+ DBUS_TYPE_INVALID);
+ if (r < 0) {
+ if (dbus_error_has_name(&error, DBUS_ERROR_NO_REPLY) ||
+ dbus_error_has_name(&error, DBUS_ERROR_DISCONNECTED)) {
+ /* systemd might have droppped off
+ * momentarily, let's not make this an
+ * error */
+
+ dbus_error_free(&error);
+ return true;
+ }
+
+ if (dbus_error_has_name(&error, BUS_ERROR_NO_SUCH_UNIT) ||
+ dbus_error_has_name(&error, BUS_ERROR_LOAD_FAILED)) {
+ /* If the unit is already unloaded then it's
+ * not active */
+
+ dbus_error_free(&error);
+ return false;
+ }
+
+ log_error("Failed to query ActiveState: %s", bus_error(&error, r));
+ dbus_error_free(&error);
+ return r;
+ }
+
+ if (!dbus_message_iter_init(reply, &iter) ||
+ dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
+ log_error("Failed to parse reply.");
+ return -EINVAL;
+ }
+
+ dbus_message_iter_recurse(&iter, &sub);
+ if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) {
+ log_error("Failed to parse reply.");
+ return -EINVAL;
+ }
+
+ dbus_message_iter_get_basic(&sub, &state);
+
+ return !streq(state, "inactive") && !streq(state, "failed");
+}
~ianmdlvl / elogind.git / blobdiff