X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fsystemctl.c;h=555c171b0e4831a0bca47be23c482645fe360292;hp=32974aecceced7b1e45fa188590c3082f9672ab8;hb=b4f27ccc6339dff34f0293b91b2047027a211809;hpb=35d2e7ec19f8d3960a14dc04642060ccee3faa43 diff --git a/src/systemctl.c b/src/systemctl.c index 32974aecc..555c171b0 100644 --- a/src/systemctl.c +++ b/src/systemctl.c @@ -1,4 +1,4 @@ -/*-*- Mode: C; c-basic-offset: 8 -*-*/ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ /*** This file is part of systemd. @@ -30,6 +30,8 @@ #include #include #include +#include +#include #include @@ -45,26 +47,42 @@ #include "cgroup-show.h" #include "cgroup-util.h" #include "list.h" +#include "path-lookup.h" +#include "conf-parser.h" +#include "sd-daemon.h" +#include "shutdownd.h" +#include "exit-status.h" +#include "bus-errors.h" +#include "build.h" +#include "unit-name.h" static const char *arg_type = NULL; -static const char *arg_property = NULL; +static char **arg_property = NULL; static bool arg_all = false; static bool arg_fail = false; static bool arg_session = false; -static bool arg_no_block = false; +static bool arg_global = false; static bool arg_immediate = false; +static bool arg_no_block = 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_dry = false; static bool arg_quiet = false; +static bool arg_full = false; +static bool arg_force = false; +static bool arg_defaults = false; static char **arg_wall = NULL; -enum action { +static usec_t arg_when = 0; +static enum action { ACTION_INVALID, ACTION_SYSTEMCTL, ACTION_HALT, ACTION_POWEROFF, ACTION_REBOOT, + ACTION_KEXEC, + ACTION_EXIT, ACTION_RUNLEVEL2, ACTION_RUNLEVEL3, ACTION_RUNLEVEL4, @@ -75,13 +93,45 @@ enum action { ACTION_RELOAD, ACTION_REEXEC, ACTION_RUNLEVEL, + ACTION_CANCEL_SHUTDOWN, _ACTION_MAX } arg_action = ACTION_SYSTEMCTL; +static enum dot { + DOT_ALL, + DOT_ORDER, + DOT_REQUIRE +} arg_dot = DOT_ALL; static bool private_bus = false; -static bool error_is_no_service(DBusError *error) { +static int daemon_reload(DBusConnection *bus, char **args, unsigned n); + +static bool on_tty(void) { + static int t = -1; + + if (_unlikely_(t < 0)) + t = isatty(STDOUT_FILENO) > 0; + + return t; +} + +static const char *ansi_highlight(bool b) { + + if (!on_tty()) + return ""; + return b ? ANSI_HIGHLIGHT_ON : ANSI_HIGHLIGHT_OFF; +} + +static const char *ansi_highlight_green(bool b) { + + if (!on_tty()) + return ""; + + return b ? ANSI_HIGHLIGHT_GREEN_ON : ANSI_HIGHLIGHT_OFF; +} + +static bool error_is_no_service(const DBusError *error) { assert(error); if (!dbus_error_is_set(error)) @@ -96,6 +146,34 @@ static bool error_is_no_service(DBusError *error) { return startswith(error->name, "org.freedesktop.DBus.Error.Spawn."); } +static int translate_bus_error_to_exit_status(int r, const DBusError *error) { + assert(error); + + if (!dbus_error_is_set(error)) + return r; + + if (dbus_error_has_name(error, DBUS_ERROR_ACCESS_DENIED) || + dbus_error_has_name(error, BUS_ERROR_ONLY_BY_DEPENDENCY) || + dbus_error_has_name(error, BUS_ERROR_NO_ISOLATION) || + dbus_error_has_name(error, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE)) + return EXIT_NOPERMISSION; + + if (dbus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT)) + return EXIT_NOTINSTALLED; + + if (dbus_error_has_name(error, BUS_ERROR_JOB_TYPE_NOT_APPLICABLE) || + dbus_error_has_name(error, BUS_ERROR_NOT_SUPPORTED)) + return EXIT_NOTIMPLEMENTED; + + if (dbus_error_has_name(error, BUS_ERROR_LOAD_FAILED)) + return EXIT_NOTCONFIGURED; + + if (r != 0) + return r; + + return EXIT_FAILURE; +} + static int bus_iter_get_basic_and_next(DBusMessageIter *iter, int type, void *data, bool next) { assert(iter); @@ -117,6 +195,7 @@ static void warn_wall(enum action action) { [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!" }; @@ -147,12 +226,145 @@ static void warn_wall(enum action action) { utmp_wall(table[action]); } +struct unit_info { + const char *id; + const char *description; + const char *load_state; + const char *active_state; + const char *sub_state; + const char *following; + const char *unit_path; + uint32_t job_id; + const char *job_type; + const char *job_path; +}; + +static int compare_unit_info(const void *a, const void *b) { + const char *d1, *d2; + const struct unit_info *u = a, *v = b; + + d1 = strrchr(u->id, '.'); + d2 = strrchr(v->id, '.'); + + if (d1 && d2) { + int r; + + if ((r = strcasecmp(d1, d2)) != 0) + return r; + } + + return strcasecmp(u->id, v->id); +} + +static bool output_show_job(const struct unit_info *u) { + const char *dot; + + 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); +} + +static void output_units_list(const struct unit_info *unit_infos, unsigned c) { + unsigned active_len, sub_len, job_len; + const struct unit_info *u; + + active_len = sizeof("ACTIVE")-1; + sub_len = sizeof("SUB")-1; + job_len = sizeof("JOB")-1; + + for (u = unit_infos; u < unit_infos + c; u++) { + if (!output_show_job(u)) + continue; + + active_len = MAX(active_len, strlen(u->active_state)); + sub_len = MAX(sub_len, strlen(u->sub_state)); + if (u->job_id != 0) + job_len = MAX(job_len, strlen(u->job_type)); + } + + if (on_tty()) { + printf("%-25s %-6s %-*s %-*s %-*s", "UNIT", "LOAD", + active_len, "ACTIVE", sub_len, "SUB", job_len, "JOB"); + if (columns() >= 80+12 || arg_full) + printf(" %s\n", "DESCRIPTION"); + else + printf("\n"); + } + + for (u = unit_infos; u < unit_infos + c; u++) { + char *e; + int a = 0, b = 0; + const char *on_loaded, *off_loaded; + const char *on_active, *off_active; + + if (!output_show_job(u)) + continue; + + if (!streq(u->load_state, "loaded") && + !streq(u->load_state, "banned")) { + on_loaded = ansi_highlight(true); + off_loaded = ansi_highlight(false); + } else + on_loaded = off_loaded = ""; + + if (streq(u->active_state, "failed")) { + on_active = ansi_highlight(true); + off_active = ansi_highlight(false); + } else + on_active = off_active = ""; + + e = arg_full ? NULL : ellipsize(u->id, 25, 33); + + printf("%-25s %s%-6s%s %s%-*s %-*s%s%n", + 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, + &a); + + free(e); + + a -= strlen(on_loaded) + strlen(off_loaded); + a -= strlen(on_active) + strlen(off_active); + + if (u->job_id != 0) + printf(" %-*s", job_len, u->job_type); + else + b = 1 + job_len; + + if (a + b + 1 < columns()) { + if (u->job_id == 0) + printf(" %-*s", job_len, ""); + + if (arg_full) + printf(" %s", u->description); + else + printf(" %.*s", columns() - a - b - 1, u->description); + } + + fputs("\n", stdout); + } + + if (on_tty()) { + 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"); + + if (arg_all) + printf("\n%u units listed.\n", c); + else + printf("\n%u units listed. Pass --all to see inactive units, too.\n", c); + } +} + static int list_units(DBusConnection *bus, char **args, unsigned n) { DBusMessage *m = NULL, *reply = NULL; DBusError error; int r; DBusMessageIter iter, sub, sub2; - unsigned k = 0; + unsigned c = 0, n_units = 0; + struct unit_info *unit_infos = NULL; dbus_error_init(&error); @@ -168,7 +380,7 @@ static int list_units(DBusConnection *bus, char **args, unsigned n) { } if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { - log_error("Failed to issue method call: %s", error.message); + log_error("Failed to issue method call: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -183,11 +395,8 @@ static int list_units(DBusConnection *bus, char **args, unsigned n) { dbus_message_iter_recurse(&iter, &sub); - printf("%-45s %-6s %-12s %-12s %-15s %s\n", "UNIT", "LOAD", "ACTIVE", "SUB", "JOB", "DESCRIPTION"); - while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { - const char *id, *description, *load_state, *active_state, *sub_state, *unit_state, *job_type, *job_path, *dot; - uint32_t job_id; + struct unit_info *u; if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) { log_error("Failed to parse reply."); @@ -195,60 +404,201 @@ static int list_units(DBusConnection *bus, char **args, unsigned n) { goto finish; } + if (c >= n_units) { + struct unit_info *w; + + n_units = MAX(2*c, 16); + w = realloc(unit_infos, sizeof(struct unit_info) * n_units); + + if (!w) { + log_error("Failed to allocate unit array."); + r = -ENOMEM; + goto finish; + } + + unit_infos = w; + } + + u = unit_infos+c; + dbus_message_iter_recurse(&sub, &sub2); - if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) < 0 || - bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &description, true) < 0 || - bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &load_state, true) < 0 || - bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &active_state, true) < 0 || - bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &sub_state, true) < 0 || - bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_state, true) < 0 || - bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &job_id, true) < 0 || - bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &job_type, true) < 0 || - bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &job_path, false) < 0) { + if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->id, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->description, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->load_state, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->active_state, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->sub_state, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->following, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &u->unit_path, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &u->job_id, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->job_type, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &u->job_path, false) < 0) { log_error("Failed to parse reply."); r = -EIO; goto finish; } - if ((!arg_type || ((dot = strrchr(id, '.')) && - streq(dot+1, arg_type))) && - (arg_all || !streq(active_state, "inactive"))) { + dbus_message_iter_next(&sub); + c++; + } + + qsort(unit_infos, c, sizeof(struct unit_info), compare_unit_info); + 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; +} + +static int dot_one_property(const char *name, const char *prop, DBusMessageIter *iter) { + static const char * const colors[] = { + "Requires", "[color=\"black\"]", + "RequiresOverridable", "[color=\"black\"]", + "Requisite", "[color=\"darkblue\"]", + "RequisiteOverridable", "[color=\"darkblue\"]", + "Wants", "[color=\"darkgrey\"]", + "Conflicts", "[color=\"red\"]", + "ConflictedBy", "[color=\"red\"]", + "After", "[color=\"green\"]" + }; + + const char *c = NULL; + unsigned i; + + assert(name); + assert(prop); + assert(iter); + + for (i = 0; i < ELEMENTSOF(colors); i += 2) + if (streq(colors[i], prop)) { + c = colors[i+1]; + break; + } + + if (!c) + return 0; - int a = 0, b = 0; + if (arg_dot != DOT_ALL) + if ((arg_dot == DOT_ORDER) != streq(prop, "After")) + return 0; - if (streq(active_state, "maintenance")) - fputs(ANSI_HIGHLIGHT_ON, stdout); + switch (dbus_message_iter_get_arg_type(iter)) { - printf("%-45s %-6s %-12s %-12s%n", id, load_state, active_state, sub_state, &a); + case DBUS_TYPE_ARRAY: - if (job_id != 0) - printf(" %-15s%n", job_type, &b); - else - b = 1 + 15; + if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRING) { + DBusMessageIter sub; - if (a + b + 2 < columns()) { - if (job_id == 0) - printf(" "); + dbus_message_iter_recurse(iter, &sub); + + while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { + const char *s; - printf(" %.*s", columns() - a - b - 2, description); + assert(dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING); + dbus_message_iter_get_basic(&sub, &s); + printf("\t\"%s\"->\"%s\" %s;\n", name, s, c); + + dbus_message_iter_next(&sub); } - if (streq(active_state, "maintenance")) - fputs(ANSI_HIGHLIGHT_OFF, stdout); + return 0; + } + } + + return 0; +} + +static int dot_one(DBusConnection *bus, const char *name, const char *path) { + DBusMessage *m = NULL, *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; + goto finish; + } + + 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_DICT_ENTRY) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } + + dbus_message_iter_recurse(&iter, &sub); + + while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { + const char *prop; + + if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_DICT_ENTRY) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } + + dbus_message_iter_recurse(&sub, &sub2); + + if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &prop, true) < 0) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } + + if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_VARIANT) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } + + dbus_message_iter_recurse(&sub2, &sub3); - fputs("\n", stdout); - k++; + if (dot_one_property(name, prop, &sub3)) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; } dbus_message_iter_next(&sub); } - if (arg_all) - printf("\n%u units listed.\n", k); - else - printf("\n%u live units listed. Pass --all to see dead units, too.\n", k); - r = 0; finish: @@ -263,12 +613,11 @@ finish: return r; } -static int list_jobs(DBusConnection *bus, char **args, unsigned n) { +static int dot(DBusConnection *bus, char **args, unsigned n) { DBusMessage *m = NULL, *reply = NULL; DBusError error; int r; DBusMessageIter iter, sub, sub2; - unsigned k = 0; dbus_error_init(&error); @@ -278,13 +627,13 @@ static int list_jobs(DBusConnection *bus, char **args, unsigned n) { "org.freedesktop.systemd1", "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", - "ListJobs"))) { + "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", error.message); + log_error("Failed to issue method call: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -297,13 +646,11 @@ static int list_jobs(DBusConnection *bus, char **args, unsigned n) { goto finish; } - dbus_message_iter_recurse(&iter, &sub); - - printf("%4s %-45s %-17s %-7s\n", "JOB", "UNIT", "TYPE", "STATE"); + printf("digraph systemd {\n"); + dbus_message_iter_recurse(&iter, &sub); while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { - const char *name, *type, *state, *job_path, *unit_path; - uint32_t id; + const char *id, *description, *load_state, *active_state, *sub_state, *following, *unit_path; if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) { log_error("Failed to parse reply."); @@ -313,24 +660,37 @@ static int list_jobs(DBusConnection *bus, char **args, unsigned n) { dbus_message_iter_recurse(&sub, &sub2); - if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &id, true) < 0 || - bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0 || - bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) < 0 || - bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &state, true) < 0 || - bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &job_path, true) < 0 || - bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_path, false) < 0) { + if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &description, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &load_state, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &active_state, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &sub_state, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &following, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_path, true) < 0) { log_error("Failed to parse reply."); r = -EIO; goto finish; } - printf("%4u %-45s %-17s %-7s\n", id, name, type, state); - k++; + if ((r = dot_one(bus, id, unit_path)) < 0) + goto finish; + /* printf("\t\"%s\";\n", id); */ dbus_message_iter_next(&sub); } - printf("\n%u jobs listed.\n", k); + printf("}\n"); + + log_info(" Color legend: black = Requires\n" + " dark blue = Requisite\n" + " dark grey = Wants\n" + " red = Conflicts\n" + " green = After\n"); + + if (isatty(fileno(stdout))) + log_notice("-- You probably want to process this output with graphviz' dot tool.\n" + "-- Try a shell pipeline like 'systemctl dot | dot -Tsvg > systemd.svg'!\n"); + r = 0; finish: @@ -345,25 +705,114 @@ finish: return r; } -static int load_unit(DBusConnection *bus, char **args, unsigned n) { +static int list_jobs(DBusConnection *bus, char **args, unsigned n) { DBusMessage *m = NULL, *reply = NULL; DBusError error; int r; - unsigned i; + DBusMessageIter iter, sub, sub2; + unsigned k = 0; dbus_error_init(&error); assert(bus); - assert(args); - for (i = 1; i < n; i++) { + 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 (!(m = dbus_message_new_method_call( - "org.freedesktop.systemd1", - "/org/freedesktop/systemd1", - "org.freedesktop.systemd1.Manager", - "LoadUnit"))) { - log_error("Could not allocate message."); + 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_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."); + r = -EIO; + goto finish; + } + + dbus_message_iter_recurse(&iter, &sub); + + if (isatty(STDOUT_FILENO)) + printf("%4s %-25s %-15s %-7s\n", "JOB", "UNIT", "TYPE", "STATE"); + + while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { + const char *name, *type, *state, *job_path, *unit_path; + uint32_t id; + char *e; + + if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } + + dbus_message_iter_recurse(&sub, &sub2); + + if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &id, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &state, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &job_path, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_path, false) < 0) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } + + e = arg_full ? NULL : ellipsize(name, 25, 33); + printf("%4u %-25s %-15s %-7s\n", id, e ? e : name, type, state); + free(e); + + k++; + + dbus_message_iter_next(&sub); + } + + if (isatty(STDOUT_FILENO)) + printf("\n%u jobs listed.\n", k); + + 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, unsigned n) { + DBusMessage *m = NULL, *reply = NULL; + DBusError error; + int r; + unsigned i; + + dbus_error_init(&error); + + assert(bus); + assert(args); + + for (i = 1; i < n; i++) { + + 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; } @@ -377,7 +826,7 @@ static int load_unit(DBusConnection *bus, char **args, unsigned n) { } if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { - log_error("Failed to issue method call: %s", error.message); + log_error("Failed to issue method call: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -413,6 +862,9 @@ static int cancel_job(DBusConnection *bus, char **args, unsigned n) { assert(bus); assert(args); + if (n <= 1) + return daemon_reload(bus, args, n); + for (i = 1; i < n; i++) { unsigned id; const char *path; @@ -442,7 +894,7 @@ static int cancel_job(DBusConnection *bus, char **args, unsigned n) { } if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { - log_error("Failed to issue method call: %s", error.message); + log_error("Failed to issue method call: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -450,7 +902,7 @@ static int cancel_job(DBusConnection *bus, char **args, unsigned n) { if (!dbus_message_get_args(reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) { - log_error("Failed to parse reply: %s", error.message); + log_error("Failed to parse reply: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -468,7 +920,7 @@ static int cancel_job(DBusConnection *bus, char **args, unsigned n) { 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", error.message); + log_error("Failed to issue method call: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -492,6 +944,77 @@ finish: return r; } +static bool need_daemon_reload(DBusConnection *bus, const char *unit) { + DBusMessage *m = NULL, *reply = NULL; + dbus_bool_t b = FALSE; + DBusMessageIter iter, sub; + const char + *interface = "org.freedesktop.systemd1.Unit", + *property = "NeedDaemonReload", + *path; + + /* 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))) + goto finish; + + if (!dbus_message_get_args(reply, NULL, + DBUS_TYPE_OBJECT_PATH, &path, + 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))) + goto finish; + + if (!dbus_message_iter_init(reply, &iter) || + dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) + goto finish; + + dbus_message_iter_recurse(&iter, &sub); + + if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN) + goto finish; + + dbus_message_iter_get_basic(&sub, &b); + +finish: + if (m) + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); + + return b; +} + typedef struct WaitData { Set *set; bool failed; @@ -526,7 +1049,7 @@ static DBusHandlerResult wait_filter(DBusConnection *connection, DBusMessage *me DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_BOOLEAN, &success, DBUS_TYPE_INVALID)) - log_error("Failed to parse message: %s", error.message); + log_error("Failed to parse message: %s", bus_error_message(&error)); else { char *p; @@ -560,7 +1083,7 @@ static int enable_wait_for_jobs(DBusConnection *bus) { &error); if (dbus_error_is_set(&error)) { - log_error("Failed to add match: %s", error.message); + log_error("Failed to add match: %s", bus_error_message(&error)); dbus_error_free(&error); return -EIO; } @@ -591,7 +1114,7 @@ static int wait_for_jobs(DBusConnection *bus, Set *s) { ; if (!arg_quiet && d.failed) - log_error("Job failed, see logs for details."); + log_error("Job failed, see system logs for details."); r = d.failed ? -EIO : 0; @@ -606,20 +1129,20 @@ static int start_unit_one( const char *method, const char *name, const char *mode, + DBusError *error, Set *s) { DBusMessage *m = NULL, *reply = NULL; - DBusError error; + const char *path; int r; assert(bus); assert(method); assert(name); assert(mode); + assert(error); assert(arg_no_block || s); - dbus_error_init(&error); - if (!(m = dbus_message_new_method_call( "org.freedesktop.systemd1", "/org/freedesktop/systemd1", @@ -639,32 +1162,35 @@ static int start_unit_one( goto finish; } - if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { + if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, error))) { - if (arg_action != ACTION_SYSTEMCTL && error_is_no_service(&error)) { + if (arg_action != ACTION_SYSTEMCTL && error_is_no_service(error)) { /* There's always a fallback possible for * legacy actions. */ - r = 0; + r = -EADDRNOTAVAIL; goto finish; } - log_error("Failed to issue method call: %s", error.message); + 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; } + if (need_daemon_reload(bus, name)) + log_warning("Unit file of created job changed on disk, 'systemctl %s daemon-reload' recommended.", + arg_session ? "--session" : "--system"); + if (!arg_no_block) { - const char *path; char *p; - if (!dbus_message_get_args(reply, &error, - DBUS_TYPE_OBJECT_PATH, &path, - DBUS_TYPE_INVALID)) { - log_error("Failed to parse reply: %s", error.message); - r = -EIO; - goto finish; - } - if (!(p = strdup(path))) { log_error("Failed to duplicate path."); r = -ENOMEM; @@ -678,7 +1204,7 @@ static int start_unit_one( } } - r = 1; + r = 0; finish: if (m) @@ -687,8 +1213,6 @@ finish: if (reply) dbus_message_unref(reply); - dbus_error_free(&error); - return r; } @@ -699,12 +1223,16 @@ static enum action verb_to_action(const char *verb) { return ACTION_POWEROFF; else if (streq(verb, "reboot")) return ACTION_REBOOT; + else if (streq(verb, "kexec")) + return ACTION_KEXEC; else if (streq(verb, "rescue")) return ACTION_RESCUE; else if (streq(verb, "emergency")) return ACTION_EMERGENCY; else if (streq(verb, "default")) return ACTION_DEFAULT; + else if (streq(verb, "exit")) + return ACTION_EXIT; else return ACTION_INVALID; } @@ -715,28 +1243,38 @@ static int start_unit(DBusConnection *bus, char **args, unsigned n) { [ACTION_HALT] = SPECIAL_HALT_TARGET, [ACTION_POWEROFF] = SPECIAL_POWEROFF_TARGET, [ACTION_REBOOT] = SPECIAL_REBOOT_TARGET, + [ACTION_KEXEC] = SPECIAL_KEXEC_TARGET, [ACTION_RUNLEVEL2] = SPECIAL_RUNLEVEL2_TARGET, [ACTION_RUNLEVEL3] = SPECIAL_RUNLEVEL3_TARGET, [ACTION_RUNLEVEL4] = SPECIAL_RUNLEVEL4_TARGET, [ACTION_RUNLEVEL5] = SPECIAL_RUNLEVEL5_TARGET, [ACTION_RESCUE] = SPECIAL_RESCUE_TARGET, - [ACTION_EMERGENCY] = SPECIAL_EMERGENCY_SERVICE, - [ACTION_DEFAULT] = SPECIAL_DEFAULT_TARGET + [ACTION_EMERGENCY] = SPECIAL_EMERGENCY_TARGET, + [ACTION_DEFAULT] = SPECIAL_DEFAULT_TARGET, + [ACTION_EXIT] = SPECIAL_EXIT_TARGET }; - int r; + int r, ret = 0; unsigned i; const char *method, *mode, *one_name; Set *s = NULL; + DBusError error; + + dbus_error_init(&error); assert(bus); if (arg_action == ACTION_SYSTEMCTL) { method = - streq(args[0], "stop") ? "StopUnit" : - streq(args[0], "reload") ? "ReloadUnit" : - streq(args[0], "restart") ? "RestartUnit" : - "StartUnit"; + streq(args[0], "stop") ? "StopUnit" : + streq(args[0], "reload") ? "ReloadUnit" : + streq(args[0], "restart") ? "RestartUnit" : + streq(args[0], "try-restart") || + streq(args[0], "condrestart") ? "TryRestartUnit" : + streq(args[0], "reload-or-restart") ? "ReloadOrRestartUnit" : + streq(args[0], "reload-or-try-restart") || + streq(args[0], "force-reload") ? "ReloadOrTryRestartUnit" : + "StartUnit"; mode = (streq(args[0], "isolate") || @@ -754,43 +1292,52 @@ static int start_unit(DBusConnection *bus, char **args, unsigned n) { method = "StartUnit"; mode = (arg_action == ACTION_EMERGENCY || - arg_action == ACTION_RESCUE) ? "isolate" : "replace"; + arg_action == ACTION_RESCUE || + arg_action == ACTION_RUNLEVEL2 || + arg_action == ACTION_RUNLEVEL3 || + arg_action == ACTION_RUNLEVEL4 || + arg_action == ACTION_RUNLEVEL5) ? "isolate" : "replace"; one_name = table[arg_action]; } if (!arg_no_block) { - if ((r = enable_wait_for_jobs(bus)) < 0) { - log_error("Could not watch jobs: %s", strerror(-r)); + if ((ret = enable_wait_for_jobs(bus)) < 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."); - r = -ENOMEM; + ret = -ENOMEM; goto finish; } } - r = 0; - if (one_name) { - if ((r = start_unit_one(bus, method, one_name, mode, s)) <= 0) + if ((ret = start_unit_one(bus, method, one_name, mode, &error, s)) <= 0) goto finish; } else { for (i = 1; i < n; i++) - if ((r = start_unit_one(bus, method, args[i], mode, s)) < 0) - goto finish; + if ((r = start_unit_one(bus, method, args[i], mode, &error, s)) != 0) { + ret = translate_bus_error_to_exit_status(r, &error); + dbus_error_free(&error); + } } if (!arg_no_block) - r = wait_for_jobs(bus, s); + if ((r = wait_for_jobs(bus, s)) < 0) { + ret = r; + goto finish; + } finish: if (s) set_free_free(s); - return r; + dbus_error_free(&error); + + return ret; } static int start_special(DBusConnection *bus, char **args, unsigned n) { @@ -799,6 +1346,14 @@ static int start_special(DBusConnection *bus, char **args, unsigned n) { assert(bus); assert(args); + if (arg_force && + (streq(args[0], "halt") || + streq(args[0], "poweroff") || + streq(args[0], "reboot") || + streq(args[0], "kexec") || + streq(args[0], "exit"))) + return daemon_reload(bus, args, n); + r = start_unit(bus, args, n); if (r >= 0) @@ -812,7 +1367,7 @@ static int check_unit(DBusConnection *bus, char **args, unsigned n) { const char *interface = "org.freedesktop.systemd1.Unit", *property = "ActiveState"; - int r = -EADDRNOTAVAIL; + int r = 3; /* According to LSB: "program is not running" */ DBusError error; unsigned i; @@ -857,7 +1412,7 @@ static int check_unit(DBusConnection *bus, char **args, unsigned n) { if (!dbus_message_get_args(reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) { - log_error("Failed to parse reply: %s", error.message); + log_error("Failed to parse reply: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -884,7 +1439,7 @@ static int check_unit(DBusConnection *bus, char **args, unsigned n) { 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", error.message); + log_error("Failed to issue method call: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -909,7 +1464,7 @@ static int check_unit(DBusConnection *bus, char **args, unsigned n) { if (!arg_quiet) puts(state); - if (streq(state, "active") || startswith(state, "reloading")) + if (streq(state, "active") || streq(state, "reloading")) r = 0; dbus_message_unref(m); @@ -1030,15 +1585,26 @@ typedef struct UnitStatusInfo { const char *sub_state; const char *description; + const char *following; - const char *fragment_path; + const char *path; const char *default_control_group; + usec_t inactive_exit_timestamp; + usec_t active_enter_timestamp; + usec_t active_exit_timestamp; + usec_t inactive_enter_timestamp; + + bool need_daemon_reload; + /* Service */ pid_t main_pid; pid_t control_pid; const char *status_text; - bool running; + bool running:1; +#ifdef HAVE_SYSV_COMPAT + bool is_sysv:1; +#endif usec_t start_timestamp; usec_t exit_timestamp; @@ -1064,6 +1630,10 @@ typedef struct UnitStatusInfo { static void print_status_info(UnitStatusInfo *i) { ExecStatusInfo *p; + const char *on, *off, *ss; + usec_t timestamp; + char since1[FORMAT_TIMESTAMP_PRETTY_MAX], *s1; + char since2[FORMAT_TIMESTAMP_MAX], *s2; assert(i); @@ -1077,30 +1647,60 @@ static void print_status_info(UnitStatusInfo *i) { printf("\n"); - if (i->fragment_path) - printf("\t Loaded: %s (%s)\n", strna(i->load_state), i->fragment_path); - else if (streq_ptr(i->load_state, "failed")) - printf("\t Loaded: " ANSI_HIGHLIGHT_ON "%s" ANSI_HIGHLIGHT_OFF "\n", strna(i->load_state)); - else - printf("\t Loaded: %s\n", strna(i->load_state)); + if (i->following) + printf("\t Follow: unit currently follows state of %s\n", i->following); - if (streq_ptr(i->active_state, "maintenance")) { - if (streq_ptr(i->active_state, i->sub_state)) - printf("\t Active: " ANSI_HIGHLIGHT_ON "%s" ANSI_HIGHLIGHT_OFF "\n", - strna(i->active_state)); - else - printf("\t Active: " ANSI_HIGHLIGHT_ON "%s (%s)" ANSI_HIGHLIGHT_OFF "\n", - strna(i->active_state), - strna(i->sub_state)); - } else { - if (streq_ptr(i->active_state, i->sub_state)) - printf("\t Active: %s\n", - strna(i->active_state)); - else - printf("\t Active: %s (%s)\n", - strna(i->active_state), - strna(i->sub_state)); - } + if (streq_ptr(i->load_state, "failed") || + streq_ptr(i->load_state, "banned")) { + on = ansi_highlight(true); + off = ansi_highlight(false); + } else + on = off = ""; + + if (i->path) + printf("\t Loaded: %s%s%s (%s)\n", on, strna(i->load_state), off, i->path); + else + printf("\t Loaded: %s%s%s\n", on, strna(i->load_state), off); + + ss = streq_ptr(i->active_state, i->sub_state) ? NULL : i->sub_state; + + if (streq_ptr(i->active_state, "failed")) { + on = ansi_highlight(true); + off = ansi_highlight(false); + } else if (streq_ptr(i->active_state, "active") || streq_ptr(i->active_state, "reloading")) { + on = ansi_highlight_green(true); + off = ansi_highlight_green(false); + } else + on = off = ""; + + if (ss) + printf("\t Active: %s%s (%s)%s", + on, + strna(i->active_state), + ss, + off); + else + printf("\t Active: %s%s%s", + on, + strna(i->active_state), + off); + + timestamp = (streq_ptr(i->active_state, "active") || + streq_ptr(i->active_state, "reloading")) ? i->active_enter_timestamp : + (streq_ptr(i->active_state, "inactive") || + streq_ptr(i->active_state, "failed")) ? i->inactive_enter_timestamp : + streq_ptr(i->active_state, "activating") ? i->inactive_exit_timestamp : + i->active_exit_timestamp; + + s1 = format_timestamp_pretty(since1, sizeof(since1), timestamp); + s2 = format_timestamp(since2, sizeof(since2), timestamp); + + if (s1) + printf(" since %s; %s\n", s2, s1); + else if (s2) + printf(" since %s\n", s2); + else + printf("\n"); if (i->sysfs_path) printf("\t Device: %s\n", i->sysfs_path); @@ -1120,12 +1720,22 @@ static void print_status_info(UnitStatusInfo *i) { continue; t = strv_join(p->argv, " "); - printf("\t Exited: %u (%s, code=%s, ", p->pid, strna(t), sigchld_code_to_string(p->code)); + printf("\t Process: %u (%s, code=%s, ", p->pid, strna(t), sigchld_code_to_string(p->code)); free(t); - if (p->code == CLD_EXITED) + if (p->code == CLD_EXITED) { + const char *c; + printf("status=%i", p->status); - else + +#ifdef HAVE_SYSV_COMPAT + if ((c = exit_status_to_string(p->status, i->is_sysv ? EXIT_STATUS_LSB : EXIT_STATUS_SYSTEMD))) +#else + if ((c = exit_status_to_string(p->status, EXIT_STATUS_SYSTEMD))) +#endif + printf("/%s", c); + + } else printf("signal=%s", signal_to_string(p->status)); printf(")\n"); @@ -1143,7 +1753,7 @@ static void print_status_info(UnitStatusInfo *i) { printf("\t"); if (i->main_pid > 0) { - printf(" Main: %u", (unsigned) i->main_pid); + printf("Main PID: %u", (unsigned) i->main_pid); if (i->running) { char *t = NULL; @@ -1152,12 +1762,22 @@ static void print_status_info(UnitStatusInfo *i) { printf(" (%s)", t); free(t); } - } else { + } else if (i->exit_code > 0) { printf(" (code=%s, ", sigchld_code_to_string(i->exit_code)); - if (i->exit_code == CLD_EXITED) + if (i->exit_code == CLD_EXITED) { + const char *c; + printf("status=%i", i->exit_status); - else + +#ifdef HAVE_SYSV_COMPAT + if ((c = exit_status_to_string(i->exit_status, i->is_sysv ? EXIT_STATUS_LSB : EXIT_STATUS_SYSTEMD))) +#else + if ((c = exit_status_to_string(i->exit_status, EXIT_STATUS_SYSTEMD))) +#endif + printf("/%s", c); + + } else printf("signal=%s", signal_to_string(i->exit_status)); printf(")"); } @@ -1196,6 +1816,12 @@ static void print_status_info(UnitStatusInfo *i) { show_cgroup_by_path(i->default_control_group, "\t\t ", c); } + + if (i->need_daemon_reload) + printf("\n%sWarning:%s Unit file changed on disk, 'systemctl %s daemon-reload' recommended.\n", + ansi_highlight(true), + ansi_highlight(false), + arg_session ? "--session" : "--system"); } static int status_property(const char *name, DBusMessageIter *iter, UnitStatusInfo *i) { @@ -1219,7 +1845,13 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn else if (streq(name, "Description")) i->description = s; else if (streq(name, "FragmentPath")) - i->fragment_path = s; + i->path = s; +#ifdef HAVE_SYSV_COMPAT + else if (streq(name, "SysVPath")) { + i->is_sysv = true; + i->path = s; + } +#endif else if (streq(name, "DefaultControlGroup")) i->default_control_group = s; else if (streq(name, "StatusText")) @@ -1230,6 +1862,8 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn i->where = s; else if (streq(name, "What")) i->what = s; + else if (streq(name, "Following")) + i->following = s; } break; @@ -1242,6 +1876,8 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn if (streq(name, "Accept")) i->accept = b; + else if (streq(name, "NeedDaemonReload")) + i->need_daemon_reload = b; break; } @@ -1291,6 +1927,14 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn i->start_timestamp = (usec_t) u; else if (streq(name, "ExecMainExitTimestamp")) i->exit_timestamp = (usec_t) u; + else if (streq(name, "ActiveEnterTimestamp")) + i->active_enter_timestamp = (usec_t) u; + else if (streq(name, "InactiveEnterTimestamp")) + i->inactive_enter_timestamp = (usec_t) u; + else if (streq(name, "InactiveExitTimestamp")) + i->inactive_exit_timestamp = (usec_t) u; + else if (streq(name, "ActiveExitTimestamp")) + i->active_exit_timestamp = (usec_t) u; break; } @@ -1334,7 +1978,7 @@ static int print_property(const char *name, DBusMessageIter *iter) { /* This is a low-level property printer, see * print_status_info() for the nicer output */ - if (arg_property && !streq(name, arg_property)) + if (arg_property && !strv_find(arg_property, name)) return 0; switch (dbus_message_iter_get_arg_type(iter)) { @@ -1399,6 +2043,14 @@ static int print_property(const char *name, DBusMessageIter *iter) { return 0; } + case DBUS_TYPE_DOUBLE: { + double d; + dbus_message_iter_get_basic(iter, &d); + + printf("%s=%g\n", name, d); + return 0; + } + case DBUS_TYPE_STRUCT: { DBusMessageIter sub; dbus_message_iter_recurse(iter, &sub); @@ -1605,7 +2257,7 @@ static int show_one(DBusConnection *bus, const char *path, bool show_properties, } if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { - log_error("Failed to issue method call: %s", error.message); + log_error("Failed to issue method call: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -1664,16 +2316,21 @@ static int show_one(DBusConnection *bus, const char *path, bool show_properties, dbus_message_iter_next(&sub); } + r = 0; + if (!show_properties) print_status_info(&info); + if (!streq_ptr(info.active_state, "active") && + !streq_ptr(info.active_state, "reloading")) + /* According to LSB: "program not running" */ + r = 3; + while ((p = info.exec)) { LIST_REMOVE(ExecStatusInfo, exec, info.exec, p); exec_status_info_free(p); } - r = 0; - finish: if (m) dbus_message_unref(m); @@ -1688,7 +2345,7 @@ finish: static int show(DBusConnection *bus, char **args, unsigned n) { DBusMessage *m = NULL, *reply = NULL; - int r; + int r, ret = 0; DBusError error; unsigned i; bool show_properties, new_line = false; @@ -1704,7 +2361,7 @@ static int show(DBusConnection *bus, char **args, unsigned n) { /* If not argument is specified inspect the manager * itself */ - r = show_one(bus, "/org/freedesktop/systemd1", show_properties, &new_line); + ret = show_one(bus, "/org/freedesktop/systemd1", show_properties, &new_line); goto finish; } @@ -1712,7 +2369,9 @@ static int show(DBusConnection *bus, char **args, unsigned n) { const char *path = NULL; uint32_t id; - if (!show_properties || safe_atou32(args[i], &id) < 0) { + if (safe_atou32(args[i], &id) < 0) { + + /* Interpret as unit name */ if (!(m = dbus_message_new_method_call( "org.freedesktop.systemd1", @@ -1720,7 +2379,7 @@ static int show(DBusConnection *bus, char **args, unsigned n) { "org.freedesktop.systemd1.Manager", "LoadUnit"))) { log_error("Could not allocate message."); - r = -ENOMEM; + ret = -ENOMEM; goto finish; } @@ -1728,15 +2387,15 @@ static int show(DBusConnection *bus, char **args, unsigned n) { DBUS_TYPE_STRING, &args[i], DBUS_TYPE_INVALID)) { log_error("Could not append arguments to message."); - r = -ENOMEM; + ret = -ENOMEM; goto finish; } if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { if (!dbus_error_has_name(&error, DBUS_ERROR_ACCESS_DENIED)) { - log_error("Failed to issue method call: %s", error.message); - r = -EIO; + log_error("Failed to issue method call: %s", bus_error_message(&error)); + ret = -EIO; goto finish; } @@ -1749,7 +2408,7 @@ static int show(DBusConnection *bus, char **args, unsigned n) { "org.freedesktop.systemd1.Manager", "GetUnit"))) { log_error("Could not allocate message."); - r = -ENOMEM; + ret = -ENOMEM; goto finish; } @@ -1757,18 +2416,24 @@ static int show(DBusConnection *bus, char **args, unsigned n) { DBUS_TYPE_STRING, &args[i], DBUS_TYPE_INVALID)) { log_error("Could not append arguments to message."); - r = -ENOMEM; + ret = -ENOMEM; goto finish; } if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { - log_error("Failed to issue method call: %s", error.message); - r = -EIO; + log_error("Failed to issue method call: %s", bus_error_message(&error)); + + if (dbus_error_has_name(&error, BUS_ERROR_NO_SUCH_UNIT)) + ret = 4; /* According to LSB: "program or service status is unknown" */ + else + ret = -EIO; goto finish; } } - } else { + } else if (show_properties) { + + /* Interpret as job id */ if (!(m = dbus_message_new_method_call( "org.freedesktop.systemd1", @@ -1776,7 +2441,7 @@ static int show(DBusConnection *bus, char **args, unsigned n) { "org.freedesktop.systemd1.Manager", "GetJob"))) { log_error("Could not allocate message."); - r = -ENOMEM; + ret = -ENOMEM; goto finish; } @@ -1784,13 +2449,40 @@ static int show(DBusConnection *bus, char **args, unsigned n) { DBUS_TYPE_UINT32, &id, DBUS_TYPE_INVALID)) { log_error("Could not append arguments to message."); - r = -ENOMEM; + ret = -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)); + ret = -EIO; + goto finish; + } + } else { + + /* Interpret as PID */ + + if (!(m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "GetUnitByPID"))) { + log_error("Could not allocate message."); + ret = -ENOMEM; + goto finish; + } + + if (!dbus_message_append_args(m, + DBUS_TYPE_UINT32, &id, + DBUS_TYPE_INVALID)) { + log_error("Could not append arguments to message."); + ret = -ENOMEM; goto finish; } if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { - log_error("Failed to issue method call: %s", error.message); - r = -EIO; + log_error("Failed to issue method call: %s", bus_error_message(&error)); + ret = -EIO; goto finish; } } @@ -1798,21 +2490,19 @@ static int show(DBusConnection *bus, char **args, unsigned n) { if (!dbus_message_get_args(reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) { - log_error("Failed to parse reply: %s", error.message); - r = -EIO; + log_error("Failed to parse reply: %s", bus_error_message(&error)); + ret = -EIO; goto finish; } - if ((r = show_one(bus, path, show_properties, &new_line)) < 0) - goto finish; + if ((r = show_one(bus, path, show_properties, &new_line)) != 0) + ret = r; dbus_message_unref(m); dbus_message_unref(reply); m = reply = NULL; } - r = 0; - finish: if (m) dbus_message_unref(m); @@ -1822,7 +2512,7 @@ finish: dbus_error_free(&error); - return r; + return ret; } static DBusHandlerResult monitor_filter(DBusConnection *connection, DBusMessage *message, void *data) { @@ -1851,7 +2541,7 @@ static DBusHandlerResult monitor_filter(DBusConnection *connection, DBusMessage DBUS_TYPE_STRING, &id, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) - log_error("Failed to parse message: %s", error.message); + log_error("Failed to parse message: %s", bus_error_message(&error)); else if (streq(dbus_message_get_member(message), "UnitNew")) printf("Unit %s added.\n", id); else @@ -1866,21 +2556,30 @@ static DBusHandlerResult monitor_filter(DBusConnection *connection, DBusMessage DBUS_TYPE_UINT32, &id, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) - log_error("Failed to parse message: %s", error.message); + log_error("Failed to parse message: %s", bus_error_message(&error)); else if (streq(dbus_message_get_member(message), "JobNew")) printf("Job %u added.\n", id); else printf("Job %u removed.\n", id); - } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Unit", "Changed") || - dbus_message_is_signal(message, "org.freedesktop.systemd1.Job", "Changed")) { + } else if (dbus_message_is_signal(message, "org.freedesktop.DBus.Properties", "PropertiesChanged")) { const char *path, *interface, *property = "Id"; DBusMessageIter iter, sub; path = dbus_message_get_path(message); - interface = dbus_message_get_interface(message); + + if (!dbus_message_get_args(message, &error, + DBUS_TYPE_STRING, &interface, + DBUS_TYPE_INVALID)) { + log_error("Failed to parse message: %s", bus_error_message(&error)); + goto finish; + } + + if (!streq(interface, "org.freedesktop.systemd1.Job") && + !streq(interface, "org.freedesktop.systemd1.Unit")) + goto finish; if (!(m = dbus_message_new_method_call( "org.freedesktop.systemd1", @@ -1900,7 +2599,7 @@ static DBusHandlerResult monitor_filter(DBusConnection *connection, DBusMessage } if (!(reply = dbus_connection_send_with_reply_and_block(connection, m, -1, &error))) { - log_error("Failed to issue method call: %s", error.message); + log_error("Failed to issue method call: %s", bus_error_message(&error)); goto finish; } @@ -1972,7 +2671,7 @@ static int monitor(DBusConnection *bus, char **args, unsigned n) { &error); if (dbus_error_is_set(&error)) { - log_error("Failed to add match: %s", error.message); + log_error("Failed to add match: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -1980,29 +2679,16 @@ static int monitor(DBusConnection *bus, char **args, unsigned n) { dbus_bus_add_match(bus, "type='signal'," "sender='org.freedesktop.systemd1'," - "interface='org.freedesktop.systemd1.Unit'," - "member='Changed'", + "interface='org.freedesktop.DBus.Properties'," + "member='PropertiesChanged'", &error); if (dbus_error_is_set(&error)) { - log_error("Failed to add match: %s", error.message); + log_error("Failed to add match: %s", bus_error_message(&error)); r = -EIO; goto finish; } - - dbus_bus_add_match(bus, - "type='signal'," - "sender='org.freedesktop.systemd1'," - "interface='org.freedesktop.systemd1.Job'," - "member='Changed'", - &error); - - if (dbus_error_is_set(&error)) { - log_error("Failed to add match: %s", error.message); - r = -EIO; - goto finish; - } - } + } if (!dbus_connection_add_filter(bus, monitor_filter, NULL, NULL)) { log_error("Failed to add filter."); @@ -2021,7 +2707,7 @@ static int monitor(DBusConnection *bus, char **args, unsigned n) { } if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { - log_error("Failed to issue method call: %s", error.message); + log_error("Failed to issue method call: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -2064,7 +2750,7 @@ static int dump(DBusConnection *bus, char **args, unsigned n) { } if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { - log_error("Failed to issue method call: %s", error.message); + log_error("Failed to issue method call: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -2072,7 +2758,7 @@ static int dump(DBusConnection *bus, char **args, unsigned n) { if (!dbus_message_get_args(reply, &error, DBUS_TYPE_STRING, &text, DBUS_TYPE_INVALID)) { - log_error("Failed to parse reply: %s", error.message); + log_error("Failed to parse reply: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -2128,7 +2814,7 @@ static int snapshot(DBusConnection *bus, char **args, unsigned n) { } if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { - log_error("Failed to issue method call: %s", error.message); + log_error("Failed to issue method call: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -2136,7 +2822,7 @@ static int snapshot(DBusConnection *bus, char **args, unsigned n) { if (!dbus_message_get_args(reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) { - log_error("Failed to parse reply: %s", error.message); + log_error("Failed to parse reply: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -2162,7 +2848,7 @@ static int snapshot(DBusConnection *bus, char **args, unsigned n) { 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", error.message); + log_error("Failed to issue method call: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -2233,7 +2919,7 @@ static int delete_snapshot(DBusConnection *bus, char **args, unsigned n) { } if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { - log_error("Failed to issue method call: %s", error.message); + log_error("Failed to issue method call: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -2241,7 +2927,7 @@ static int delete_snapshot(DBusConnection *bus, char **args, unsigned n) { if (!dbus_message_get_args(reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) { - log_error("Failed to parse reply: %s", error.message); + log_error("Failed to parse reply: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -2259,7 +2945,7 @@ static int delete_snapshot(DBusConnection *bus, char **args, unsigned n) { 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", error.message); + log_error("Failed to issue method call: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -2283,7 +2969,7 @@ finish: return r; } -static int clear_jobs(DBusConnection *bus, char **args, unsigned n) { +static int daemon_reload(DBusConnection *bus, char **args, unsigned n) { DBusMessage *m = NULL, *reply = NULL; DBusError error; int r; @@ -2299,10 +2985,16 @@ static int clear_jobs(DBusConnection *bus, char **args, unsigned n) { assert(arg_action == ACTION_SYSTEMCTL); method = - streq(args[0], "clear-jobs") ? "ClearJobs" : - streq(args[0], "daemon-reload") ? "Reload" : + streq(args[0], "clear-jobs") || + streq(args[0], "cancel") ? "ClearJobs" : streq(args[0], "daemon-reexec") ? "Reexecute" : - "Exit"; + streq(args[0], "reset-failed") ? "ResetFailed" : + streq(args[0], "halt") ? "Halt" : + streq(args[0], "poweroff") ? "PowerOff" : + streq(args[0], "reboot") ? "Reboot" : + streq(args[0], "kexec") ? "KExec" : + streq(args[0], "exit") ? "Exit" : + /* "daemon-reload" */ "Reload"; } if (!(m = dbus_message_new_method_call( @@ -2319,172 +3011,908 @@ static int clear_jobs(DBusConnection *bus, char **args, unsigned n) { if (arg_action != ACTION_SYSTEMCTL && error_is_no_service(&error)) { /* There's always a fallback possible for * legacy actions. */ - r = 0; + r = -EADDRNOTAVAIL; + goto finish; + } + + 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, unsigned n) { + DBusMessage *m = NULL, *reply = NULL; + unsigned i; + int r; + DBusError error; + + assert(bus); + dbus_error_init(&error); + + if (n <= 1) + return daemon_reload(bus, args, n); + + for (i = 1; i < n; i++) { + + 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, args + i, + 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); + m = reply = NULL; + } + + r = 0; + +finish: + if (m) + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); + + dbus_error_free(&error); + + return r; +} + +static int show_enviroment(DBusConnection *bus, char **args, unsigned n) { + DBusMessage *m = NULL, *reply = NULL; + DBusError error; + DBusMessageIter iter, sub, sub2; + int r; + const char + *interface = "org.freedesktop.systemd1.Manager", + *property = "Environment"; + + dbus_error_init(&error); + + 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; + 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."); + r = -EIO; + goto finish; + } + + dbus_message_iter_recurse(&iter, &sub); + + if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_ARRAY || + dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_STRING) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } + + dbus_message_iter_recurse(&sub, &sub2); + + while (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_INVALID) { + const char *text; + + if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_STRING) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } + + dbus_message_iter_get_basic(&sub2, &text); + printf("%s\n", text); + + dbus_message_iter_next(&sub2); + } + + r = 0; + +finish: + if (m) + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); + + dbus_error_free(&error); + + return r; +} + +static int set_environment(DBusConnection *bus, char **args, unsigned n) { + DBusMessage *m = NULL, *reply = NULL; + DBusError error; + int r; + const char *method; + DBusMessageIter iter, sub; + unsigned i; + + dbus_error_init(&error); + + method = streq(args[0], "set-environment") + ? "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; + } + + 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; + } + + for (i = 1; i < n; i++) + if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &args[i])) { + 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; + } + + 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; + } + + r = 0; + +finish: + if (m) + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); + + dbus_error_free(&error); + + return r; +} + +typedef struct { + char *name; + char *path; + + char **aliases; + char **wanted_by; +} InstallInfo; + +static Hashmap *will_install = NULL, *have_installed = NULL; +static Set *remove_symlinks_to = NULL; +static unsigned n_symlinks = 0; + +static void install_info_free(InstallInfo *i) { + assert(i); + + free(i->name); + free(i->path); + strv_free(i->aliases); + strv_free(i->wanted_by); + free(i); +} + +static void install_info_hashmap_free(Hashmap *m) { + InstallInfo *i; + + while ((i = hashmap_steal_first(m))) + install_info_free(i); + + hashmap_free(m); +} + +static int install_info_add(const char *name) { + InstallInfo *i; + int r; + + assert(will_install); + + if (!unit_name_is_valid_no_type(name, true)) { + log_warning("Unit name %s is not a valid unit name.", name); + return -EINVAL; + } + + if (hashmap_get(have_installed, name) || + hashmap_get(will_install, name)) + return 0; + + if (!(i = new0(InstallInfo, 1))) { + r = -ENOMEM; + goto fail; + } + + if (!(i->name = strdup(name))) { + r = -ENOMEM; + goto fail; + } + + if ((r = hashmap_put(will_install, i->name, i)) < 0) + goto fail; + + return 0; + +fail: + if (i) + install_info_free(i); + + return r; +} + +static int config_parse_also( + const char *filename, + unsigned line, + const char *section, + const char *lvalue, + const char *rvalue, + void *data, + void *userdata) { + + char *w; + size_t l; + char *state; + + assert(filename); + assert(lvalue); + assert(rvalue); + + FOREACH_WORD_QUOTED(w, l, rvalue, state) { + char *n; + int r; + + if (!(n = strndup(w, l))) + return -ENOMEM; + + if ((r = install_info_add(n)) < 0) { + log_warning("Cannot install unit %s: %s", n, strerror(-r)); + free(n); + return r; + } + + free(n); + } + + return 0; +} + +static int mark_symlink_for_removal(const char *p) { + char *n; + int r; + + assert(p); + assert(path_is_absolute(p)); + + if (!remove_symlinks_to) + return 0; + + if (!(n = strdup(p))) + return -ENOMEM; + + path_kill_slashes(n); + + if ((r = set_put(remove_symlinks_to, n)) < 0) { + free(n); + return r == -EEXIST ? 0 : r; + } + + return 0; +} + +static int remove_marked_symlinks_fd(int fd, const char *config_path, const char *root, bool *deleted) { + int r = 0; + DIR *d; + struct dirent *de; + + assert(fd >= 0); + assert(root); + assert(deleted); + + if (!(d = fdopendir(fd))) { + close_nointr_nofail(fd); + return -errno; + } + + rewinddir(d); + + while ((de = readdir(d))) { + bool is_dir = false, is_link = false; + + if (ignore_file(de->d_name)) + continue; + + if (de->d_type == DT_LNK) + is_link = true; + else if (de->d_type == DT_DIR) + is_dir = true; + else if (de->d_type == DT_UNKNOWN) { + struct stat st; + + if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) { + log_error("Failed to stat %s/%s: %m", root, de->d_name); + + if (r == 0) + r = -errno; + continue; + } + + is_link = S_ISLNK(st.st_mode); + is_dir = S_ISDIR(st.st_mode); + } else + continue; + + if (is_dir) { + int nfd, q; + char *p; + + if ((nfd = openat(fd, de->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW)) < 0) { + log_error("Failed to open %s/%s: %m", root, de->d_name); + + if (r == 0) + r = -errno; + continue; + } + + if (asprintf(&p, "%s/%s", root, de->d_name) < 0) { + log_error("Failed to allocate directory string."); + close_nointr_nofail(nfd); + r = -ENOMEM; + break; + } + + /* This will close nfd, regardless whether it succeeds or not */ + q = remove_marked_symlinks_fd(nfd, config_path, p, deleted); + free(p); + + if (r == 0) + r = q; + + } else if (is_link) { + char *p, *dest, *c; + int q; + + if (asprintf(&p, "%s/%s", root, de->d_name) < 0) { + log_error("Failed to allocate symlink string."); + r = -ENOMEM; + break; + } + + if ((q = readlink_and_make_absolute(p, &dest)) < 0) { + log_error("Cannot read symlink %s: %s", p, strerror(-q)); + free(p); + + if (r == 0) + r = q; + continue; + } + + if ((c = canonicalize_file_name(dest))) { + /* This might fail if the destination + * is already removed */ + + free(dest); + dest = c; + } + + path_kill_slashes(dest); + if (set_get(remove_symlinks_to, dest)) { + + if (!arg_quiet) + log_info("rm '%s'", p); + + if (unlink(p) < 0) { + log_error("Cannot unlink symlink %s: %m", p); + + if (r == 0) + r = -errno; + } else { + rmdir_parents(p, config_path); + path_kill_slashes(p); + + if (!set_get(remove_symlinks_to, p)) { + + if ((r = mark_symlink_for_removal(p)) < 0) { + if (r == 0) + r = q; + } else + *deleted = true; + } + } + } + + free(p); + free(dest); + } + } + + closedir(d); + + return r; +} + +static int remove_marked_symlinks(const char *config_path) { + int fd, r = 0; + bool deleted; + + assert(config_path); + + if (set_size(remove_symlinks_to) <= 0) + return 0; + + if ((fd = open(config_path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW)) < 0) + return -errno; + + do { + int q, cfd; + deleted = false; + + if ((cfd = dup(fd)) < 0) { + r = -errno; + break; + } + + /* This takes possession of cfd and closes it */ + if ((q = remove_marked_symlinks_fd(cfd, config_path, config_path, &deleted)) < 0) { + if (r == 0) + r = q; + } + } while (deleted); + + close_nointr_nofail(fd); + + return r; +} + +static int create_symlink(const char *verb, const char *old_path, const char *new_path) { + int r; + + assert(old_path); + assert(new_path); + assert(verb); + + if (streq(verb, "enable")) { + char *dest; + + mkdir_parents(new_path, 0755); + + if (symlink(old_path, new_path) >= 0) { + + if (!arg_quiet) + log_info("ln -s '%s' '%s'", old_path, new_path); + + return 0; + } + + if (errno != EEXIST) { + log_error("Cannot link %s to %s: %m", old_path, new_path); + return -errno; + } + + if ((r = readlink_and_make_absolute(new_path, &dest)) < 0) { + + if (errno == EINVAL) { + log_error("Cannot link %s to %s, file exists already and is not a symlink.", old_path, new_path); + return -EEXIST; + } + + log_error("readlink() failed: %s", strerror(-r)); + return r; + } + + if (streq(dest, old_path)) { + free(dest); + return 0; + } + + if (!arg_force) { + log_error("Cannot link %s to %s, symlink exists already and points to %s.", old_path, new_path, dest); + free(dest); + return -EEXIST; + } + + free(dest); + unlink(new_path); + + if (!arg_quiet) + log_info("ln -s '%s' '%s'", old_path, new_path); + + if (symlink(old_path, new_path) >= 0) + return 0; + + log_error("Cannot link %s to %s: %m", old_path, new_path); + return -errno; + + } else if (streq(verb, "disable")) { + char *dest; + + if ((r = mark_symlink_for_removal(old_path)) < 0) + return r; + + if ((r = readlink_and_make_absolute(new_path, &dest)) < 0) { + if (errno == ENOENT) + return 0; + + if (errno == EINVAL) { + log_warning("File %s not a symlink, ignoring.", old_path); + return 0; + } + + log_error("readlink() failed: %s", strerror(-r)); + return r; + } + + if (!streq(dest, old_path)) { + log_warning("File %s not a symlink to %s but points to %s, ignoring.", new_path, old_path, dest); + free(dest); + return 0; + } + + free(dest); + + if ((r = mark_symlink_for_removal(new_path)) < 0) + return r; + + if (!arg_quiet) + log_info("rm '%s'", new_path); + + if (unlink(new_path) >= 0) + return 0; + + log_error("Cannot unlink %s: %m", new_path); + return -errno; + + } else if (streq(verb, "is-enabled")) { + char *dest; + + if ((r = readlink_and_make_absolute(new_path, &dest)) < 0) { + + if (errno == ENOENT || errno == EINVAL) + return 0; + + log_error("readlink() failed: %s", strerror(-r)); + return r; + } + + if (streq(dest, old_path)) { + free(dest); + return 1; + } + + return 0; + } + + assert_not_reached("Unknown action."); +} + +static int install_info_symlink_alias(const char *verb, InstallInfo *i, const char *config_path) { + char **s; + char *alias_path = NULL; + int r; + + assert(verb); + assert(i); + assert(config_path); + + STRV_FOREACH(s, i->aliases) { + + free(alias_path); + if (!(alias_path = path_make_absolute(*s, config_path))) { + log_error("Out of memory"); + r = -ENOMEM; + goto finish; + } + + if ((r = create_symlink(verb, i->path, alias_path)) != 0) + goto finish; + + if (streq(verb, "disable")) + rmdir_parents(alias_path, config_path); + } + r = 0; + +finish: + free(alias_path); + + return r; +} + +static int install_info_symlink_wants(const char *verb, InstallInfo *i, const char *config_path) { + char **s; + char *alias_path = NULL; + int r; + + assert(verb); + assert(i); + assert(config_path); + + STRV_FOREACH(s, i->wanted_by) { + if (!unit_name_is_valid_no_type(*s, true)) { + log_error("Invalid name %s.", *s); + r = -EINVAL; + goto finish; + } + + free(alias_path); + alias_path = NULL; + + if (asprintf(&alias_path, "%s/%s.wants/%s", config_path, *s, i->name) < 0) { + log_error("Out of memory"); + r = -ENOMEM; goto finish; } - log_error("Failed to issue method call: %s", error.message); - r = -EIO; - goto finish; + if ((r = create_symlink(verb, i->path, alias_path)) != 0) + goto finish; + + if (streq(verb, "disable")) + rmdir_parents(alias_path, config_path); } - r = 1; + r = 0; finish: - if (m) - dbus_message_unref(m); - - if (reply) - dbus_message_unref(reply); - - dbus_error_free(&error); + free(alias_path); return r; } -static int show_enviroment(DBusConnection *bus, char **args, unsigned n) { - DBusMessage *m = NULL, *reply = NULL; - DBusError error; - DBusMessageIter iter, sub, sub2; +static int install_info_apply(const char *verb, LookupPaths *paths, InstallInfo *i, const char *config_path) { + + const ConfigItem items[] = { + { "Alias", config_parse_strv, &i->aliases, "Install" }, + { "WantedBy", config_parse_strv, &i->wanted_by, "Install" }, + { "Also", config_parse_also, NULL, "Install" }, + + { NULL, NULL, NULL, NULL } + }; + + char **p; + char *filename = NULL; + FILE *f = NULL; int r; - const char - *interface = "org.freedesktop.systemd1.Manager", - *property = "Environment"; - dbus_error_init(&error); + assert(paths); + assert(i); - 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; - } + STRV_FOREACH(p, paths->unit_path) { + int fd; - 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 (!(filename = path_make_absolute(i->name, *p))) { + log_error("Out of memory"); + return -ENOMEM; + } - if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { - log_error("Failed to issue method call: %s", error.message); - r = -EIO; - goto finish; + /* Ensure that we don't follow symlinks */ + if ((fd = open(filename, O_RDONLY|O_CLOEXEC|O_NOFOLLOW|O_NOCTTY)) >= 0) + if ((f = fdopen(fd, "re"))) + break; + + if (errno == ELOOP) { + log_error("Refusing to operate on symlinks, please pass unit names or absolute paths to unit files."); + free(filename); + return -errno; + } + + if (errno != ENOENT) { + log_error("Failed to open %s: %m", filename); + free(filename); + return -errno; + } + + free(filename); + filename = NULL; } - 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; + if (!f) { + log_error("Couldn't find %s.", i->name); + return -ENOENT; } - dbus_message_iter_recurse(&iter, &sub); + i->path = filename; - if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_ARRAY || - dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_STRING) { - log_error("Failed to parse reply."); - r = -EIO; - goto finish; + if ((r = config_parse(filename, f, NULL, items, true, i)) < 0) { + fclose(f); + return r; } - dbus_message_iter_recurse(&sub, &sub2); + n_symlinks += strv_length(i->aliases); + n_symlinks += strv_length(i->wanted_by); - while (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_INVALID) { - const char *text; + fclose(f); - if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_STRING) { - log_error("Failed to parse reply."); - r = -EIO; - goto finish; - } + if ((r = install_info_symlink_alias(verb, i, config_path)) != 0) + return r; - dbus_message_iter_get_basic(&sub2, &text); - printf("%s\n", text); + if ((r = install_info_symlink_wants(verb, i, config_path)) != 0) + return r; - dbus_message_iter_next(&sub2); - } + if ((r = mark_symlink_for_removal(filename)) < 0) + return r; - r = 0; + if ((r = remove_marked_symlinks(config_path)) < 0) + return r; -finish: - if (m) - dbus_message_unref(m); + return 0; +} - if (reply) - dbus_message_unref(reply); +static char *get_config_path(void) { - dbus_error_free(&error); + if (arg_session && arg_global) + return strdup(SESSION_CONFIG_UNIT_PATH); - return r; + if (arg_session) { + char *p; + + if (session_config_home(&p) < 0) + return NULL; + + return p; + } + + return strdup(SYSTEM_CONFIG_UNIT_PATH); } -static int set_environment(DBusConnection *bus, char **args, unsigned n) { - DBusMessage *m = NULL, *reply = NULL; +static int enable_unit(DBusConnection *bus, char **args, unsigned n) { DBusError error; int r; - const char *method; - DBusMessageIter iter, sub; - unsigned i; + LookupPaths paths; + char *config_path = NULL; + unsigned j; + InstallInfo *i; + const char *verb = args[0]; dbus_error_init(&error); - method = streq(args[0], "set-environment") - ? "SetEnvironment" - : "UnsetEnvironment"; - - if (!(m = dbus_message_new_method_call( - "org.freedesktop.systemd1", - "/org/freedesktop/systemd1", - "org.freedesktop.systemd1.Manager", - method))) { + zero(paths); + if ((r = lookup_paths_init(&paths, arg_session ? MANAGER_SESSION : MANAGER_SYSTEM)) < 0) { + log_error("Failed to determine lookup paths: %s", strerror(-r)); + goto finish; + } - log_error("Could not allocate message."); - return -ENOMEM; + if (!(config_path = get_config_path())) { + log_error("Failed to determine config path"); + r = -ENOMEM; + goto finish; } - dbus_message_iter_init_append(m, &iter); + will_install = hashmap_new(string_hash_func, string_compare_func); + have_installed = hashmap_new(string_hash_func, string_compare_func); - if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub)) { - log_error("Could not append arguments to message."); + if (!will_install || !have_installed) { + log_error("Failed to allocate unit sets."); r = -ENOMEM; goto finish; } - for (i = 1; i < n; i++) - if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &args[i])) { - log_error("Could not append arguments to message."); + if (!arg_defaults && streq(verb, "disable")) + if (!(remove_symlinks_to = set_new(string_hash_func, string_compare_func))) { + log_error("Failed to allocate symlink sets."); r = -ENOMEM; goto finish; } - if (!dbus_message_iter_close_container(&iter, &sub)) { - log_error("Could not append arguments to message."); - r = -ENOMEM; - goto finish; - } + for (j = 1; j < n; j++) + if ((r = install_info_add(args[j])) < 0) { + log_warning("Cannot install unit %s: %s", args[j], strerror(-r)); + goto finish; + } - if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { - log_error("Failed to issue method call: %s", error.message); - r = -EIO; - goto finish; + while ((i = hashmap_first(will_install))) { + int q; + + assert_se(hashmap_move_one(have_installed, will_install, i->name) == 0); + + if ((q = install_info_apply(verb, &paths, i, config_path)) != 0) { + + if (q < 0) { + if (r == 0) + r = q; + goto finish; + } + + /* In test mode and found something */ + r = 1; + break; + } } - r = 0; + if (streq(verb, "is-enabled")) + r = r > 0 ? 0 : -ENOENT; + else { + if (n_symlinks <= 0) + log_warning("Unit files contain no applicable installation information. Ignoring."); + + if (bus && + /* Don't try to reload anything if the user asked us to not do this */ + !arg_no_reload && + /* Don't try to reload anything when updating a unit globally */ + !arg_global && + /* Don't try to reload anything if we are called for system changes but the system wasn't booted with systemd */ + (arg_session || sd_booted() > 0) && + /* Don't try to reload anything if we are running in a chroot environment */ + (arg_session || running_in_chroot() <= 0) ) { + int q; + + if ((q = daemon_reload(bus, args, n)) < 0) + r = q; + } + } finish: - if (m) - dbus_message_unref(m); + install_info_hashmap_free(will_install); + install_info_hashmap_free(have_installed); - if (reply) - dbus_message_unref(reply); + set_free_free(remove_symlinks_to); - dbus_error_free(&error); + lookup_paths_free(&paths); + + free(config_path); return r; } @@ -2492,47 +3920,70 @@ finish: static int systemctl_help(void) { printf("%s [OPTIONS...] {COMMAND} ...\n\n" - "Send control commands to the systemd manager.\n\n" + "Send control commands to or query the systemd manager.\n\n" " -h --help Show this help\n" + " --version Show package version\n" " -t --type=TYPE List only units of a particular type\n" " -p --property=NAME Show only properties by this name\n" " -a --all Show all units/properties, including dead/empty ones\n" - " --fail When installing a new job, fail if conflicting jobs are pending\n" - " --system Connect to system bus\n" - " --session Connect to session bus\n" + " --full Don't ellipsize unit names on output\n" + " --fail When queueing a new job, fail if conflicting jobs are\n" + " pending\n" " -q --quiet Suppress output\n" " --no-block Do not wait until operation finished\n" - " --no-wall Don't send wall message before halt/power-off/reboot\n\n" + " --system Connect to system bus\n" + " --session Connect to session bus\n" + " --order When generating graph for dot, show only order\n" + " --require When generating graph for dot, show only requirement\n" + " --no-wall Don't send wall message before halt/power-off/reboot\n" + " --global Enable/disable unit files globally\n" + " --no-reload When enabling/disabling unit files, don't reload daemon\n" + " configuration\n" + " -f --force When enabling unit files, override existing symlinks\n" + " When shutting down, execute action immediately\n" + " --defaults When disabling unit files, remove default symlinks only\n\n" "Commands:\n" " list-units List units\n" - " start [NAME...] Start one or more units\n" - " stop [NAME...] Stop one or more units\n" - " restart [NAME...] Restart one or more units\n" + " start [NAME...] Start (activate) one or more units\n" + " stop [NAME...] Stop (deactivate) 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" + " otherwise start or restart\n" + " reload-or-try-restart [NAME...] Reload one or more units is possible,\n" + " otherwise restart if active\n" " isolate [NAME] Start one unit and stop all others\n" - " check [NAME...] Check whether any of the passed units are active\n" - " status [NAME...] Show status of one or more units\n" - " show [NAME...|JOB...] Show properties of one or more units/jobs/manager\n" + " is-active [NAME...] Check whether units are active\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" + " reset-failed [NAME...] Reset failed state for all, one, or more\n" + " units\n" + " enable [NAME...] Enable one or more unit files\n" + " disable [NAME...] Disable one or more unit files\n" + " is-enabled [NAME...] Check whether unit files are enabled\n" " load [NAME...] Load one or more units\n" " list-jobs List jobs\n" - " cancel [JOB...] Cancel one or more jobs\n" - " clear-jobs Cancel all jobs\n" + " cancel [JOB...] Cancel all, one, or more jobs\n" " monitor Monitor unit/job changes\n" " dump Dump server status\n" + " dot Dump dependency graph for dot(1)\n" " snapshot [NAME] Create a snapshot\n" " delete [NAME...] Remove one or more snapshots\n" " daemon-reload Reload systemd manager configuration\n" " daemon-reexec Reexecute systemd manager\n" - " daemon-exit Ask the systemd manager to quit\n" " show-environment Dump environment\n" " set-environment [NAME=VALUE...] Set one or more environment variables\n" " unset-environment [NAME...] Unset one or more environment variables\n" + " default Enter system default mode\n" + " rescue Enter system rescue mode\n" + " emergency Enter system emergency mode\n" " halt Shut down and halt the system\n" " poweroff Shut down and power-off the system\n" " reboot Shut down and reboot the system\n" - " default Enter default mode\n" - " rescue Enter rescue mode\n" - " emergency Enter emergency mode\n", + " kexec Shut down and reboot the system with kexec\n" + " exit Ask for session termination\n", program_invocation_short_name); return 0; @@ -2561,7 +4012,7 @@ static int halt_help(void) { static int shutdown_help(void) { - printf("%s [OPTIONS...] [now] [WALL...]\n\n" + printf("%s [OPTIONS...] [TIME] [WALL...]\n\n" "Shut down the system.\n\n" " --help Show this help\n" " -H --halt Halt the machine\n" @@ -2569,7 +4020,8 @@ static int shutdown_help(void) { " -r --reboot Reboot the machine\n" " -h Equivalent to --poweroff, overriden by --halt\n" " -k Don't halt/power-off/reboot, just send warnings\n" - " --no-wall Don't send wall message before halt/power-off/reboot\n", + " --no-wall Don't send wall message before halt/power-off/reboot\n" + " -c Cancel a pending shutdown\n", program_invocation_short_name); return 0; @@ -2607,24 +4059,39 @@ static int systemctl_parse_argv(int argc, char *argv[]) { enum { ARG_FAIL = 0x100, + ARG_VERSION, ARG_SESSION, ARG_SYSTEM, + ARG_GLOBAL, ARG_NO_BLOCK, - ARG_NO_WALL + ARG_NO_WALL, + ARG_ORDER, + ARG_REQUIRE, + ARG_FULL, + ARG_NO_RELOAD, + ARG_DEFAULTS }; static const struct option options[] = { - { "help", no_argument, NULL, 'h' }, - { "type", required_argument, NULL, 't' }, - { "property", required_argument, NULL, 'p' }, - { "all", no_argument, NULL, 'a' }, - { "fail", no_argument, NULL, ARG_FAIL }, - { "session", no_argument, NULL, ARG_SESSION }, - { "system", no_argument, NULL, ARG_SYSTEM }, - { "no-block", no_argument, NULL, ARG_NO_BLOCK }, - { "no-wall", no_argument, NULL, ARG_NO_WALL }, - { "quiet", no_argument, NULL, 'q' }, - { NULL, 0, NULL, 0 } + { "help", no_argument, NULL, 'h' }, + { "version", no_argument, NULL, ARG_VERSION }, + { "type", required_argument, NULL, 't' }, + { "property", required_argument, NULL, 'p' }, + { "all", no_argument, NULL, 'a' }, + { "full", no_argument, NULL, ARG_FULL }, + { "fail", no_argument, NULL, ARG_FAIL }, + { "session", no_argument, NULL, ARG_SESSION }, + { "system", no_argument, NULL, ARG_SYSTEM }, + { "global", no_argument, NULL, ARG_GLOBAL }, + { "no-block", no_argument, NULL, ARG_NO_BLOCK }, + { "no-wall", no_argument, NULL, ARG_NO_WALL }, + { "quiet", no_argument, NULL, 'q' }, + { "order", no_argument, NULL, ARG_ORDER }, + { "require", no_argument, NULL, ARG_REQUIRE }, + { "force", no_argument, NULL, 'f' }, + { "no-reload", no_argument, NULL, ARG_NO_RELOAD }, + { "defaults", no_argument, NULL, ARG_DEFAULTS }, + { NULL, 0, NULL, 0 } }; int c; @@ -2632,7 +4099,7 @@ static int systemctl_parse_argv(int argc, char *argv[]) { assert(argc >= 0); assert(argv); - while ((c = getopt_long(argc, argv, "ht:p:aq", options, NULL)) >= 0) { + while ((c = getopt_long(argc, argv, "ht:p:aqf", options, NULL)) >= 0) { switch (c) { @@ -2640,18 +4107,31 @@ static int systemctl_parse_argv(int argc, char *argv[]) { systemctl_help(); return 0; + case ARG_VERSION: + puts(PACKAGE_STRING); + puts(DISTRIBUTION); + puts(SYSTEMD_FEATURES); + return 0; + case 't': arg_type = optarg; break; - case 'p': - arg_property = optarg; + case 'p': { + char **l; + + if (!(l = strv_append(arg_property, optarg))) + return -ENOMEM; + + strv_free(arg_property); + arg_property = l; /* If the user asked for a particular * property, show it to him, even if it is * empty. */ arg_all = true; break; + } case 'a': arg_all = true; @@ -2677,10 +4157,39 @@ static int systemctl_parse_argv(int argc, char *argv[]) { arg_no_wall = true; break; + case ARG_ORDER: + arg_dot = DOT_ORDER; + break; + + case ARG_REQUIRE: + arg_dot = DOT_REQUIRE; + break; + + case ARG_FULL: + arg_full = true; + break; + case 'q': arg_quiet = true; break; + case 'f': + arg_force = true; + break; + + case ARG_NO_RELOAD: + arg_no_reload = true; + break; + + case ARG_GLOBAL: + arg_global = true; + arg_session = true; + break; + + case ARG_DEFAULTS: + arg_defaults = true; + break; + case '?': return -EINVAL; @@ -2736,7 +4245,8 @@ static int halt_parse_argv(int argc, char *argv[]) { break; case 'p': - arg_action = ACTION_POWEROFF; + if (arg_action != ACTION_REBOOT) + arg_action = ACTION_POWEROFF; break; case ARG_REBOOT: @@ -2785,6 +4295,56 @@ static int halt_parse_argv(int argc, char *argv[]) { return 1; } +static int parse_time_spec(const char *t, usec_t *_u) { + assert(t); + assert(_u); + + if (streq(t, "now")) + *_u = 0; + else if (t[0] == '+') { + uint64_t u; + + if (safe_atou64(t + 1, &u) < 0) + return -EINVAL; + + *_u = now(CLOCK_REALTIME) + USEC_PER_MINUTE * u; + } else { + char *e = NULL; + long hour, minute; + struct tm tm; + time_t s; + usec_t n; + + errno = 0; + hour = strtol(t, &e, 10); + if (errno != 0 || *e != ':' || hour < 0 || hour > 23) + return -EINVAL; + + minute = strtol(e+1, &e, 10); + if (errno != 0 || *e != 0 || minute < 0 || minute > 59) + return -EINVAL; + + n = now(CLOCK_REALTIME); + s = (time_t) (n / USEC_PER_SEC); + + zero(tm); + assert_se(localtime_r(&s, &tm)); + + tm.tm_hour = (int) hour; + tm.tm_min = (int) minute; + tm.tm_sec = 0; + + assert_se(s = mktime(&tm)); + + *_u = (usec_t) s * USEC_PER_SEC; + + while (*_u <= n) + *_u += USEC_PER_DAY; + } + + return 0; +} + static int shutdown_parse_argv(int argc, char *argv[]) { enum { @@ -2801,12 +4361,12 @@ static int shutdown_parse_argv(int argc, char *argv[]) { { NULL, 0, NULL, 0 } }; - int c; + int c, r; assert(argc >= 0); assert(argv); - while ((c = getopt_long(argc, argv, "HPrhkt:a", options, NULL)) >= 0) { + while ((c = getopt_long(argc, argv, "HPrhkt:afFc", options, NULL)) >= 0) { switch (c) { case ARG_HELP: @@ -2843,6 +4403,10 @@ static int shutdown_parse_argv(int argc, char *argv[]) { /* Compatibility nops */ break; + case 'c': + arg_action = ACTION_CANCEL_SHUTDOWN; + break; + case '?': return -EINVAL; @@ -2852,10 +4416,15 @@ static int shutdown_parse_argv(int argc, char *argv[]) { } } - if (argc > optind && !streq(argv[optind], "now")) - log_warning("First argument '%s' isn't 'now'. Ignoring.", argv[optind]); + if (argc > optind) { + if ((r = parse_time_spec(argv[optind], &arg_when)) < 0) { + log_error("Failed to parse time specification: %s", argv[optind]); + return r; + } + } else + arg_when = now(CLOCK_REALTIME) + USEC_PER_MINUTE; - /* We ignore the time argument */ + /* We skip the time argument */ if (argc > optind + 1) arg_wall = argv + optind + 1; @@ -3012,8 +4581,22 @@ static int parse_argv(int argc, char *argv[]) { arg_action = ACTION_POWEROFF; return shutdown_parse_argv(argc, argv); } else if (strstr(program_invocation_short_name, "init")) { - arg_action = ACTION_INVALID; - return telinit_parse_argv(argc, argv); + + if (sd_booted() > 0) { + arg_action = ACTION_INVALID; + return telinit_parse_argv(argc, argv); + } else { + /* Hmm, so some other init system is + * running, we need to forward this + * request to it. For now we simply + * guess that it is Upstart. */ + + execv("/lib/upstart/telinit", argv); + + log_error("Couldn't find an alternative telinit implementation to spawn."); + return -EIO; + } + } else if (strstr(program_invocation_short_name, "runlevel")) { arg_action = ACTION_RUNLEVEL; return runlevel_parse_argv(argc, argv); @@ -3069,7 +4652,7 @@ static int talk_upstart(void) { goto finish; } - log_error("Failed to connect to Upstart bus: %s", error.message); + log_error("Failed to connect to Upstart bus: %s", bus_error_message(&error)); r = -EIO; goto finish; } @@ -3109,16 +4692,16 @@ static int talk_upstart(void) { if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { if (error_is_no_service(&error)) { - r = 0; + r = -EADDRNOTAVAIL; goto finish; } - log_error("Failed to issue method call: %s", error.message); + log_error("Failed to issue method call: %s", bus_error_message(&error)); r = -EIO; goto finish; } - r = 1; + r = 0; finish: if (m) @@ -3128,6 +4711,7 @@ finish: dbus_message_unref(reply); if (bus) { + dbus_connection_flush(bus); dbus_connection_close(bus); dbus_connection_unref(bus); } @@ -3172,7 +4756,7 @@ static int talk_initctl(void) { return 1; } -static int systemctl_main(DBusConnection *bus, int argc, char *argv[]) { +static int systemctl_main(DBusConnection *bus, int argc, char *argv[], DBusError *error) { static const struct { const char* verb; @@ -3184,43 +4768,55 @@ static int systemctl_main(DBusConnection *bus, int argc, char *argv[]) { const int argc; int (* const dispatch)(DBusConnection *bus, char **args, unsigned n); } verbs[] = { - { "list-units", LESS, 1, list_units }, - { "list-jobs", EQUAL, 1, list_jobs }, - { "clear-jobs", EQUAL, 1, clear_jobs }, - { "load", MORE, 2, load_unit }, - { "cancel", MORE, 2, cancel_job }, - { "start", MORE, 2, start_unit }, - { "stop", MORE, 2, start_unit }, - { "reload", MORE, 2, start_unit }, - { "restart", MORE, 2, start_unit }, - { "isolate", EQUAL, 2, start_unit }, - { "check", MORE, 2, check_unit }, - { "show", MORE, 1, show }, - { "status", MORE, 2, show }, - { "monitor", EQUAL, 1, monitor }, - { "dump", EQUAL, 1, dump }, - { "snapshot", LESS, 2, snapshot }, - { "delete", MORE, 2, delete_snapshot }, - { "daemon-reload", EQUAL, 1, clear_jobs }, - { "daemon-reexec", EQUAL, 1, clear_jobs }, - { "daemon-exit", EQUAL, 1, clear_jobs }, - { "show-environment", EQUAL, 1, show_enviroment }, - { "set-environment", MORE, 2, set_environment }, - { "unset-environment", MORE, 2, set_environment }, - { "halt", EQUAL, 1, start_special }, - { "poweroff", EQUAL, 1, start_special }, - { "reboot", EQUAL, 1, start_special }, - { "default", EQUAL, 1, start_special }, - { "rescue", EQUAL, 1, start_special }, - { "emergency", EQUAL, 1, start_special } + { "list-units", LESS, 1, list_units }, + { "list-jobs", EQUAL, 1, list_jobs }, + { "clear-jobs", EQUAL, 1, daemon_reload }, + { "load", MORE, 2, load_unit }, + { "cancel", MORE, 2, cancel_job }, + { "start", MORE, 2, start_unit }, + { "stop", MORE, 2, start_unit }, + { "reload", MORE, 2, start_unit }, + { "restart", MORE, 2, start_unit }, + { "try-restart", MORE, 2, start_unit }, + { "reload-or-restart", MORE, 2, start_unit }, + { "reload-or-try-restart", MORE, 2, start_unit }, + { "force-reload", MORE, 2, start_unit }, /* For compatibility with SysV */ + { "condrestart", MORE, 2, start_unit }, /* For compatibility with RH */ + { "isolate", EQUAL, 2, start_unit }, + { "is-active", MORE, 2, check_unit }, + { "check", MORE, 2, check_unit }, + { "show", MORE, 1, show }, + { "status", MORE, 2, show }, + { "monitor", EQUAL, 1, monitor }, + { "dump", EQUAL, 1, dump }, + { "dot", EQUAL, 1, dot }, + { "snapshot", LESS, 2, snapshot }, + { "delete", MORE, 2, delete_snapshot }, + { "daemon-reload", EQUAL, 1, daemon_reload }, + { "daemon-reexec", EQUAL, 1, daemon_reload }, + { "show-environment", EQUAL, 1, show_enviroment }, + { "set-environment", MORE, 2, set_environment }, + { "unset-environment", MORE, 2, set_environment }, + { "halt", EQUAL, 1, start_special }, + { "poweroff", EQUAL, 1, start_special }, + { "reboot", EQUAL, 1, start_special }, + { "kexec", EQUAL, 1, start_special }, + { "default", EQUAL, 1, start_special }, + { "rescue", EQUAL, 1, start_special }, + { "emergency", EQUAL, 1, start_special }, + { "exit", EQUAL, 1, start_special }, + { "reset-failed", MORE, 1, reset_failed }, + { "enable", MORE, 2, enable_unit }, + { "disable", MORE, 2, enable_unit }, + { "is-enabled", MORE, 2, enable_unit } }; int left; unsigned i; - assert(bus); assert(argc >= 0); assert(argv); + assert(error); left = argc - optind; @@ -3273,15 +4869,66 @@ static int systemctl_main(DBusConnection *bus, int argc, char *argv[]) { assert_not_reached("Unknown comparison operator."); } + /* Require a bus connection for all operations but + * enable/disable */ + if (!streq(verbs[i].verb, "enable") && + !streq(verbs[i].verb, "disable") && + !bus) { + log_error("Failed to get D-Bus connection: %s", error->message); + return -EIO; + } + return verbs[i].dispatch(bus, argv + optind, left); } +static int send_shutdownd(usec_t t, char mode, bool warn, const char *message) { + int fd = -1; + struct msghdr msghdr; + struct iovec iovec; + union sockaddr_union sockaddr; + struct shutdownd_command c; + + zero(c); + c.elapse = t; + c.mode = mode; + c.warn_wall = warn; + + if (message) + strncpy(c.wall_message, message, sizeof(c.wall_message)); + + if ((fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0)) < 0) + return -errno; + + zero(sockaddr); + sockaddr.sa.sa_family = AF_UNIX; + sockaddr.un.sun_path[0] = 0; + strncpy(sockaddr.un.sun_path+1, "/org/freedesktop/systemd1/shutdownd", sizeof(sockaddr.un.sun_path)-1); + + zero(iovec); + iovec.iov_base = (char*) &c; + iovec.iov_len = sizeof(c); + + zero(msghdr); + msghdr.msg_name = &sockaddr; + msghdr.msg_namelen = offsetof(struct sockaddr_un, sun_path) + 1 + sizeof("/org/freedesktop/systemd1/shutdownd") - 1; + + msghdr.msg_iov = &iovec; + msghdr.msg_iovlen = 1; + + if (sendmsg(fd, &msghdr, MSG_NOSIGNAL) < 0) { + close_nointr_nofail(fd); + return -errno; + } + + close_nointr_nofail(fd); + return 0; +} + static int reload_with_fallback(DBusConnection *bus) { - int r; if (bus) { /* First, try systemd via D-Bus. */ - if ((r = clear_jobs(bus, NULL, 0)) > 0) + if (daemon_reload(bus, NULL, 0) > 0) return 0; } @@ -3297,23 +4944,21 @@ static int reload_with_fallback(DBusConnection *bus) { } static int start_with_fallback(DBusConnection *bus) { - int r; - if (bus) { /* First, try systemd via D-Bus. */ - if ((r = start_unit(bus, NULL, 0)) > 0) - goto done; - - /* Hmm, talking to systemd via D-Bus didn't work. Then - * let's try to talk to Upstart via D-Bus. */ - if ((r = talk_upstart()) > 0) + if (start_unit(bus, NULL, 0) >= 0) goto done; } + /* Hmm, talking to systemd via D-Bus didn't work. Then + * let's try to talk to Upstart via D-Bus. */ + if (talk_upstart() > 0) + goto done; + /* Nothing else worked, so let's try * /dev/initctl */ - if ((r = talk_initctl()) != 0) + if (talk_initctl() > 0) goto done; log_error("Failed to talk to init daemon."); @@ -3328,16 +4973,41 @@ static int halt_main(DBusConnection *bus) { int r; if (geteuid() != 0) { - log_error("Must to be root."); + log_error("Must be root."); return -EPERM; } + if (arg_when > 0) { + char *m; + char date[FORMAT_TIMESTAMP_MAX]; + + m = strv_join(arg_wall, " "); + r = send_shutdownd(arg_when, + arg_action == ACTION_HALT ? 'H' : + arg_action == ACTION_POWEROFF ? 'P' : + 'r', + !arg_no_wall, + m); + free(m); + + if (r < 0) + log_warning("Failed to talk to shutdownd, proceeding with immediate shutdown: %s", strerror(-r)); + else { + log_info("Shutdown scheduled for %s, use 'shutdown -c' to cancel.", + format_timestamp(date, sizeof(date), arg_when)); + return 0; + } + } + if (!arg_dry && !arg_immediate) return start_with_fallback(bus); - if (!arg_no_wtmp) - if ((r = utmp_put_shutdown(0)) < 0) + if (!arg_no_wtmp) { + if (sd_booted() > 0) + log_debug("Not writing utmp record, assuming that systemd-update-utmp is used."); + else if ((r = utmp_put_shutdown(0)) < 0) log_warning("Failed to write utmp record: %s", strerror(-r)); + } if (!arg_no_sync) sync(); @@ -3352,17 +5022,17 @@ static int halt_main(DBusConnection *bus) { switch (arg_action) { case ACTION_HALT: - log_info("Halting"); + log_info("Halting."); reboot(RB_HALT_SYSTEM); break; case ACTION_POWEROFF: - log_info("Powering off"); + log_info("Powering off."); reboot(RB_POWER_OFF); break; case ACTION_REBOOT: - log_info("Rebooting"); + log_info("Rebooting."); reboot(RB_AUTOBOOT); break; @@ -3378,7 +5048,7 @@ static int runlevel_main(void) { int r, runlevel, previous; if ((r = utmp_get_runlevel(&runlevel, &previous)) < 0) { - printf("unknown"); + printf("unknown\n"); return r; } @@ -3390,25 +5060,27 @@ static int runlevel_main(void) { } int main(int argc, char*argv[]) { - int r, retval = 1; + int r, retval = EXIT_FAILURE; DBusConnection *bus = NULL; DBusError error; dbus_error_init(&error); log_parse_environment(); + log_open(); if ((r = parse_argv(argc, argv)) < 0) goto finish; else if (r == 0) { - retval = 0; + retval = EXIT_SUCCESS; goto finish; } /* /sbin/runlevel doesn't need to communicate via D-Bus, so * let's shortcut this */ if (arg_action == ACTION_RUNLEVEL) { - retval = runlevel_main() < 0; + r = runlevel_main(); + retval = r < 0 ? EXIT_FAILURE : r; goto finish; } @@ -3416,21 +5088,14 @@ int main(int argc, char*argv[]) { switch (arg_action) { - case ACTION_SYSTEMCTL: { - - if (!bus) { - log_error("Failed to get D-Bus connection: %s", error.message); - goto finish; - } - - retval = systemctl_main(bus, argc, argv) < 0; + case ACTION_SYSTEMCTL: + r = systemctl_main(bus, argc, argv, &error); break; - } case ACTION_HALT: case ACTION_POWEROFF: case ACTION_REBOOT: - retval = halt_main(bus) < 0; + r = halt_main(bus); break; case ACTION_RUNLEVEL2: @@ -3440,12 +5105,16 @@ int main(int argc, char*argv[]) { case ACTION_RESCUE: case ACTION_EMERGENCY: case ACTION_DEFAULT: - retval = start_with_fallback(bus) < 0; + r = start_with_fallback(bus); break; case ACTION_RELOAD: case ACTION_REEXEC: - retval = reload_with_fallback(bus) < 0; + r = reload_with_fallback(bus); + break; + + case ACTION_CANCEL_SHUTDOWN: + r = send_shutdownd(0, 0, false, NULL); break; case ACTION_INVALID: @@ -3454,9 +5123,12 @@ int main(int argc, char*argv[]) { assert_not_reached("Unknown action"); } + retval = r < 0 ? EXIT_FAILURE : r; + finish: if (bus) { + dbus_connection_flush(bus); dbus_connection_close(bus); dbus_connection_unref(bus); } @@ -3465,5 +5137,7 @@ finish: dbus_shutdown(); + strv_free(arg_property); + return retval; }