#include <sys/reboot.h>
#include <stdio.h>
#include <getopt.h>
+#include <locale.h>
#include <stdbool.h>
#include <string.h>
#include <errno.h>
#include "install.h"
#include "logs-show.h"
#include "path-util.h"
+#include "socket-util.h"
static const char *arg_type = NULL;
+static const char *arg_load_state = NULL;
static char **arg_property = NULL;
static bool arg_all = false;
static const char *arg_job_mode = "replace";
static bool arg_no_legend = false;
static bool arg_no_pager = false;
static bool arg_no_wtmp = false;
-static bool arg_no_sync = false;
static bool arg_no_wall = false;
static bool arg_no_reload = false;
+static bool arg_ignore_inhibitors = false;
static bool arg_dry = false;
static bool arg_quiet = false;
static bool arg_full = false;
static bool arg_runtime = false;
static char **arg_wall = NULL;
static const char *arg_kill_who = NULL;
-static const char *arg_kill_mode = NULL;
static int arg_signal = SIGTERM;
static const char *arg_root = NULL;
static usec_t arg_when = 0;
ACTION_EXIT,
ACTION_SUSPEND,
ACTION_HIBERNATE,
+ ACTION_HYBRID_SLEEP,
ACTION_RUNLEVEL2,
ACTION_RUNLEVEL3,
ACTION_RUNLEVEL4,
TRANSPORT_POLKIT
} arg_transport = TRANSPORT_NORMAL;
static const char *arg_host = NULL;
-static bool arg_follow = false;
static unsigned arg_lines = 10;
static OutputMode arg_output = OUTPUT_SHORT;
static int daemon_reload(DBusConnection *bus, char **args);
static void halt_now(enum action a);
-static bool on_tty(void) {
- static int t = -1;
-
- /* Note that this is invoked relatively early, before we start
- * the pager. That means the value we return reflects whether
- * we originally were started on a tty, not if we currently
- * are. But this is intended, since we want colour and so on
- * when run in our own pager. */
-
- if (_unlikely_(t < 0))
- t = isatty(STDOUT_FILENO) > 0;
-
- return t;
-}
-
static void pager_open_if_enabled(void) {
- /* Cache result before we open the pager */
- on_tty();
-
if (arg_no_pager)
return;
}
#endif
-static const char *ansi_highlight_red(bool b) {
+static const char *ansi_highlight(bool b) {
if (!on_tty())
return "";
- return b ? ANSI_HIGHLIGHT_RED_ON : ANSI_HIGHLIGHT_OFF;
+ return b ? ANSI_HIGHLIGHT_ON : ANSI_HIGHLIGHT_OFF;
}
-static const char *ansi_highlight_green(bool b) {
+static const char *ansi_highlight_red(bool b) {
if (!on_tty())
return "";
- return b ? ANSI_HIGHLIGHT_GREEN_ON : ANSI_HIGHLIGHT_OFF;
+ return b ? ANSI_HIGHLIGHT_RED_ON : ANSI_HIGHLIGHT_OFF;
}
-static bool error_is_no_service(const DBusError *error) {
- assert(error);
-
- if (!dbus_error_is_set(error))
- return false;
-
- if (dbus_error_has_name(error, DBUS_ERROR_NAME_HAS_NO_OWNER))
- return true;
+static const char *ansi_highlight_green(bool b) {
- if (dbus_error_has_name(error, DBUS_ERROR_SERVICE_UNKNOWN))
- return true;
+ if (!on_tty())
+ return "";
- return startswith(error->name, "org.freedesktop.DBus.Error.Spawn.");
+ return b ? ANSI_HIGHLIGHT_GREEN_ON : ANSI_HIGHLIGHT_OFF;
}
static int translate_bus_error_to_exit_status(int r, const DBusError *error) {
static void warn_wall(enum action a) {
static const char *table[_ACTION_MAX] = {
- [ACTION_HALT] = "The system is going down for system halt NOW!",
- [ACTION_REBOOT] = "The system is going down for reboot NOW!",
- [ACTION_POWEROFF] = "The system is going down for power-off NOW!",
- [ACTION_KEXEC] = "The system is going down for kexec reboot NOW!",
- [ACTION_RESCUE] = "The system is going down to rescue mode NOW!",
- [ACTION_EMERGENCY] = "The system is going down to emergency mode NOW!"
+ [ACTION_HALT] = "The system is going down for system halt NOW!",
+ [ACTION_REBOOT] = "The system is going down for reboot NOW!",
+ [ACTION_POWEROFF] = "The system is going down for power-off NOW!",
+ [ACTION_KEXEC] = "The system is going down for kexec reboot NOW!",
+ [ACTION_RESCUE] = "The system is going down to rescue mode NOW!",
+ [ACTION_EMERGENCY] = "The system is going down to emergency mode NOW!",
+ [ACTION_CANCEL_SHUTDOWN] = "The system shutdown has been cancelled NOW!"
};
if (arg_no_wall)
return (!arg_type || ((dot = strrchr(u->id, '.')) &&
streq(dot+1, arg_type))) &&
- (arg_all || !(streq(u->active_state, "inactive") || u->following[0]) || u->job_id > 0);
+ (!arg_load_state || streq(u->load_state, arg_load_state)) &&
+ (arg_all || !(streq(u->active_state, "inactive")
+ || u->following[0]) || u->job_id > 0);
}
static void output_units_list(const struct unit_info *unit_infos, unsigned c) {
unsigned id_len, max_id_len, active_len, sub_len, job_len, desc_len, n_shown = 0;
const struct unit_info *u;
+ int job_count = 0;
max_id_len = sizeof("UNIT")-1;
active_len = sizeof("ACTIVE")-1;
max_id_len = MAX(max_id_len, strlen(u->id));
active_len = MAX(active_len, strlen(u->active_state));
sub_len = MAX(sub_len, strlen(u->sub_state));
- if (u->job_id != 0)
+ if (u->job_id != 0) {
job_len = MAX(job_len, strlen(u->job_type));
+ job_count++;
+ }
}
if (!arg_full) {
unsigned basic_len;
id_len = MIN(max_id_len, 25);
- basic_len = 5 + id_len + 6 + active_len + sub_len + job_len;
+ basic_len = 5 + id_len + 5 + active_len + sub_len;
+ if (job_count)
+ basic_len += job_len + 1;
if (basic_len < (unsigned) columns()) {
unsigned extra_len, incr;
extra_len = columns() - basic_len;
} else
id_len = max_id_len;
- if (!arg_no_legend) {
- printf("%-*s %-6s %-*s %-*s %-*s ", id_len, "UNIT", "LOAD",
- active_len, "ACTIVE", sub_len, "SUB", job_len, "JOB");
- if (!arg_full && arg_no_pager)
- printf("%.*s\n", desc_len, "DESCRIPTION");
- else
- printf("%s\n", "DESCRIPTION");
- }
-
for (u = unit_infos; u < unit_infos + c; u++) {
char *e;
const char *on_loaded, *off_loaded;
if (!output_show_unit(u))
continue;
+ if (!n_shown && !arg_no_legend) {
+ printf("%-*s %-6s %-*s %-*s ", id_len, "UNIT", "LOAD",
+ active_len, "ACTIVE", sub_len, "SUB");
+ if (job_count)
+ printf("%-*s ", job_len, "JOB");
+ if (!arg_full && arg_no_pager)
+ printf("%.*s\n", desc_len, "DESCRIPTION");
+ else
+ printf("%s\n", "DESCRIPTION");
+ }
+
n_shown++;
if (streq(u->load_state, "error")) {
e = arg_full ? NULL : ellipsize(u->id, id_len, 33);
- printf("%-*s %s%-6s%s %s%-*s %-*s%s %-*s ",
+ printf("%-*s %s%-6s%s %s%-*s %-*s%s %-*s",
id_len, e ? e : u->id,
on_loaded, u->load_state, off_loaded,
on_active, active_len, u->active_state,
sub_len, u->sub_state, off_active,
- job_len, u->job_id ? u->job_type : "");
+ job_count ? job_len + 1 : 0, u->job_id ? u->job_type : "");
if (!arg_full && arg_no_pager)
printf("%.*s\n", desc_len, u->description);
else
}
if (!arg_no_legend) {
- printf("\nLOAD = Reflects whether the unit definition was properly loaded.\n"
- "ACTIVE = The high-level unit activation state, i.e. generalization of SUB.\n"
- "SUB = The low-level unit activation state, values depend on unit type.\n"
- "JOB = Pending job for the unit.\n");
+ const char *on, *off;
+
+ if (n_shown) {
+ printf("\nLOAD = Reflects whether the unit definition was properly loaded.\n"
+ "ACTIVE = The high-level unit activation state, i.e. generalization of SUB.\n"
+ "SUB = The low-level unit activation state, values depend on unit type.\n");
+ if (job_count)
+ printf("JOB = Pending job for the unit.\n");
+ puts("");
+ on = ansi_highlight(true);
+ off = ansi_highlight(false);
+ } else {
+ on = ansi_highlight_red(true);
+ off = ansi_highlight_red(false);
+ }
if (arg_all)
- printf("\n%u units listed.\n", n_shown);
+ printf("%s%u loaded units listed.%s\n"
+ "To show all installed unit files use 'systemctl list-unit-files'.\n",
+ on, n_shown, off);
else
- printf("\n%u units listed. Pass --all to see inactive units, too.\n", n_shown);
+ printf("%s%u loaded units listed.%s Pass --all to see loaded but inactive units, too.\n"
+ "To show all installed unit files use 'systemctl list-unit-files'.\n",
+ on, n_shown, off);
}
}
static int list_units(DBusConnection *bus, char **args) {
- DBusMessage *m = NULL, *reply = NULL;
- DBusError error;
+ DBusMessage *reply = NULL;
int r;
DBusMessageIter iter, sub, sub2;
unsigned c = 0, n_units = 0;
struct unit_info *unit_infos = NULL;
- dbus_error_init(&error);
-
- assert(bus);
-
pager_open_if_enabled();
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- "ListUnits"))) {
- log_error("Could not allocate message.");
- return -ENOMEM;
- }
-
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
+ r = bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "ListUnits",
+ &reply,
+ NULL,
+ DBUS_TYPE_INVALID);
+ if (r)
goto finish;
- }
if (!dbus_message_iter_init(reply, &iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
output_units_list(unit_infos, c);
}
- r = 0;
-
finish:
- if (m)
- dbus_message_unref(m);
-
if (reply)
dbus_message_unref(reply);
free(unit_infos);
- dbus_error_free(&error);
-
return r;
}
if (u->state == UNIT_FILE_MASKED ||
u->state == UNIT_FILE_MASKED_RUNTIME ||
- u->state == UNIT_FILE_DISABLED) {
+ u->state == UNIT_FILE_DISABLED ||
+ u->state == UNIT_FILE_INVALID) {
on = ansi_highlight_red(true);
off = ansi_highlight_red(false);
} else if (u->state == UNIT_FILE_ENABLED) {
}
static int list_unit_files(DBusConnection *bus, char **args) {
- DBusMessage *m = NULL, *reply = NULL;
- DBusError error;
+ DBusMessage *reply = NULL;
int r;
DBusMessageIter iter, sub, sub2;
unsigned c = 0, n_units = 0;
UnitFileList *units = NULL;
- dbus_error_init(&error);
-
pager_open_if_enabled();
if (avoid_bus()) {
Iterator i;
h = hashmap_new(string_hash_func, string_compare_func);
- if (!h) {
- log_error("Out of memory");
- return -ENOMEM;
- }
+ if (!h)
+ return log_oom();
r = unit_file_get_list(arg_scope, arg_root, h);
if (r < 0) {
units = new(UnitFileList, n_units);
if (!units) {
unit_file_list_free(h);
- log_error("Out of memory");
- return -ENOMEM;
+ return log_oom();
}
HASHMAP_FOREACH(u, h, i) {
hashmap_free(h);
} else {
- assert(bus);
-
- m = dbus_message_new_method_call(
+ r = bus_method_call_with_reply (
+ bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- "ListUnitFiles");
- if (!m) {
- log_error("Could not allocate message.");
- return -ENOMEM;
- }
-
- reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
- if (!reply) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
+ "ListUnitFiles",
+ &reply,
+ NULL,
+ DBUS_TYPE_INVALID);
+ if (r)
goto finish;
- }
if (!dbus_message_iter_init(reply, &iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
r = 0;
finish:
- if (m)
- dbus_message_unref(m);
-
if (reply)
dbus_message_unref(reply);
free(units);
- dbus_error_free(&error);
-
return r;
}
"RequiresOverridable", "[color=\"black\"]",
"Requisite", "[color=\"darkblue\"]",
"RequisiteOverridable", "[color=\"darkblue\"]",
- "Wants", "[color=\"darkgrey\"]",
+ "Wants", "[color=\"grey66\"]",
"Conflicts", "[color=\"red\"]",
"ConflictedBy", "[color=\"red\"]",
"After", "[color=\"green\"]"
}
static int dot_one(DBusConnection *bus, const char *name, const char *path) {
- DBusMessage *m = NULL, *reply = NULL;
+ DBusMessage *reply = NULL;
const char *interface = "org.freedesktop.systemd1.Unit";
int r;
- DBusError error;
DBusMessageIter iter, sub, sub2, sub3;
- assert(bus);
assert(path);
- dbus_error_init(&error);
-
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- path,
- "org.freedesktop.DBus.Properties",
- "GetAll"))) {
- log_error("Could not allocate message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, &interface,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
+ r = bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ path,
+ "org.freedesktop.DBus.Properties",
+ "GetAll",
+ &reply,
+ NULL,
+ DBUS_TYPE_STRING, &interface,
+ DBUS_TYPE_INVALID);
+ if (r)
goto finish;
- }
if (!dbus_message_iter_init(reply, &iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
dbus_message_iter_next(&sub);
}
- r = 0;
-
finish:
- if (m)
- dbus_message_unref(m);
-
if (reply)
dbus_message_unref(reply);
- dbus_error_free(&error);
-
return r;
}
static int dot(DBusConnection *bus, char **args) {
- DBusMessage *m = NULL, *reply = NULL;
- DBusError error;
+ DBusMessage *reply = NULL;
int r;
DBusMessageIter iter, sub, sub2;
- dbus_error_init(&error);
-
- assert(bus);
-
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- "ListUnits"))) {
- log_error("Could not allocate message.");
- return -ENOMEM;
- }
-
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
+ r = bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "ListUnits",
+ &reply,
+ NULL,
+ DBUS_TYPE_INVALID);
+ if (r)
goto finish;
- }
if (!dbus_message_iter_init(reply, &iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
r = 0;
finish:
- if (m)
- dbus_message_unref(m);
-
if (reply)
dbus_message_unref(reply);
- dbus_error_free(&error);
-
return r;
}
static int list_jobs(DBusConnection *bus, char **args) {
- DBusMessage *m = NULL, *reply = NULL;
- DBusError error;
+ DBusMessage *reply = NULL;
int r;
DBusMessageIter iter, sub, sub2;
unsigned k = 0;
- dbus_error_init(&error);
-
- assert(bus);
-
pager_open_if_enabled();
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- "ListJobs"))) {
- log_error("Could not allocate message.");
- return -ENOMEM;
- }
-
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
+ r = bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "ListJobs",
+ &reply,
+ NULL,
+ DBUS_TYPE_INVALID);
+ if (r)
goto finish;
- }
if (!dbus_message_iter_init(reply, &iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
r = 0;
finish:
- if (m)
- dbus_message_unref(m);
-
if (reply)
dbus_message_unref(reply);
- dbus_error_free(&error);
-
return r;
}
static int load_unit(DBusConnection *bus, char **args) {
- DBusMessage *m = NULL;
- DBusError error;
- int r;
char **name;
- dbus_error_init(&error);
-
- assert(bus);
assert(args);
STRV_FOREACH(name, args+1) {
- DBusMessage *reply;
-
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- "LoadUnit"))) {
- log_error("Could not allocate message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, name,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
- goto finish;
- }
-
- dbus_message_unref(m);
- dbus_message_unref(reply);
+ _cleanup_free_ char *n = NULL;
+ int r;
- m = reply = NULL;
+ n = unit_name_mangle(*name);
+ r = bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "LoadUnit",
+ NULL,
+ NULL,
+ DBUS_TYPE_STRING, n ? &n : name,
+ DBUS_TYPE_INVALID);
+ if (r < 0)
+ return r;
}
- r = 0;
-
-finish:
- if (m)
- dbus_message_unref(m);
-
- dbus_error_free(&error);
-
- return r;
+ return 0;
}
static int cancel_job(DBusConnection *bus, char **args) {
- DBusMessage *m = NULL, *reply = NULL;
- DBusError error;
- int r;
char **name;
- dbus_error_init(&error);
-
- assert(bus);
assert(args);
if (strv_length(args) <= 1)
return daemon_reload(bus, args);
STRV_FOREACH(name, args+1) {
- unsigned id;
- const char *path;
-
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- "GetJob"))) {
- log_error("Could not allocate message.");
- r = -ENOMEM;
- goto finish;
- }
+ uint32_t id;
+ int r;
- if ((r = safe_atou(*name, &id)) < 0) {
+ r = safe_atou32(*name, &id);
+ if (r < 0) {
log_error("Failed to parse job id: %s", strerror(-r));
- goto finish;
- }
-
- assert_cc(sizeof(uint32_t) == sizeof(id));
- if (!dbus_message_append_args(m,
- DBUS_TYPE_UINT32, &id,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
- goto finish;
- }
-
- if (!dbus_message_get_args(reply, &error,
- DBUS_TYPE_OBJECT_PATH, &path,
- DBUS_TYPE_INVALID)) {
- log_error("Failed to parse reply: %s", bus_error_message(&error));
- r = -EIO;
- goto finish;
- }
-
- dbus_message_unref(m);
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- path,
- "org.freedesktop.systemd1.Job",
- "Cancel"))) {
- log_error("Could not allocate message.");
- r = -ENOMEM;
- goto finish;
- }
-
- dbus_message_unref(reply);
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
- goto finish;
+ return r;
}
- dbus_message_unref(m);
- dbus_message_unref(reply);
- m = reply = NULL;
+ r = bus_method_call_with_reply(
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "CancelJob",
+ NULL,
+ NULL,
+ DBUS_TYPE_UINT32, &id,
+ DBUS_TYPE_INVALID);
+ if (r < 0)
+ return r;
}
- r = 0;
-
-finish:
- if (m)
- dbus_message_unref(m);
-
- if (reply)
- dbus_message_unref(reply);
-
- dbus_error_free(&error);
-
- return r;
+ return 0;
}
static bool need_daemon_reload(DBusConnection *bus, const char *unit) {
- DBusMessage *m = NULL, *reply = NULL;
+ DBusMessage *reply = NULL;
dbus_bool_t b = FALSE;
DBusMessageIter iter, sub;
const char
*interface = "org.freedesktop.systemd1.Unit",
*property = "NeedDaemonReload",
*path;
+ char *n;
+ int r;
/* We ignore all errors here, since this is used to show a warning only */
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- "GetUnit")))
- goto finish;
-
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, &unit,
- DBUS_TYPE_INVALID))
- goto finish;
-
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, NULL)))
+ n = unit_name_mangle(unit);
+ r = bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "GetUnit",
+ &reply,
+ NULL,
+ DBUS_TYPE_STRING, n ? (const char**) &n : &unit,
+ DBUS_TYPE_INVALID);
+ free(n);
+ if (r)
goto finish;
if (!dbus_message_get_args(reply, NULL,
DBUS_TYPE_INVALID))
goto finish;
- dbus_message_unref(m);
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- path,
- "org.freedesktop.DBus.Properties",
- "Get")))
- goto finish;
-
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, &interface,
- DBUS_TYPE_STRING, &property,
- DBUS_TYPE_INVALID)) {
- goto finish;
- }
-
dbus_message_unref(reply);
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, NULL)))
+ r = bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ path,
+ "org.freedesktop.DBus.Properties",
+ "Get",
+ &reply,
+ NULL,
+ DBUS_TYPE_STRING, &interface,
+ DBUS_TYPE_STRING, &property,
+ DBUS_TYPE_INVALID);
+ if (r)
goto finish;
if (!dbus_message_iter_init(reply, &iter) ||
dbus_message_iter_get_basic(&sub, &b);
finish:
- if (m)
- dbus_message_unref(m);
-
if (reply)
dbus_message_unref(reply);
typedef struct WaitData {
Set *set;
+
+ char *name;
char *result;
} WaitData;
p = set_remove(d->set, (char*) path);
free(p);
- if (*result)
+ if (!isempty(result))
d->result = strdup(result);
+ if (!isempty(unit))
+ d->name = strdup(unit);
+
goto finish;
}
#ifndef LEGACY
}
static int wait_for_jobs(DBusConnection *bus, Set *s) {
- int r;
+ int r = 0;
WaitData d;
assert(bus);
zero(d);
d.set = s;
- if (!dbus_connection_add_filter(bus, wait_filter, &d, NULL)) {
- log_error("Failed to add filter.");
- r = -ENOMEM;
- goto finish;
- }
+ if (!dbus_connection_add_filter(bus, wait_filter, &d, NULL))
+ return log_oom();
- while (!set_isempty(s) &&
- dbus_connection_read_write_dispatch(bus, -1))
- ;
+ while (!set_isempty(s)) {
- if (!arg_quiet && d.result) {
- if (streq(d.result, "timeout"))
- log_error("Job timed out.");
- else if (streq(d.result, "canceled"))
- log_error("Job canceled.");
- else if (streq(d.result, "dependency"))
- log_error("A dependency job failed. See system journal for details.");
- else if (!streq(d.result, "done") && !streq(d.result, "skipped"))
- log_error("Job failed. See system journal and 'systemctl status' for details.");
- }
+ if (!dbus_connection_read_write_dispatch(bus, -1)) {
+ log_error("Disconnected from bus.");
+ return -ECONNREFUSED;
+ }
- if (streq_ptr(d.result, "timeout"))
- r = -ETIME;
- else if (streq_ptr(d.result, "canceled"))
- r = -ECANCELED;
- else if (!streq_ptr(d.result, "done") && !streq_ptr(d.result, "skipped"))
- r = -EIO;
- else
- r = 0;
+ if (!d.result)
+ goto free_name;
- free(d.result);
+ if (!arg_quiet) {
+ if (streq(d.result, "timeout"))
+ log_error("Job for %s timed out.", strna(d.name));
+ else if (streq(d.result, "canceled"))
+ log_error("Job for %s canceled.", strna(d.name));
+ else if (streq(d.result, "dependency"))
+ log_error("A dependency job for %s failed. See 'journalctl -xn' for details.", strna(d.name));
+ else if (!streq(d.result, "done") && !streq(d.result, "skipped"))
+ log_error("Job for %s failed. See 'systemctl status %s' and 'journalctl -xn' for details.", strna(d.name), strna(d.name));
+ }
+
+ if (streq_ptr(d.result, "timeout"))
+ r = -ETIME;
+ else if (streq_ptr(d.result, "canceled"))
+ r = -ECANCELED;
+ else if (!streq_ptr(d.result, "done") && !streq_ptr(d.result, "skipped"))
+ r = -EIO;
-finish:
- /* This is slightly dirty, since we don't undo the filter registration. */
+ free(d.result);
+ d.result = NULL;
+ free_name:
+ free(d.name);
+ d.name = NULL;
+ }
+
+ dbus_connection_remove_filter(bus, wait_filter, &d);
return r;
}
-static int get_unit_path(
- DBusConnection *bus,
- const char *name,
- char **unit_path) {
-
+static int check_one_unit(DBusConnection *bus, const char *name, char **check_states, bool quiet) {
+ _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+ DBusMessageIter iter, sub;
+ const char
+ *interface = "org.freedesktop.systemd1.Unit",
+ *property = "ActiveState";
+ const char *state, *path;
+ _cleanup_free_ char *n = NULL;
DBusError error;
- DBusMessage *m = NULL, *reply = NULL;
- char *path;
- int r = 0;
+ int r;
- assert(bus);
assert(name);
- assert(unit_path);
dbus_error_init(&error);
- m = dbus_message_new_method_call("org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- "GetUnit");
- if (!m) {
- log_error("Could not allocate message.");
- r = -ENOMEM;
- goto finish;
- }
+ n = unit_name_mangle(name);
+ if (!n)
+ return log_oom();
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
+ r = bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "GetUnit",
+ &reply,
+ &error,
+ DBUS_TYPE_STRING, &n,
+ DBUS_TYPE_INVALID);
+ if (r < 0) {
+ dbus_error_free(&error);
- reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
- if (!reply) {
- if (streq(error.name, BUS_ERROR_NO_SUCH_UNIT))
- r = -EINVAL;
- else {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
- }
- goto finish;
+ if (!quiet)
+ puts("unknown");
+ return 0;
}
- if (!dbus_message_get_args(reply, &error,
+ if (!dbus_message_get_args(reply, NULL,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID)) {
- log_error("Failed to parse reply: %s", bus_error_message(&error));
- r = -EIO;
- goto finish;
- }
-
- *unit_path = strdup(path);
- if (!(*unit_path)) {
- log_error("Failed to duplicate unit path");
- r = -ENOMEM;
+ log_error("Failed to parse reply.");
+ return -EIO;
}
-finish:
- if (m)
- dbus_message_unref(m);
- if (reply)
- dbus_message_unref(reply);
-
- dbus_error_free(&error);
-
- return r;
-}
-
-static int is_socket_listening(
- DBusConnection *bus,
- const char *socket_name) {
-
- DBusError error;
- DBusMessage *m = NULL, *reply = NULL;
- DBusMessageIter iter, sub;
- char *socket_object_path = NULL;
- const char *sub_state = NULL,
- *interface = "org.freedesktop.systemd1.Unit",
- *property = "SubState";
- int r = 0;
- assert(bus);
- assert(socket_name);
-
- dbus_error_init(&error);
-
- r = get_unit_path(bus, socket_name, &socket_object_path);
- if (r < 0)
- goto finish;
-
- m = dbus_message_new_method_call("org.freedesktop.systemd1",
- socket_object_path,
- "org.freedesktop.DBus.Properties",
- "Get");
- if (!m) {
- log_error("Could not allocate message.");
- r = -ENOMEM;
- goto finish;
- }
+ dbus_message_unref(reply);
+ reply = NULL;
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, &interface,
- DBUS_TYPE_STRING, &property,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
+ r = bus_method_call_with_reply(
+ bus,
+ "org.freedesktop.systemd1",
+ path,
+ "org.freedesktop.DBus.Properties",
+ "Get",
+ &reply,
+ NULL,
+ DBUS_TYPE_STRING, &interface,
+ DBUS_TYPE_STRING, &property,
+ DBUS_TYPE_INVALID);
+ if (r < 0) {
+ if (!quiet)
+ puts("unknown");
+ return 0;
}
- reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
- if (!reply) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
- goto finish;
+ if (!dbus_message_iter_init(reply, &iter) ||
+ dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
+ log_error("Failed to parse reply.");
+ return r;
}
- dbus_message_iter_init(reply, &iter);
dbus_message_iter_recurse(&iter, &sub);
- if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) {
- log_error("Failed to parse reply: %s", bus_error_message(&error));
- r = -EIO;
- goto finish;
+ if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) {
+ log_error("Failed to parse reply.");
+ return r;
}
- dbus_message_iter_get_basic(&sub, &sub_state);
- r = streq(sub_state, "listening");
-finish:
- if (m)
- dbus_message_unref(m);
- if (reply)
- dbus_message_unref(reply);
+ dbus_message_iter_get_basic(&sub, &state);
- dbus_error_free(&error);
+ if (!quiet)
+ puts(state);
- free(socket_object_path);
- return r;
+ return strv_find(check_states, state) ? 1 : 0;
}
-static void check_listening_sockets(
+static void check_triggering_units(
DBusConnection *bus,
const char *unit_name) {
- DBusError error;
- DBusMessage *m = NULL, *reply = NULL;
+ _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
DBusMessageIter iter, sub;
- const char *service_trigger = NULL,
- *interface = "org.freedesktop.systemd1.Unit",
+ const char *interface = "org.freedesktop.systemd1.Unit",
*triggered_by_property = "TriggeredBy";
- char *unit_path = NULL;
+ char _cleanup_free_ *unit_path = NULL, *n = NULL;
bool print_warning_label = true;
+ int r;
- dbus_error_init(&error);
-
- if (get_unit_path(bus, unit_name, &unit_path) < 0)
- goto finish;
-
- m = dbus_message_new_method_call("org.freedesktop.systemd1",
- unit_path,
- "org.freedesktop.DBus.Properties",
- "Get");
- if (!m) {
- log_error("Could not allocate message.");
- goto finish;
+ n = unit_name_mangle(unit_name);
+ if (!n) {
+ log_oom();
+ return;
}
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, &interface,
- DBUS_TYPE_STRING, &triggered_by_property,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- goto finish;
+ unit_path = unit_dbus_path_from_name(n);
+ if (!unit_path) {
+ log_oom();
+ return;
}
- reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
- if (!reply) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- goto finish;
- }
+ r = bus_method_call_with_reply(
+ bus,
+ "org.freedesktop.systemd1",
+ unit_path,
+ "org.freedesktop.DBus.Properties",
+ "Get",
+ &reply,
+ NULL,
+ DBUS_TYPE_STRING, &interface,
+ DBUS_TYPE_STRING, &triggered_by_property,
+ DBUS_TYPE_INVALID);
+ if (r < 0)
+ return;
if (!dbus_message_iter_init(reply, &iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
- log_error("Failed to parse reply: %s", bus_error_message(&error));
- goto finish;
-
+ log_error("Failed to parse reply.");
+ return;
}
dbus_message_iter_recurse(&iter, &sub);
sub = iter;
while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
- int r;
+ const char * const check_states[] = {
+ "active",
+ "reloading",
+ NULL
+ };
+ const char *service_trigger;
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) {
- log_error("Failed to parse reply: %s", bus_error_message(&error));
- goto finish;
+ log_error("Failed to parse reply.");
+ return;
}
dbus_message_iter_get_basic(&sub, &service_trigger);
- if (!endswith(service_trigger, ".socket"))
- goto next;
-
- r = is_socket_listening(bus, service_trigger);
+ r = check_one_unit(bus, service_trigger, (char**) check_states, true);
if (r < 0)
- goto finish;
- if (r == 1) {
+ return;
+ if (r > 0) {
if (print_warning_label) {
- log_warning("There are listening sockets associated with %s :", unit_name);
+ log_warning("Warning: Stopping %s, but it can still be activated by:", unit_name);
print_warning_label = false;
}
- log_warning("%s", service_trigger);
- }
-next:
- dbus_message_iter_recurse(&iter, &sub);
- iter = sub;
- }
-finish:
- if (m)
- dbus_message_unref(m);
-
- if (reply)
- dbus_message_unref(reply);
- dbus_error_free(&error);
+ log_warning(" %s", service_trigger);
+ }
- free(unit_path);
+ dbus_message_iter_next(&sub);
+ }
}
static int start_unit_one(
DBusError *error,
Set *s) {
- DBusMessage *m = NULL, *reply = NULL;
+ _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
const char *path;
int r;
+ _cleanup_free_ char *n, *p = NULL;
- assert(bus);
assert(method);
assert(name);
assert(mode);
assert(error);
- assert(arg_no_block || s);
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- method))) {
- log_error("Could not allocate message.");
- r = -ENOMEM;
- goto finish;
- }
+ n = unit_name_mangle(name);
+ if (!n)
+ return log_oom();
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_STRING, &mode,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, error))) {
-
- if (arg_action != ACTION_SYSTEMCTL && error_is_no_service(error)) {
+ r = bus_method_call_with_reply(
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ method,
+ &reply,
+ error,
+ DBUS_TYPE_STRING, &n,
+ DBUS_TYPE_STRING, &mode,
+ DBUS_TYPE_INVALID);
+ if (r) {
+ if (r == -ENOENT && arg_action != ACTION_SYSTEMCTL)
/* There's always a fallback possible for
* legacy actions. */
r = -EADDRNOTAVAIL;
- goto finish;
- }
+ else
+ log_error("Failed to issue method call: %s", bus_error_message(error));
- log_error("Failed to issue method call: %s", bus_error_message(error));
- r = -EIO;
- goto finish;
+ return r;
}
if (!dbus_message_get_args(reply, error,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID)) {
log_error("Failed to parse reply: %s", bus_error_message(error));
- r = -EIO;
- goto finish;
+ return -EIO;
}
- if (need_daemon_reload(bus, name))
- log_warning("Warning: Unit file of created job changed on disk, 'systemctl %s daemon-reload' recommended.",
- arg_scope == UNIT_FILE_SYSTEM ? "--system" : "--user");
+ if (need_daemon_reload(bus, n))
+ log_warning("Warning: Unit file of %s changed on disk, 'systemctl %s daemon-reload' recommended.",
+ n, arg_scope == UNIT_FILE_SYSTEM ? "--system" : "--user");
- if (!arg_no_block) {
- char *p;
-
- if (!(p = strdup(path))) {
- log_error("Failed to duplicate path.");
- r = -ENOMEM;
- goto finish;
- }
+ if (s) {
+ p = strdup(path);
+ if (!p)
+ return log_oom();
- if ((r = set_put(s, p)) < 0) {
- free(p);
+ r = set_put(s, p);
+ if (r < 0) {
log_error("Failed to add path to set.");
- goto finish;
+ return r;
}
- }
- /* When stopping unit check if we have some listening sockets active */
- if (streq(method, "StopUnit") && !arg_quiet)
- check_listening_sockets(bus, name);
-
- r = 0;
-
-finish:
- if (m)
- dbus_message_unref(m);
-
- if (reply)
- dbus_message_unref(reply);
+ p = NULL;
+ }
- return r;
+ return 0;
}
static enum action verb_to_action(const char *verb) {
return ACTION_SUSPEND;
else if (streq(verb, "hibernate"))
return ACTION_HIBERNATE;
+ else if (streq(verb, "hybrid-sleep"))
+ return ACTION_HYBRID_SLEEP;
else
return ACTION_INVALID;
}
[ACTION_DEFAULT] = SPECIAL_DEFAULT_TARGET,
[ACTION_EXIT] = SPECIAL_EXIT_TARGET,
[ACTION_SUSPEND] = SPECIAL_SUSPEND_TARGET,
- [ACTION_HIBERNATE] = SPECIAL_HIBERNATE_TARGET
+ [ACTION_HIBERNATE] = SPECIAL_HIBERNATE_TARGET,
+ [ACTION_HYBRID_SLEEP] = SPECIAL_HYBRID_SLEEP_TARGET
};
int r, ret = 0;
}
if (!arg_no_block) {
- if ((ret = enable_wait_for_jobs(bus)) < 0) {
+ ret = enable_wait_for_jobs(bus);
+ if (ret < 0) {
log_error("Could not watch jobs: %s", strerror(-ret));
goto finish;
}
- if (!(s = set_new(string_hash_func, string_compare_func))) {
- log_error("Failed to allocate set.");
- ret = -ENOMEM;
+ s = set_new(string_hash_func, string_compare_func);
+ if (!s) {
+ ret = log_oom();
goto finish;
}
}
if (one_name) {
- if ((ret = start_unit_one(bus, method, one_name, mode, &error, s)) <= 0)
- goto finish;
+ ret = start_unit_one(bus, method, one_name, mode, &error, s);
+ if (ret < 0)
+ ret = translate_bus_error_to_exit_status(ret, &error);
} else {
- STRV_FOREACH(name, args+1)
- if ((r = start_unit_one(bus, method, *name, mode, &error, s)) != 0) {
+ STRV_FOREACH(name, args+1) {
+ r = start_unit_one(bus, method, *name, mode, &error, s);
+ if (r < 0) {
ret = translate_bus_error_to_exit_status(r, &error);
dbus_error_free(&error);
}
+ }
}
- if (!arg_no_block)
- if ((r = wait_for_jobs(bus, s)) < 0) {
+ if (!arg_no_block) {
+ r = wait_for_jobs(bus, s);
+ if (r < 0) {
ret = r;
goto finish;
}
-finish:
- if (s)
- set_free_free(s);
+ /* When stopping units, warn if they can still be triggered by
+ * another active unit (socket, path, timer) */
+ if (!arg_quiet && streq(method, "StopUnit")) {
+ if (one_name)
+ check_triggering_units(bus, one_name);
+ else
+ STRV_FOREACH(name, args+1)
+ check_triggering_units(bus, *name);
+ }
+ }
+finish:
+ set_free_free(s);
dbus_error_free(&error);
return ret;
static int reboot_with_logind(DBusConnection *bus, enum action a) {
#ifdef HAVE_LOGIND
const char *method;
- DBusMessage *m = NULL, *reply = NULL;
- DBusError error;
dbus_bool_t interactive = true;
- int r;
- dbus_error_init(&error);
+ if (!bus)
+ return -EIO;
polkit_agent_open_if_enabled();
method = "Hibernate";
break;
+ case ACTION_HYBRID_SLEEP:
+ method = "HybridSleep";
+ break;
+
default:
return -EINVAL;
}
- m = dbus_message_new_method_call(
- "org.freedesktop.login1",
- "/org/freedesktop/login1",
- "org.freedesktop.login1.Manager",
- method);
- if (!m) {
- log_error("Could not allocate message.");
- r = -ENOMEM;
- goto finish;
- }
+ return bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.login1",
+ "/org/freedesktop/login1",
+ "org.freedesktop.login1.Manager",
+ method,
+ NULL,
+ NULL,
+ DBUS_TYPE_BOOLEAN, &interactive,
+ DBUS_TYPE_INVALID);
+#else
+ return -ENOSYS;
+#endif
+}
- if (!dbus_message_append_args(m,
- DBUS_TYPE_BOOLEAN, &interactive,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
+static int check_inhibitors(DBusConnection *bus, enum action a) {
+#ifdef HAVE_LOGIND
+ _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+ DBusMessageIter iter, sub, sub2;
+ int r;
+ unsigned c = 0;
+
+ if (!bus)
+ return 0;
+
+ if (arg_ignore_inhibitors || arg_force > 0)
+ return 0;
+
+ if (arg_when > 0)
+ return 0;
+
+ if (geteuid() == 0)
+ return 0;
+
+ if (!on_tty())
+ return 0;
+
+ r = bus_method_call_with_reply(
+ bus,
+ "org.freedesktop.login1",
+ "/org/freedesktop/login1",
+ "org.freedesktop.login1.Manager",
+ "ListInhibitors",
+ &reply,
+ NULL,
+ DBUS_TYPE_INVALID);
+ if (r < 0)
+ /* If logind is not around, then there are no inhibitors... */
+ return 0;
+
+ if (!dbus_message_iter_init(reply, &iter) ||
+ dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
+ dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {
+ log_error("Failed to parse reply.");
+ return -EIO;
}
- reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
- if (!reply) {
- if (error_is_no_service(&error)) {
- log_debug("Failed to issue method call: %s", bus_error_message(&error));
- r = -ENOENT;
- goto finish;
+ dbus_message_iter_recurse(&iter, &sub);
+ while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
+ const char *what, *who, *why, *mode;
+ uint32_t uid, pid;
+ _cleanup_strv_free_ char **sv = NULL;
+ _cleanup_free_ char *comm = NULL;
+
+ if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
+ log_error("Failed to parse reply.");
+ return -EIO;
}
- if (dbus_error_has_name(&error, DBUS_ERROR_ACCESS_DENIED)) {
- log_debug("Failed to issue method call: %s", bus_error_message(&error));
- r = -EACCES;
- goto finish;
+ dbus_message_iter_recurse(&sub, &sub2);
+
+ if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &what, true) < 0 ||
+ bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &who, true) < 0 ||
+ bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &why, true) < 0 ||
+ bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &mode, true) < 0 ||
+ bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &uid, true) < 0 ||
+ bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &pid, false) < 0) {
+ log_error("Failed to parse reply.");
+ return -EIO;
}
- log_info("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
- goto finish;
- }
+ if (!streq(mode, "block"))
+ goto next;
- r = 0;
+ sv = strv_split(what, ":");
+ if (!sv)
+ return log_oom();
-finish:
- if (m)
- dbus_message_unref(m);
+ if (!strv_contains(sv,
+ a == ACTION_HALT ||
+ a == ACTION_POWEROFF ||
+ a == ACTION_REBOOT ||
+ a == ACTION_KEXEC ? "shutdown" : "sleep"))
+ goto next;
- if (reply)
- dbus_message_unref(reply);
+ get_process_comm(pid, &comm);
+ log_warning("Operation inhibited by \"%s\" (PID %lu \"%s\", UID %lu), reason is \"%s\".", who, (unsigned long) pid, strna(comm), (unsigned long) uid, why);
+ c++;
- dbus_error_free(&error);
+ next:
+ dbus_message_iter_next(&sub);
+ }
- return r;
+ dbus_message_iter_recurse(&iter, &sub);
+
+ if (c <= 0)
+ return 0;
+
+ log_error("Please try again after closing inhibitors or ignore them with 'systemctl %s -i'.",
+ a == ACTION_HALT ? "halt" :
+ a == ACTION_POWEROFF ? "poweroff" :
+ a == ACTION_REBOOT ? "reboot" :
+ a == ACTION_KEXEC ? "kexec" :
+ a == ACTION_SUSPEND ? "suspend" :
+ a == ACTION_HIBERNATE ? "hibernate" : "hybrid-sleep");
+
+ return -EPERM;
#else
- return -ENOSYS;
+ return 0;
#endif
}
a = verb_to_action(args[0]);
+ r = check_inhibitors(bus, a);
+ if (r < 0)
+ return r;
+
if (arg_force >= 2 && geteuid() != 0) {
log_error("Must be root.");
return -EPERM;
(a == ACTION_POWEROFF ||
a == ACTION_REBOOT ||
a == ACTION_SUSPEND ||
- a == ACTION_HIBERNATE)) {
+ a == ACTION_HIBERNATE ||
+ a == ACTION_HYBRID_SLEEP)) {
r = reboot_with_logind(bus, a);
- if (r >= 0)
- return r;
- }
-
- r = start_unit(bus, args);
- if (r >= 0)
- warn_wall(a);
-
- return r;
-}
-
-static int check_unit(DBusConnection *bus, char **args) {
- DBusMessage *m = NULL, *reply = NULL;
- const char
- *interface = "org.freedesktop.systemd1.Unit",
- *property = "ActiveState";
- int r = 3; /* According to LSB: "program is not running" */
- DBusError error;
- char **name;
-
- assert(bus);
- assert(args);
-
- dbus_error_init(&error);
-
- STRV_FOREACH(name, args+1) {
- const char *path = NULL;
- const char *state;
- DBusMessageIter iter, sub;
-
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- "GetUnit"))) {
- log_error("Could not allocate message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, name,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
+ if (r >= 0)
+ return r;
+ }
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
+ r = start_unit(bus, args);
+ if (r >= 0)
+ warn_wall(a);
- /* Hmm, cannot figure out anything about this unit... */
- if (!arg_quiet)
- puts("unknown");
+ return r;
+}
- dbus_error_free(&error);
- dbus_message_unref(m);
- m = NULL;
- continue;
- }
+static int check_unit_active(DBusConnection *bus, char **args) {
+ const char * const check_states[] = {
+ "active",
+ "reloading",
+ NULL
+ };
- if (!dbus_message_get_args(reply, &error,
- DBUS_TYPE_OBJECT_PATH, &path,
- DBUS_TYPE_INVALID)) {
- log_error("Failed to parse reply: %s", bus_error_message(&error));
- r = -EIO;
- goto finish;
- }
+ char **name;
+ int r = 3; /* According to LSB: "program is not running" */
- dbus_message_unref(m);
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- path,
- "org.freedesktop.DBus.Properties",
- "Get"))) {
- log_error("Could not allocate message.");
- r = -ENOMEM;
- goto finish;
- }
+ assert(bus);
+ assert(args);
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, &interface,
- DBUS_TYPE_STRING, &property,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
+ STRV_FOREACH(name, args+1) {
+ int state;
- dbus_message_unref(reply);
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
- goto finish;
- }
+ state = check_one_unit(bus, *name, (char**) check_states, arg_quiet);
+ if (state < 0)
+ return state;
+ if (state > 0)
+ r = 0;
+ }
- if (!dbus_message_iter_init(reply, &iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
- log_error("Failed to parse reply.");
- r = -EIO;
- goto finish;
- }
+ return r;
+}
- dbus_message_iter_recurse(&iter, &sub);
+static int check_unit_failed(DBusConnection *bus, char **args) {
+ const char * const check_states[] = {
+ "failed",
+ NULL
+ };
- if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) {
- log_error("Failed to parse reply.");
- r = -EIO;
- goto finish;
- }
+ char **name;
+ int r = 1;
- dbus_message_iter_get_basic(&sub, &state);
+ assert(bus);
+ assert(args);
- if (!arg_quiet)
- puts(state);
+ STRV_FOREACH(name, args+1) {
+ int state;
- if (streq(state, "active") || streq(state, "reloading"))
+ state = check_one_unit(bus, *name, (char**) check_states, arg_quiet);
+ if (state < 0)
+ return state;
+ if (state > 0)
r = 0;
-
- dbus_message_unref(m);
- dbus_message_unref(reply);
- m = reply = NULL;
}
-finish:
- if (m)
- dbus_message_unref(m);
-
- if (reply)
- dbus_message_unref(reply);
-
- dbus_error_free(&error);
-
return r;
}
static int kill_unit(DBusConnection *bus, char **args) {
- DBusMessage *m = NULL;
- int r = 0;
- DBusError error;
char **name;
+ int r = 0;
assert(bus);
assert(args);
- dbus_error_init(&error);
-
if (!arg_kill_who)
arg_kill_who = "all";
- if (!arg_kill_mode)
- arg_kill_mode = streq(arg_kill_who, "all") ? "control-group" : "process";
-
STRV_FOREACH(name, args+1) {
- DBusMessage *reply;
-
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- "KillUnit"))) {
- log_error("Could not allocate message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, name,
- DBUS_TYPE_STRING, &arg_kill_who,
- DBUS_TYPE_STRING, &arg_kill_mode,
- DBUS_TYPE_INT32, &arg_signal,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- dbus_error_free(&error);
- r = -EIO;
- }
+ _cleanup_free_ char *n = NULL;
- dbus_message_unref(m);
+ n = unit_name_mangle(*name);
- if (reply)
- dbus_message_unref(reply);
- m = reply = NULL;
+ r = bus_method_call_with_reply(
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "KillUnit",
+ NULL,
+ NULL,
+ DBUS_TYPE_STRING, n ? &n : name,
+ DBUS_TYPE_STRING, &arg_kill_who,
+ DBUS_TYPE_INT32, &arg_signal,
+ DBUS_TYPE_INVALID);
+ if (r < 0)
+ return r;
}
-
-finish:
- if (m)
- dbus_message_unref(m);
-
- dbus_error_free(&error);
-
- return r;
+ return 0;
}
typedef struct ExecStatusInfo {
ExecStatusInfo *p;
const char *on, *off, *ss;
usec_t timestamp;
- char since1[FORMAT_TIMESTAMP_PRETTY_MAX], *s1;
+ char since1[FORMAT_TIMESTAMP_RELATIVE_MAX], *s1;
char since2[FORMAT_TIMESTAMP_MAX], *s2;
const char *path;
streq_ptr(i->active_state, "activating") ? i->inactive_exit_timestamp :
i->active_exit_timestamp;
- s1 = format_timestamp_pretty(since1, sizeof(since1), timestamp);
+ s1 = format_timestamp_relative(since1, sizeof(since1), timestamp);
s2 = format_timestamp(since2, sizeof(since2), timestamp);
if (s1)
printf("\n");
if (!i->condition_result && i->condition_timestamp > 0) {
- s1 = format_timestamp_pretty(since1, sizeof(since1), i->condition_timestamp);
+ s1 = format_timestamp_relative(since1, sizeof(since1), i->condition_timestamp);
s2 = format_timestamp(since2, sizeof(since2), i->condition_timestamp);
if (s1)
printf("\t Process: %u %s=%s ", p->pid, p->name, strna(t));
free(t);
- good = is_clean_exit_lsb(p->code, p->status);
+ good = is_clean_exit_lsb(p->code, p->status, NULL);
if (!good) {
on = ansi_highlight_red(true);
off = ansi_highlight_red(false);
if (i->status_text)
printf("\t Status: \"%s\"\n", i->status_text);
- if (i->default_control_group) {
+ if (i->default_control_group &&
+ (i->main_pid > 0 || i->control_pid > 0 || cg_is_empty_by_spec(i->default_control_group, false) == 0)) {
unsigned c;
printf("\t CGroup: %s\n", i->default_control_group);
}
if (i->id && arg_transport != TRANSPORT_SSH) {
+ int flags =
+ arg_all * OUTPUT_SHOW_ALL |
+ (!on_tty() || pager_have()) * OUTPUT_FULL_WIDTH |
+ on_tty() * OUTPUT_COLOR |
+ !arg_quiet * OUTPUT_WARN_CUTOFF;
+
printf("\n");
- show_journal_by_unit(i->id, arg_output, 0, i->inactive_exit_timestamp_monotonic, arg_lines, arg_all, arg_follow);
+ show_journal_by_unit(stdout,
+ i->id,
+ arg_output,
+ 0,
+ i->inactive_exit_timestamp_monotonic,
+ arg_lines,
+ flags);
}
if (i->need_daemon_reload)
if (e) {
page = strndup((*p) + 4, e - *p - 4);
if (!page) {
- log_error("Out of memory.");
+ log_oom();
return;
}
section = strndup(e + 1, *p + k - e - 2);
if (!section) {
free(page);
- log_error("Out of memory");
+ log_oom();
return;
}
wait_for_terminate(pid, NULL);
} else
- log_info("Can't show %s.", *p);
+ log_info("Can't show: %s", *p);
}
}
}
static int show_one(const char *verb, DBusConnection *bus, const char *path, bool show_properties, bool *new_line) {
- DBusMessage *m = NULL, *reply = NULL;
+ DBusMessage *reply = NULL;
const char *interface = "";
int r;
- DBusError error;
DBusMessageIter iter, sub, sub2, sub3;
UnitStatusInfo info;
ExecStatusInfo *p;
- assert(bus);
assert(path);
assert(new_line);
zero(info);
- dbus_error_init(&error);
-
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- path,
- "org.freedesktop.DBus.Properties",
- "GetAll"))) {
- log_error("Could not allocate message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, &interface,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
+ r = bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ path,
+ "org.freedesktop.DBus.Properties",
+ "GetAll",
+ &reply,
+ NULL,
+ DBUS_TYPE_STRING, &interface,
+ DBUS_TYPE_INVALID);
+ if (r)
goto finish;
- }
if (!dbus_message_iter_init(reply, &iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
}
finish:
- if (m)
- dbus_message_unref(m);
-
if (reply)
dbus_message_unref(reply);
- dbus_error_free(&error);
-
return r;
}
static int show_one_by_pid(const char *verb, DBusConnection *bus, uint32_t pid, bool *new_line) {
- DBusMessage *m = NULL, *reply = NULL;
+ DBusMessage *reply = NULL;
const char *path = NULL;
DBusError error;
int r;
dbus_error_init(&error);
- m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- "GetUnitByPID");
- if (!m) {
- log_error("Could not allocate message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!dbus_message_append_args(m,
- DBUS_TYPE_UINT32, &pid,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
-
- reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
- if (!reply) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
+ r = bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "GetUnitByPID",
+ &reply,
+ NULL,
+ DBUS_TYPE_UINT32, &pid,
+ DBUS_TYPE_INVALID);
+ if (r)
goto finish;
- }
if (!dbus_message_get_args(reply, &error,
DBUS_TYPE_OBJECT_PATH, &path,
r = show_one(verb, bus, path, false, new_line);
finish:
- if (m)
- dbus_message_unref(m);
-
if (reply)
dbus_message_unref(reply);
uint32_t id;
if (safe_atou32(*name, &id) < 0) {
-
+ char *p, *n;
/* Interpret as unit name */
- char *e, *p;
- e = bus_path_escape(*name);
- if (!e)
- return -ENOMEM;
- p = strappend("/org/freedesktop/systemd1/unit/", e);
- free(e);
+ n = unit_name_mangle(*name);
+ p = unit_dbus_path_from_name(n ? n : *name);
+ free(n);
if (!p)
- return -ENOMEM;
+ return log_oom();
r = show_one(args[0], bus, p, show_properties, &new_line);
free(p);
char *p;
if (asprintf(&p, "/org/freedesktop/systemd1/job/%u", id) < 0)
- return -ENOMEM;
+ return log_oom();
r = show_one(args[0], bus, p, show_properties, &new_line);
free(p);
}
static int dump(DBusConnection *bus, char **args) {
- DBusMessage *m = NULL, *reply = NULL;
+ DBusMessage *reply = NULL;
DBusError error;
int r;
const char *text;
pager_open_if_enabled();
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- "Dump"))) {
- log_error("Could not allocate message.");
- return -ENOMEM;
- }
-
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
+ r = bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "Dump",
+ &reply,
+ NULL,
+ DBUS_TYPE_INVALID);
+ if (r)
goto finish;
- }
if (!dbus_message_get_args(reply, &error,
DBUS_TYPE_STRING, &text,
fputs(text, stdout);
- r = 0;
-
finish:
- if (m)
- dbus_message_unref(m);
-
if (reply)
dbus_message_unref(reply);
}
static int snapshot(DBusConnection *bus, char **args) {
- DBusMessage *m = NULL, *reply = NULL;
+ _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
DBusError error;
int r;
- const char *name = "", *path, *id;
dbus_bool_t cleanup = FALSE;
DBusMessageIter iter, sub;
const char
+ *name = "", *path, *id,
*interface = "org.freedesktop.systemd1.Unit",
*property = "Id";
+ _cleanup_free_ char *n = NULL;
dbus_error_init(&error);
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- "CreateSnapshot"))) {
- log_error("Could not allocate message.");
- return -ENOMEM;
- }
-
- if (strv_length(args) > 1)
+ if (strv_length(args) > 1) {
name = args[1];
-
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_BOOLEAN, &cleanup,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
+ n = unit_name_mangle(name);
}
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
+ r = bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "CreateSnapshot",
+ &reply,
+ NULL,
+ DBUS_TYPE_STRING, n ? (const char**) &n : &name,
+ DBUS_TYPE_BOOLEAN, &cleanup,
+ DBUS_TYPE_INVALID);
+ if (r < 0)
goto finish;
- }
if (!dbus_message_get_args(reply, &error,
DBUS_TYPE_OBJECT_PATH, &path,
goto finish;
}
- dbus_message_unref(m);
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- path,
- "org.freedesktop.DBus.Properties",
- "Get"))) {
- log_error("Could not allocate message.");
- return -ENOMEM;
- }
-
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, &interface,
- DBUS_TYPE_STRING, &property,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
-
dbus_message_unref(reply);
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
+ reply = NULL;
+
+ r = bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ path,
+ "org.freedesktop.DBus.Properties",
+ "Get",
+ &reply,
+ NULL,
+ DBUS_TYPE_STRING, &interface,
+ DBUS_TYPE_STRING, &property,
+ DBUS_TYPE_INVALID);
+ if (r < 0)
goto finish;
- }
if (!dbus_message_iter_init(reply, &iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
if (!arg_quiet)
puts(id);
- r = 0;
finish:
- if (m)
- dbus_message_unref(m);
-
- if (reply)
- dbus_message_unref(reply);
-
dbus_error_free(&error);
return r;
}
static int delete_snapshot(DBusConnection *bus, char **args) {
- DBusMessage *m = NULL, *reply = NULL;
- int r;
- DBusError error;
char **name;
- assert(bus);
assert(args);
- dbus_error_init(&error);
-
STRV_FOREACH(name, args+1) {
- const char *path = NULL;
-
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- "GetUnit"))) {
- log_error("Could not allocate message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, name,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
- goto finish;
- }
-
- if (!dbus_message_get_args(reply, &error,
- DBUS_TYPE_OBJECT_PATH, &path,
- DBUS_TYPE_INVALID)) {
- log_error("Failed to parse reply: %s", bus_error_message(&error));
- r = -EIO;
- goto finish;
- }
-
- dbus_message_unref(m);
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- path,
- "org.freedesktop.systemd1.Snapshot",
- "Remove"))) {
- log_error("Could not allocate message.");
- r = -ENOMEM;
- goto finish;
- }
-
- dbus_message_unref(reply);
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
- goto finish;
- }
-
- dbus_message_unref(m);
- dbus_message_unref(reply);
- m = reply = NULL;
- }
-
- r = 0;
-
-finish:
- if (m)
- dbus_message_unref(m);
-
- if (reply)
- dbus_message_unref(reply);
+ _cleanup_free_ char *n = NULL;
+ int r;
- dbus_error_free(&error);
+ n = unit_name_mangle(*name);
+ r = bus_method_call_with_reply(
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "RemoveSnapshot",
+ NULL,
+ NULL,
+ DBUS_TYPE_STRING, n ? &n : name,
+ DBUS_TYPE_INVALID);
+ if (r < 0)
+ return r;
+ }
- return r;
+ return 0;
}
static int daemon_reload(DBusConnection *bus, char **args) {
- DBusMessage *m = NULL, *reply = NULL;
- DBusError error;
int r;
const char *method;
-
- dbus_error_init(&error);
+ DBusError error;
if (arg_action == ACTION_RELOAD)
method = "Reload";
/* "daemon-reload" */ "Reload";
}
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- method))) {
- log_error("Could not allocate message.");
- return -ENOMEM;
- }
-
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
-
- if (arg_action != ACTION_SYSTEMCTL && error_is_no_service(&error)) {
- /* There's always a fallback possible for
- * legacy actions. */
- r = -EADDRNOTAVAIL;
- goto finish;
- }
-
- if (streq(method, "Reexecute") && dbus_error_has_name(&error, DBUS_ERROR_NO_REPLY)) {
- /* On reexecution, we expect a disconnect, not
- * a reply */
- r = 0;
- goto finish;
- }
-
+ r = bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ method,
+ NULL,
+ &error,
+ DBUS_TYPE_INVALID);
+
+ if (r == -ENOENT && arg_action != ACTION_SYSTEMCTL)
+ /* There's always a fallback possible for
+ * legacy actions. */
+ r = -EADDRNOTAVAIL;
+ else if (r == -ETIMEDOUT && streq(method, "Reexecute"))
+ /* On reexecution, we expect a disconnect, not
+ * a reply */
+ r = 0;
+ else if (r)
log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
- goto finish;
- }
-
- r = 0;
-
-finish:
- if (m)
- dbus_message_unref(m);
-
- if (reply)
- dbus_message_unref(reply);
-
dbus_error_free(&error);
return r;
}
static int reset_failed(DBusConnection *bus, char **args) {
- DBusMessage *m = NULL;
- int r;
- DBusError error;
- char **name;
-
- assert(bus);
- dbus_error_init(&error);
+ int r = 0;
+ char **name, *n;
if (strv_length(args) <= 1)
return daemon_reload(bus, args);
STRV_FOREACH(name, args+1) {
- DBusMessage *reply;
-
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- "ResetFailedUnit"))) {
- log_error("Could not allocate message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, name,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
+ n = unit_name_mangle(*name);
+ r = bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "ResetFailedUnit",
+ NULL,
+ NULL,
+ DBUS_TYPE_STRING, n ? &n : name,
+ DBUS_TYPE_INVALID);
+ free(n);
+ if (r)
goto finish;
- }
-
- dbus_message_unref(m);
- dbus_message_unref(reply);
- m = reply = NULL;
}
- r = 0;
-
finish:
- if (m)
- dbus_message_unref(m);
-
- dbus_error_free(&error);
-
return r;
}
static int show_enviroment(DBusConnection *bus, char **args) {
- DBusMessage *m = NULL, *reply = NULL;
- DBusError error;
+ DBusMessage *reply = NULL;
DBusMessageIter iter, sub, sub2;
int r;
const char
*interface = "org.freedesktop.systemd1.Manager",
*property = "Environment";
- dbus_error_init(&error);
-
pager_open_if_enabled();
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.DBus.Properties",
- "Get"))) {
- log_error("Could not allocate message.");
- return -ENOMEM;
- }
-
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, &interface,
- DBUS_TYPE_STRING, &property,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
+ r = bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.DBus.Properties",
+ "Get",
+ &reply,
+ NULL,
+ DBUS_TYPE_STRING, &interface,
+ DBUS_TYPE_STRING, &property,
+ DBUS_TYPE_INVALID);
+ if (r)
goto finish;
- }
if (!dbus_message_iter_init(reply, &iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
r = 0;
finish:
- if (m)
- dbus_message_unref(m);
-
if (reply)
dbus_message_unref(reply);
- dbus_error_free(&error);
-
return r;
}
static int switch_root(DBusConnection *bus, char **args) {
- DBusMessage *m = NULL, *reply = NULL;
unsigned l;
- const char *root, *init;
- DBusError error;
- int r;
-
- dbus_error_init(&error);
+ const char *root;
+ _cleanup_free_ char *init = NULL;
l = strv_length(args);
if (l < 2 || l > 3) {
}
root = args[1];
- init = l >= 3 ? args[2] : "";
-
- m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- "SwitchRoot");
- if (!m) {
- log_error("Could not allocate message.");
- return -ENOMEM;
- }
-
- if (!dbus_message_append_args(
- m,
- DBUS_TYPE_STRING, &root,
- DBUS_TYPE_STRING, &init,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
- reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
- if (!reply) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
- goto finish;
- }
+ if (l >= 3)
+ init = strdup(args[2]);
+ else {
+ parse_env_file("/proc/cmdline", WHITESPACE,
+ "init", &init,
+ NULL);
- r = 0;
+ if (!init)
+ init = strdup("");
-finish:
- if (m)
- dbus_message_unref(m);
+ if (!init)
+ return log_oom();
- if (reply)
- dbus_message_unref(reply);
+ }
- dbus_error_free(&error);
+ log_debug("switching root - root: %s; init: %s", root, init);
- return r;
+ return bus_method_call_with_reply (
+ bus,
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "SwitchRoot",
+ NULL,
+ NULL,
+ DBUS_TYPE_STRING, &root,
+ DBUS_TYPE_STRING, &init,
+ DBUS_TYPE_INVALID);
}
static int set_environment(DBusConnection *bus, char **args) {
- DBusMessage *m = NULL, *reply = NULL;
+ _cleanup_dbus_message_unref_ DBusMessage *m = NULL, *reply = NULL;
DBusError error;
- int r;
const char *method;
- DBusMessageIter iter, sub;
- char **name;
+ DBusMessageIter iter;
+ int r;
+
+ assert(bus);
+ assert(args);
dbus_error_init(&error);
? "SetEnvironment"
: "UnsetEnvironment";
- if (!(m = dbus_message_new_method_call(
- "org.freedesktop.systemd1",
- "/org/freedesktop/systemd1",
- "org.freedesktop.systemd1.Manager",
- method))) {
-
- log_error("Could not allocate message.");
- return -ENOMEM;
- }
+ m = dbus_message_new_method_call(
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ method);
+ if (!m)
+ return log_oom();
dbus_message_iter_init_append(m, &iter);
- if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
-
- STRV_FOREACH(name, args+1)
- if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, name)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
-
- if (!dbus_message_iter_close_container(&iter, &sub)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
+ r = bus_append_strv_iter(&iter, args + 1);
+ if (r < 0)
+ return log_oom();
- if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
+ reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
+ if (!reply) {
log_error("Failed to issue method call: %s", bus_error_message(&error));
r = -EIO;
goto finish;
r = 0;
finish:
- if (m)
- dbus_message_unref(m);
-
- if (reply)
- dbus_message_unref(reply);
-
dbus_error_free(&error);
-
return r;
}
static int enable_sysv_units(char **args) {
int r = 0;
-#if defined (HAVE_SYSV_COMPAT) && (defined(TARGET_FEDORA) || defined(TARGET_MANDRIVA) || defined(TARGET_SUSE) || defined(TARGET_MEEGO) || defined(TARGET_ALTLINUX) || defined(TARGET_MAGEIA))
+#if defined(HAVE_SYSV_COMPAT) && defined(HAVE_CHKCONFIG)
const char *verb = args[0];
unsigned f = 1, t = 1;
LookupPaths paths;
* afterwards only the native units remain */
zero(paths);
- r = lookup_paths_init(&paths, MANAGER_SYSTEM, false, NULL, NULL, NULL);
+ r = lookup_paths_init(&paths, SYSTEMD_SYSTEM, false, NULL, NULL, NULL);
if (r < 0)
return r;
asprintf(&p, "%s/%s", *k, name);
if (!p) {
- log_error("No memory");
- r = -ENOMEM;
+ r = log_oom();
goto finish;
}
else
asprintf(&p, SYSTEM_SYSVINIT_PATH "/%s", name);
if (!p) {
- log_error("No memory");
- r = -ENOMEM;
+ r = log_oom();
goto finish;
}
l = strv_join((char**)argv, " ");
if (!l) {
- log_error("No memory.");
free(q);
free(p);
- r = -ENOMEM;
+ r = log_oom();
goto finish;
}
return r;
}
+static int mangle_names(char **original_names, char ***mangled_names) {
+ char **i, **l, **name;
+
+ l = new(char*, strv_length(original_names) + 1);
+ if (!l)
+ return log_oom();
+
+ i = l;
+ STRV_FOREACH(name, original_names) {
+
+ /* When enabling units qualified path names are OK,
+ * too, hence allow them explicitly. */
+
+ if (is_path(*name))
+ *i = strdup(*name);
+ else
+ *i = unit_name_mangle(*name);
+
+ if (!*i) {
+ strv_free(l);
+ return log_oom();
+ }
+
+ i++;
+ }
+
+ *i = NULL;
+ *mangled_names = l;
+
+ return 0;
+}
+
static int enable_unit(DBusConnection *bus, char **args) {
const char *verb = args[0];
UnitFileChange *changes = NULL;
DBusMessage *m = NULL, *reply = NULL;
int r;
DBusError error;
+ char **mangled_names = NULL;
r = enable_sysv_units(args);
if (r < 0)
}
}
+ r = 0;
} else {
const char *method;
bool send_force = true, expect_carries_install_info = false;
"org.freedesktop.systemd1.Manager",
method);
if (!m) {
- log_error("Out of memory");
- r = -ENOMEM;
+ r = log_oom();
goto finish;
}
dbus_message_iter_init_append(m, &iter);
- r = bus_append_strv_iter(&iter, args+1);
+ r = mangle_names(args+1, &mangled_names);
+ if(r < 0)
+ goto finish;
+
+ r = bus_append_strv_iter(&iter, mangled_names);
if (r < 0) {
log_error("Failed to append unit files.");
goto finish;
}
if (carries_install_info == 0)
- log_warning("Warning: unit files do not carry install information. No operation executed.");
+ log_warning(
+"The unit files have no [Install] section. They are not meant to be enabled\n"
+"using systemctl.\n"
+"Possible reasons for having this kind of units are:\n"
+"1) A unit may be statically enabled by being symlinked from another unit's\n"
+" .wants/ or .requires/ directory.\n"
+"2) A unit's purpose may be to act as a helper for some other unit which has\n"
+" a requirement dependency on it.\n"
+"3) A unit may be started when needed via activation (socket, path, timer,\n"
+" D-Bus, udev, scripted systemctl call, ...).\n");
finish:
if (m)
unit_file_changes_free(changes, n_changes);
dbus_error_free(&error);
+
+ strv_free(mangled_names);
+
return r;
}
static int unit_is_enabled(DBusConnection *bus, char **args) {
DBusError error;
int r;
- DBusMessage *m = NULL, *reply = NULL;
+ DBusMessage *reply = NULL;
bool enabled;
char **name;
STRV_FOREACH(name, args+1) {
const char *s;
- m = dbus_message_new_method_call(
+ r = bus_method_call_with_reply (
+ bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- "GetUnitFileState");
- if (!m) {
- log_error("Out of memory");
- r = -ENOMEM;
+ "GetUnitFileState",
+ &reply,
+ NULL,
+ DBUS_TYPE_STRING, name,
+ DBUS_TYPE_INVALID);
+ if (r)
goto finish;
- }
-
- if (!dbus_message_append_args(m,
- DBUS_TYPE_STRING, name,
- DBUS_TYPE_INVALID)) {
- log_error("Could not append arguments to message.");
- r = -ENOMEM;
- goto finish;
- }
-
- reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
- if (!reply) {
- log_error("Failed to issue method call: %s", bus_error_message(&error));
- r = -EIO;
- goto finish;
- }
if (!dbus_message_get_args(reply, &error,
DBUS_TYPE_STRING, &s,
goto finish;
}
- dbus_message_unref(m);
dbus_message_unref(reply);
- m = reply = NULL;
+ reply = NULL;
if (streq(s, "enabled") ||
streq(s, "enabled-runtime") ||
r = enabled ? 0 : 1;
finish:
- if (m)
- dbus_message_unref(m);
-
if (reply)
dbus_message_unref(reply);
" pending\n"
" --ignore-dependencies\n"
" When queueing a new job, ignore all its dependencies\n"
+ " -i --ignore-inhibitors\n"
+ " When shutting down or sleeping, ignore inhibitors\n"
" --kill-who=WHO Who to send signal to\n"
" -s --signal=SIGNAL Which signal to send\n"
" -H --host=[USER@]HOST\n"
" --root=PATH Enable unit files in the specified root directory\n"
" --runtime Enable unit files only temporarily until next reboot\n"
" -n --lines=INTEGER Journal entries to show\n"
- " --follow Follow journal\n"
" -o --output=STRING Change journal output mode (short, short-monotonic,\n"
- " verbose, export, json, cat)\n\n"
+ " verbose, export, json, json-pretty, json-sse, cat)\n\n"
"Unit Commands:\n"
" list-units List loaded units\n"
" start [NAME...] Start (activate) one or more units\n"
" reload [NAME...] Reload one or more units\n"
" restart [NAME...] Start or restart one or more units\n"
" try-restart [NAME...] Restart one or more units if active\n"
- " reload-or-restart [NAME...] Reload one or more units is possible,\n"
+ " reload-or-restart [NAME...] Reload one or more units if possible,\n"
" otherwise start or restart\n"
- " reload-or-try-restart [NAME...] Reload one or more units is possible,\n"
+ " reload-or-try-restart [NAME...] Reload one or more units if possible,\n"
" otherwise restart if active\n"
" isolate [NAME] Start one unit and stop all others\n"
" kill [NAME...] Send signal to processes of a unit\n"
" is-active [NAME...] Check whether units are active\n"
+ " is-failed [NAME...] Check whether units are failed\n"
" status [NAME...|PID...] Show runtime status of one or more units\n"
" show [NAME...|JOB...] Show properties of one or more\n"
" units/jobs or the manager\n"
" exit Request user instance exit\n"
" switch-root [ROOT] [INIT] Change to a different root file system\n"
" suspend Suspend the system\n"
- " hibernate Hibernate the system\n",
+ " hibernate Hibernate the system\n"
+ " hybrid-sleep Hibernate and suspend the system\n",
program_invocation_short_name);
return 0;
" -f --force Force immediate halt/power-off/reboot\n"
" -w --wtmp-only Don't halt/power-off/reboot, just write wtmp record\n"
" -d --no-wtmp Don't write wtmp record\n"
- " -n --no-sync Don't sync before halt/power-off/reboot\n"
" --no-wall Don't send wall message before halt/power-off/reboot\n",
program_invocation_short_name,
arg_action == ACTION_REBOOT ? "Reboot" :
return 0;
}
+static int help_types(void) {
+ int i;
+
+ puts("Available unit types:");
+ for(i = UNIT_SERVICE; i < _UNIT_TYPE_MAX; i++)
+ if (unit_type_table[i])
+ puts(unit_type_table[i]);
+
+ puts("\nAvailable unit load states: ");
+ for(i = UNIT_STUB; i < _UNIT_LOAD_STATE_MAX; i++)
+ if (unit_type_table[i])
+ puts(unit_load_state_table[i]);
+
+ return 0;
+}
+
static int systemctl_parse_argv(int argc, char *argv[]) {
enum {
ARG_ROOT,
ARG_FULL,
ARG_NO_RELOAD,
- ARG_KILL_MODE,
ARG_KILL_WHO,
ARG_NO_ASK_PASSWORD,
ARG_FAILED,
ARG_RUNTIME,
- ARG_FOLLOW,
ARG_FORCE
};
{ "full", no_argument, NULL, ARG_FULL },
{ "fail", no_argument, NULL, ARG_FAIL },
{ "ignore-dependencies", no_argument, NULL, ARG_IGNORE_DEPENDENCIES },
+ { "ignore-inhibitors", no_argument, NULL, 'i' },
{ "user", no_argument, NULL, ARG_USER },
{ "system", no_argument, NULL, ARG_SYSTEM },
{ "global", no_argument, NULL, ARG_GLOBAL },
{ "root", required_argument, NULL, ARG_ROOT },
{ "force", no_argument, NULL, ARG_FORCE },
{ "no-reload", no_argument, NULL, ARG_NO_RELOAD },
- { "kill-mode", required_argument, NULL, ARG_KILL_MODE }, /* undocumented on purpose */
{ "kill-who", required_argument, NULL, ARG_KILL_WHO },
{ "signal", required_argument, NULL, 's' },
{ "no-ask-password", no_argument, NULL, ARG_NO_ASK_PASSWORD },
{ "privileged",no_argument, NULL, 'P' },
{ "runtime", no_argument, NULL, ARG_RUNTIME },
{ "lines", required_argument, NULL, 'n' },
- { "follow", no_argument, NULL, ARG_FOLLOW },
{ "output", required_argument, NULL, 'o' },
{ NULL, 0, NULL, 0 }
};
assert(argc >= 0);
assert(argv);
- while ((c = getopt_long(argc, argv, "ht:p:aqfs:H:Pn:o:", options, NULL)) >= 0) {
+ while ((c = getopt_long(argc, argv, "ht:p:aqfs:H:Pn:o:i", options, NULL)) >= 0) {
switch (c) {
case ARG_VERSION:
puts(PACKAGE_STRING);
- puts(DISTRIBUTION);
puts(SYSTEMD_FEATURES);
return 0;
case 't':
- arg_type = optarg;
- break;
+ if (streq(optarg, "help")) {
+ help_types();
+ return 0;
+ }
+ if (unit_type_from_string(optarg) >= 0) {
+ arg_type = optarg;
+ break;
+ }
+ if (unit_load_state_from_string(optarg) >= 0) {
+ arg_load_state = optarg;
+ break;
+ }
+ log_error("Unkown unit type or load state '%s'.",
+ optarg);
+ log_info("Use -t help to see a list of allowed values.");
+ return -EINVAL;
case 'p': {
char **l;
arg_force ++;
break;
- case ARG_FOLLOW:
- arg_follow = true;
- break;
-
case 'f':
- /* -f is short for both --follow and --force! */
arg_force ++;
- arg_follow = true;
break;
case ARG_NO_RELOAD:
arg_kill_who = optarg;
break;
- case ARG_KILL_MODE:
- arg_kill_mode = optarg;
- break;
-
case 's':
if ((arg_signal = signal_from_string_try_harder(optarg)) < 0) {
log_error("Failed to parse signal string %s.", optarg);
}
break;
+ case 'i':
+ arg_ignore_inhibitors = true;
+ break;
+
case '?':
return -EINVAL;
default:
- log_error("Unknown option code %c", c);
+ log_error("Unknown option code '%c'.", c);
return -EINVAL;
}
}
{ "force", no_argument, NULL, 'f' },
{ "wtmp-only", no_argument, NULL, 'w' },
{ "no-wtmp", no_argument, NULL, 'd' },
- { "no-sync", no_argument, NULL, 'n' },
{ "no-wall", no_argument, NULL, ARG_NO_WALL },
{ NULL, 0, NULL, 0 }
};
arg_no_wtmp = true;
break;
- case 'n':
- arg_no_sync = true;
- break;
-
case ARG_NO_WALL:
arg_no_wall = true;
break;
case 'i':
case 'h':
+ case 'n':
/* Compatibility nops */
break;
return -EINVAL;
default:
- log_error("Unknown option code %c", c);
+ log_error("Unknown option code '%c'.", c);
return -EINVAL;
}
}
return -EINVAL;
default:
- log_error("Unknown option code %c", c);
+ log_error("Unknown option code '%c'.", c);
return -EINVAL;
}
}
- if (argc > optind) {
+ if (argc > optind && arg_action != ACTION_CANCEL_SHUTDOWN) {
r = parse_time_spec(argv[optind], &arg_when);
if (r < 0) {
log_error("Failed to parse time specification: %s", argv[optind]);
} else
arg_when = now(CLOCK_REALTIME) + USEC_PER_MINUTE;
- /* We skip the time argument */
- if (argc > optind + 1)
+ if (argc > optind && arg_action == ACTION_CANCEL_SHUTDOWN)
+ /* No time argument for shutdown cancel */
+ arg_wall = argv + optind;
+ else if (argc > optind + 1)
+ /* We skip the time argument */
arg_wall = argv + optind + 1;
optind = argc;
return -EINVAL;
default:
- log_error("Unknown option code %c", c);
+ log_error("Unknown option code '%c'.", c);
return -EINVAL;
}
}
break;
if (i >= ELEMENTSOF(table)) {
- log_error("Unknown command %s.", argv[optind]);
+ log_error("Unknown command '%s'.", argv[optind]);
return -EINVAL;
}
return -EINVAL;
default:
- log_error("Unknown option code %c", c);
+ log_error("Unknown option code '%c'.", c);
return -EINVAL;
}
}
if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
- if (error_is_no_service(&error)) {
+ if (bus_error_is_no_service(&error)) {
r = -EADDRNOTAVAIL;
goto finish;
}
{ "condrestart", MORE, 2, start_unit }, /* For compatibility with RH */
{ "isolate", EQUAL, 2, start_unit },
{ "kill", MORE, 2, kill_unit },
- { "is-active", MORE, 2, check_unit },
- { "check", MORE, 2, check_unit },
+ { "is-active", MORE, 2, check_unit_active },
+ { "check", MORE, 2, check_unit_active },
+ { "is-failed", MORE, 2, check_unit_failed },
{ "show", MORE, 1, show },
{ "status", MORE, 2, show },
{ "help", MORE, 2, show },
{ "kexec", EQUAL, 1, start_special },
{ "suspend", EQUAL, 1, start_special },
{ "hibernate", EQUAL, 1, start_special },
+ { "hybrid-sleep", EQUAL, 1, start_special },
{ "default", EQUAL, 1, start_special },
{ "rescue", EQUAL, 1, start_special },
{ "emergency", EQUAL, 1, start_special },
break;
if (i >= ELEMENTSOF(verbs)) {
- log_error("Unknown operation %s", argv[optind]);
+ log_error("Unknown operation '%s'.", argv[optind]);
return -EINVAL;
}
}
return 0;
}
-static void halt_now(enum action a) {
+static _noreturn_ void halt_now(enum action a) {
/* Make sure C-A-D is handled by the kernel from this
* point on... */
static int halt_main(DBusConnection *bus) {
int r;
+ r = check_inhibitors(bus, arg_action);
+ if (r < 0)
+ return r;
+
if (geteuid() != 0) {
/* Try logind if we are a normal user and no special
* mode applies. Maybe PolicyKit allows us to shutdown
if (arg_when <= 0 &&
!arg_dry &&
- !arg_force &&
+ arg_force <= 0 &&
(arg_action == ACTION_POWEROFF ||
arg_action == ACTION_REBOOT)) {
r = reboot_with_logind(bus, arg_action);
}
}
- if (!arg_no_sync)
- sync();
-
if (arg_dry)
return 0;
dbus_error_init(&error);
+ setlocale(LC_ALL, "");
log_parse_environment();
log_open();
r = reload_with_fallback(bus);
break;
- case ACTION_CANCEL_SHUTDOWN:
- r = send_shutdownd(0, 0, false, false, NULL);
+ case ACTION_CANCEL_SHUTDOWN: {
+ char *m = NULL;
+
+ if (arg_wall) {
+ m = strv_join(arg_wall, " ");
+ if (!m) {
+ retval = EXIT_FAILURE;
+ goto finish;
+ }
+ }
+ r = send_shutdownd(arg_when, SD_SHUTDOWN_NONE, false, !arg_no_wall, m);
+ if (r < 0)
+ log_warning("Failed to talk to shutdownd, shutdown hasn't been cancelled: %s", strerror(-r));
+ free(m);
break;
+ }
case ACTION_INVALID:
case ACTION_RUNLEVEL:
~ianmdlvl / elogind.git / blobdiff