X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fsystemctl.c;h=63d5d9cd9f3fae168de878955becde144f38d35d;hp=aad9ba039b32498765465def338d88d4e33e67fa;hb=ebf57b80c37c3931ec7503b63da1a34f702d9cca;hpb=ef2f1067d0ca0e6d7346aa3e082048821b670b54 diff --git a/src/systemctl.c b/src/systemctl.c index aad9ba039..63d5d9cd9 100644 --- a/src/systemctl.c +++ b/src/systemctl.c @@ -28,6 +28,8 @@ #include #include #include +#include +#include #include @@ -36,16 +38,22 @@ #include "macro.h" #include "set.h" #include "utmp-wtmp.h" +#include "special.h" +#include "initreq.h" +#include "strv.h" static const char *arg_type = NULL; +static const char *arg_property = NULL; static bool arg_all = false; static bool arg_replace = false; static bool arg_session = false; -static bool arg_block = false; +static bool arg_no_block = false; static bool arg_immediate = false; static bool arg_no_wtmp = false; static bool arg_no_sync = false; +static bool arg_no_wall = false; static bool arg_dry = false; +static bool arg_quiet = false; static char **arg_wall = NULL; enum action { ACTION_INVALID, @@ -58,6 +66,8 @@ enum action { ACTION_RUNLEVEL4, ACTION_RUNLEVEL5, ACTION_RESCUE, + ACTION_EMERGENCY, + ACTION_DEFAULT, ACTION_RELOAD, ACTION_REEXEC, ACTION_RUNLEVEL, @@ -66,6 +76,8 @@ enum action { static bool error_is_no_service(DBusError *error) { + assert(error); + if (!dbus_error_is_set(error)) return false; @@ -80,6 +92,9 @@ static bool error_is_no_service(DBusError *error) { static int bus_iter_get_basic_and_next(DBusMessageIter *iter, int type, void *data, bool next) { + assert(iter); + assert(data); + if (dbus_message_iter_get_arg_type(iter) != type) return -EIO; @@ -91,6 +106,32 @@ static int bus_iter_get_basic_and_next(DBusMessageIter *iter, int type, void *da return 0; } +static int bus_check_peercred(DBusConnection *c) { + int fd; + struct ucred ucred; + socklen_t l; + + assert(c); + + assert_se(dbus_connection_get_unix_fd(c, &fd)); + + l = sizeof(struct ucred); + if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0) { + log_error("SO_PEERCRED failed: %m"); + return -errno; + } + + if (l != sizeof(struct ucred)) { + log_error("SO_PEERCRED returned wrong size."); + return -E2BIG; + } + + if (ucred.uid != 0) + return -EPERM; + + return 1; +} + static int columns(void) { static int parsed_columns = 0; const char *e; @@ -116,18 +157,39 @@ static int columns(void) { } -static void warn_wall(void) { +static void warn_wall(enum action action) { static const char *table[_ACTION_MAX] = { - [ACTION_HALT] = "The system is going down for system halt NOW!", - [ACTION_REBOOT] = "The system is going down for reboot NOW!", - [ACTION_POWEROFF] = "The system is going down for power-off NOW!", - [ACTION_RESCUE] = "The system is going down to rescue mode NOW!" + [ACTION_HALT] = "The system is going down for system halt NOW!", + [ACTION_REBOOT] = "The system is going down for reboot NOW!", + [ACTION_POWEROFF] = "The system is going down for power-off NOW!", + [ACTION_RESCUE] = "The system is going down to rescue mode NOW!", + [ACTION_EMERGENCY] = "The system is going down to emergency mode NOW!" }; - if (!table[arg_action]) + if (arg_no_wall) + return; + + if (arg_wall) { + char *p; + + if (!(p = strv_join(arg_wall, " "))) { + log_error("Failed to join strings."); + return; + } + + if (*p) { + utmp_wall(p); + free(p); + return; + } + + free(p); + } + + if (!table[action]) return; - utmp_wall(table[arg_action]); + utmp_wall(table[action]); } static int list_units(DBusConnection *bus, char **args, unsigned n) { @@ -139,6 +201,8 @@ static int list_units(DBusConnection *bus, char **args, unsigned n) { dbus_error_init(&error); + assert(bus); + if (!(m = dbus_message_new_method_call( "org.freedesktop.systemd1", "/org/freedesktop/systemd1", @@ -247,6 +311,8 @@ static int list_jobs(DBusConnection *bus, char **args, unsigned n) { dbus_error_init(&error); + assert(bus); + if (!(m = dbus_message_new_method_call( "org.freedesktop.systemd1", "/org/freedesktop/systemd1", @@ -326,6 +392,9 @@ static int load_unit(DBusConnection *bus, char **args, unsigned n) { dbus_error_init(&error); + assert(bus); + assert(args); + for (i = 1; i < n; i++) { if (!(m = dbus_message_new_method_call( @@ -380,6 +449,9 @@ static int cancel_job(DBusConnection *bus, char **args, unsigned n) { dbus_error_init(&error); + assert(bus); + assert(args); + for (i = 1; i < n; i++) { unsigned id; const char *path; @@ -459,13 +531,18 @@ finish: return r; } +typedef struct WaitData { + Set *set; + bool failed; +} WaitData; + static DBusHandlerResult wait_filter(DBusConnection *connection, DBusMessage *message, void *data) { DBusError error; - Set *s = data; + WaitData *d = data; assert(connection); assert(message); - assert(s); + assert(d); dbus_error_init(&error); @@ -481,17 +558,22 @@ static DBusHandlerResult wait_filter(DBusConnection *connection, DBusMessage *me } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobRemoved")) { uint32_t id; const char *path; + dbus_bool_t success = true; if (!dbus_message_get_args(message, &error, DBUS_TYPE_UINT32, &id, DBUS_TYPE_OBJECT_PATH, &path, + DBUS_TYPE_BOOLEAN, &success, DBUS_TYPE_INVALID)) log_error("Failed to parse message: %s", error.message); else { char *p; - if ((p = set_remove(s, (char*) path))) + if ((p = set_remove(d->set, (char*) path))) free(p); + + if (!success) + d->failed = true; } } @@ -556,11 +638,16 @@ finish: static int wait_for_jobs(DBusConnection *bus, Set *s) { int r; + WaitData d; assert(bus); assert(s); - if (!dbus_connection_add_filter(bus, wait_filter, s, NULL)) { + zero(d); + d.set = s; + d.failed = false; + + if (!dbus_connection_add_filter(bus, wait_filter, &d, NULL)) { log_error("Failed to add filter."); r = -ENOMEM; goto finish; @@ -570,7 +657,10 @@ static int wait_for_jobs(DBusConnection *bus, Set *s) { dbus_connection_read_write_dispatch(bus, -1)) ; - r = 0; + if (!arg_quiet && d.failed) + log_error("Job failed, see logs for details."); + + r = d.failed ? -EIO : 0; finish: /* This is slightly dirty, since we don't undo the filter registration. */ @@ -593,7 +683,7 @@ static int start_unit_one( assert(method); assert(name); assert(mode); - assert(!arg_block || s); + assert(arg_no_block || s); dbus_error_init(&error); @@ -630,7 +720,7 @@ static int start_unit_one( goto finish; } - if (arg_block) { + if (!arg_no_block) { const char *path; char *p; @@ -669,75 +759,578 @@ finish: return r; } +static enum action verb_to_action(const char *verb) { + if (streq(verb, "halt")) + return ACTION_HALT; + else if (streq(verb, "poweroff")) + return ACTION_POWEROFF; + else if (streq(verb, "reboot")) + return ACTION_REBOOT; + 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 + return ACTION_INVALID; +} + static int start_unit(DBusConnection *bus, char **args, unsigned n) { static const char * const table[_ACTION_MAX] = { - [ACTION_HALT] = "halt.target", - [ACTION_POWEROFF] = "poweroff.target", - [ACTION_REBOOT] = "reboot.target", - [ACTION_RUNLEVEL2] = "runlevel2.target", - [ACTION_RUNLEVEL3] = "runlevel3.target", - [ACTION_RUNLEVEL4] = "runlevel4.target", - [ACTION_RUNLEVEL5] = "runlevel5.target", - [ACTION_RESCUE] = "rescue.target" + [ACTION_HALT] = SPECIAL_HALT_TARGET, + [ACTION_POWEROFF] = SPECIAL_POWEROFF_TARGET, + [ACTION_REBOOT] = SPECIAL_REBOOT_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 }; int r; unsigned i; - const char *method, *mode; + const char *method, *mode, *one_name; Set *s = NULL; - if (arg_action == ACTION_SYSTEMCTL) { - method = - streq(args[0], "start") ? "StartUnit" : - streq(args[0], "stop") ? "StopUnit" : - streq(args[0], "reload") ? "ReloadUnit" : - streq(args[0], "restart") ? "RestartUnit" : - /* isolate */ "StartUnit"; + assert(bus); + + if (arg_action == ACTION_SYSTEMCTL) { + method = + streq(args[0], "stop") ? "StopUnit" : + streq(args[0], "reload") ? "ReloadUnit" : + streq(args[0], "restart") ? "RestartUnit" : + "StartUnit"; + + mode = + (streq(args[0], "isolate") || + streq(args[0], "rescue") || + streq(args[0], "emergency")) ? "isolate" : + arg_replace ? "replace" : + "fail"; + + one_name = table[verb_to_action(args[0])]; + + } else { + assert(arg_action < ELEMENTSOF(table)); + assert(table[arg_action]); + + method = "StartUnit"; + + mode = (arg_action == ACTION_EMERGENCY || + arg_action == ACTION_RESCUE) ? "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)); + goto finish; + } + + if (!(s = set_new(string_hash_func, string_compare_func))) { + log_error("Failed to allocate set."); + r = -ENOMEM; + goto finish; + } + } + + r = 0; + + if (one_name) { + if ((r = start_unit_one(bus, method, one_name, mode, 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 (!arg_no_block) + r = wait_for_jobs(bus, s); + +finish: + if (s) + set_free_free(s); + + return r; +} + +static int start_special(DBusConnection *bus, char **args, unsigned n) { + assert(bus); + assert(args); + + warn_wall(verb_to_action(args[0])); + + return start_unit(bus, args, n); +} + +static int check_unit(DBusConnection *bus, char **args, unsigned n) { + DBusMessage *m = NULL, *reply = NULL; + const char + *interface = "org.freedesktop.systemd1.Unit", + *property = "ActiveState"; + int r = -EADDRNOTAVAIL; + DBusError error; + unsigned i; + + assert(bus); + assert(args); + + dbus_error_init(&error); + + for (i = 1; i < n; i++) { + const char *path = NULL; + const char *state; + DBusMessageIter iter, sub; + + if (!(m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "GetUnit"))) { + log_error("Could not allocate message."); + r = -ENOMEM; + goto finish; + } + + if (!dbus_message_append_args(m, + DBUS_TYPE_STRING, &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))) { + + /* Hmm, cannot figure out anything about this unit... */ + if (!arg_quiet) + puts("unknown"); + + continue; + } + + 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; + } + + dbus_message_unref(m); + if (!(m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + path, + "org.freedesktop.DBus.Properties", + "Get"))) { + log_error("Could not allocate message."); + r = -ENOMEM; + goto finish; + } + + if (!dbus_message_append_args(m, + DBUS_TYPE_STRING, &interface, + DBUS_TYPE_STRING, &property, + DBUS_TYPE_INVALID)) { + log_error("Could not append arguments to message."); + r = -ENOMEM; + goto finish; + } + + dbus_message_unref(reply); + if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { + log_error("Failed to issue method call: %s", error.message); + 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_STRING) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } + + dbus_message_iter_get_basic(&sub, &state); + + if (!arg_quiet) + puts(state); + + if (streq(state, "active") || startswith(state, "reloading")) + r = 0; + + dbus_message_unref(m); + dbus_message_unref(reply); + m = reply = NULL; + } + +finish: + if (m) + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); + + dbus_error_free(&error); + + return r; +} + +static int print_property(const char *name, DBusMessageIter *iter) { + assert(name); + assert(iter); + + if (arg_property && !streq(name, arg_property)) + return 0; + + switch (dbus_message_iter_get_arg_type(iter)) { + + case DBUS_TYPE_STRING: { + const char *s; + dbus_message_iter_get_basic(iter, &s); + + if (arg_all || s[0]) + printf("%s=%s\n", name, s); + + return 0; + } + + case DBUS_TYPE_BOOLEAN: { + dbus_bool_t b; + dbus_message_iter_get_basic(iter, &b); + printf("%s=%s\n", name, yes_no(b)); + + return 0; + } + + case DBUS_TYPE_UINT64: { + uint64_t u; + dbus_message_iter_get_basic(iter, &u); + + /* Yes, heuristics! But we can change this check + * should it turn out to not be sufficient */ + + if (strstr(name, "Timestamp")) { + char timestamp[FORMAT_TIMESTAMP_MAX], *t; + + if ((t = format_timestamp(timestamp, sizeof(timestamp), u)) || arg_all) + printf("%s=%s\n", name, strempty(t)); + } else + printf("%s=%llu\n", name, (unsigned long long) u); + + return 0; + } + + case DBUS_TYPE_UINT32: { + uint32_t u; + dbus_message_iter_get_basic(iter, &u); + + if (strstr(name, "UMask")) + printf("%s=%04o\n", name, u); + else + printf("%s=%u\n", name, (unsigned) u); + + return 0; + } + + case DBUS_TYPE_INT32: { + int32_t i; + dbus_message_iter_get_basic(iter, &i); + + printf("%s=%i\n", name, (int) i); + return 0; + } + + case DBUS_TYPE_STRUCT: { + DBusMessageIter sub; + dbus_message_iter_recurse(iter, &sub); + + if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_UINT32 && streq(name, "Job")) { + uint32_t u; + + dbus_message_iter_get_basic(&sub, &u); + + if (u) + printf("%s=%u\n", name, (unsigned) u); + else if (arg_all) + printf("%s=\n", name); + + return 0; + } else if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "Unit")) { + const char *s; + + dbus_message_iter_get_basic(&sub, &s); + + if (arg_all || s[0]) + printf("%s=%s\n", name, s); + + return 0; + } + + break; + } + + case DBUS_TYPE_ARRAY: + + if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRING) { + DBusMessageIter sub; + bool space = false; + + dbus_message_iter_recurse(iter, &sub); + + if (arg_all || + dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { + printf("%s=", name); + + while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { + const char *s; + + assert(dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING); + dbus_message_iter_get_basic(&sub, &s); + printf("%s%s", space ? " " : "", s); + + space = true; + dbus_message_iter_next(&sub); + } + + puts(""); + } + + return 0; + + } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Paths")) { + DBusMessageIter sub, sub2; + + dbus_message_iter_recurse(iter, &sub); + + while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) { + const char *type, *path; + + dbus_message_iter_recurse(&sub, &sub2); + + if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) >= 0 && + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, false) >= 0) + printf("%s=%s\n", type, path); + + dbus_message_iter_next(&sub); + } + + return 0; + } + + break; + } + + if (arg_all) + printf("%s=[unprintable]\n", name); + + return 0; +} + +static int show_one(DBusConnection *bus, const char *path) { + DBusMessage *m = NULL, *reply = NULL; + const char *interface = ""; + 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", error.message); + 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 *name; + + 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, &name, 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); + + if (print_property(name, &sub3) < 0) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } + + dbus_message_iter_next(&sub); + } + + r = 0; + +finish: + if (m) + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); + + dbus_error_free(&error); + + return r; +} + +static int show(DBusConnection *bus, char **args, unsigned n) { + DBusMessage *m = NULL, *reply = NULL; + int r; + DBusError error; + unsigned i; + + assert(bus); + assert(args); + + dbus_error_init(&error); + + if (n <= 1) { + /* If not argument is specified inspect the manager + * itself */ + + r = show_one(bus, "/org/freedesktop/systemd1"); + goto finish; + } + + for (i = 1; i < n; i++) { + const char *path = NULL; + uint32_t id; - mode = - streq(args[0], "isolate") ? "isolate" : - arg_replace ? "replace" : - "fail"; + if (safe_atou32(args[i], &id) < 0) { - if (arg_block) { - if ((r = enable_wait_for_jobs(bus)) < 0) { - log_error("Could not watch jobs: %s", strerror(-r)); + if (!(m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "GetUnit"))) { + log_error("Could not allocate message."); + r = -ENOMEM; goto finish; } - if (!(s = set_new(string_hash_func, string_compare_func))) { - log_error("Failed to allocate set."); + 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; } - } - } else { - assert(arg_action < ELEMENTSOF(table)); - assert(table[arg_action]); - method = "StartUnit"; - mode = arg_action == ACTION_RESCUE ? "isolate" : "replace"; - } + } else { - r = 0; + if (!(m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "GetJob"))) { + log_error("Could not allocate message."); + r = -ENOMEM; + goto finish; + } - if (arg_action == ACTION_SYSTEMCTL) { - for (i = 1; i < n; i++) - if ((r = start_unit_one(bus, method, args[i], mode, s)) < 0) + if (!dbus_message_append_args(m, + DBUS_TYPE_UINT32, &id, + DBUS_TYPE_INVALID)) { + log_error("Could not append arguments to message."); + r = -ENOMEM; goto finish; + } + } + + if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { + log_error("Failed to issue method call: %s", error.message); + r = -EIO; + goto finish; + } - if (arg_block) - r = wait_for_jobs(bus, s); + 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; + } - } else { - if ((r = start_unit_one(bus, method, table[arg_action], mode, s)) <= 0) + if ((r = show_one(bus, path)) < 0) goto finish; + + dbus_message_unref(m); + dbus_message_unref(reply); + m = reply = NULL; } + r = 0; + finish: - if (s) - set_free_free(s); + if (m) + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); + + dbus_error_free(&error); return r; } @@ -1098,7 +1691,92 @@ static int snapshot(DBusConnection *bus, char **args, unsigned n) { } dbus_message_iter_get_basic(&sub, &id); - puts(id); + + if (!arg_quiet) + puts(id); + r = 0; + +finish: + if (m) + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); + + dbus_error_free(&error); + + return r; +} + +static int delete_snapshot(DBusConnection *bus, char **args, unsigned n) { + DBusMessage *m = NULL, *reply = NULL; + int r; + DBusError error; + unsigned i; + + assert(bus); + assert(args); + + dbus_error_init(&error); + + for (i = 1; i < n; i++) { + const char *path = NULL; + + if (!(m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "GetUnit"))) { + log_error("Could not allocate message."); + r = -ENOMEM; + goto finish; + } + + if (!dbus_message_append_args(m, + DBUS_TYPE_STRING, &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", error.message); + 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", error.message); + r = -EIO; + goto finish; + } + + dbus_message_unref(m); + if (!(m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + path, + "org.freedesktop.systemd1.Snapshot", + "Remove"))) { + log_error("Could not allocate message."); + r = -ENOMEM; + goto finish; + } + + dbus_message_unref(reply); + if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { + log_error("Failed to issue method call: %s", error.message); + r = -EIO; + goto finish; + } + + dbus_message_unref(m); + dbus_message_unref(reply); + m = reply = NULL; + } + r = 0; finish: @@ -1321,35 +1999,47 @@ finish: static int systemctl_help(void) { - printf("%s [options]\n\n" - "Send control commands to the init system.\n\n" - " -h --help Show this help\n" - " -t --type=TYPE List only units of a particular type\n" - " -a --all Show all units, including dead ones\n" - " --replace When installing a new job, replace existing conflicting ones\n" - " --system Connect to system bus\n" - " --session Connect to session bus\n" - " --block Wait until operation finished\n\n" + printf("%s [OPTIONS...] {COMMAND} ...\n\n" + "Send control commands to the systemd manager.\n\n" + " -h --help Show this help\n" + " -t --type=TYPE List only units of a particular type\n" + " -p --property=NAME Show only property by this name\n" + " -a --all Show all units/properties, including dead/empty ones\n" + " --replace When installing a new job, replace existing conflicting ones\n" + " --system Connect to system bus\n" + " --session Connect to session bus\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" "Commands:\n" " list-units List units\n" - " list-jobs List jobs\n" - " clear-jobs Cancel all jobs\n" - " load [NAME...] Load one or more units\n" - " cancel [JOB...] Cancel one or more jobs\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" " reload [NAME...] Reload one or more units\n" " isolate [NAME] Start one unit and stop all others\n" + " check [NAME...] Check whether any of the passed units are active\n" + " show [NAME...|JOB...] Show information about one or more units\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" " monitor Monitor unit/job changes\n" " dump Dump server status\n" " snapshot [NAME] Create a snapshot\n" - " daemon-reload Reload daemon configuration\n" - " daemon-reexecute Reexecute daemon\n" - " daemon-exit Ask the daemon to quit\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", + " unset-environment [NAME...] Unset one or more environment variables\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", program_invocation_short_name); return 0; @@ -1357,16 +2047,17 @@ static int systemctl_help(void) { static int halt_help(void) { - printf("%s [options]\n\n" + printf("%s [OPTIONS...]\n\n" "%s the system.\n\n" " --help Show this help\n" " --halt Halt the machine\n" " -p --poweroff Switch off the machine\n" " --reboot Reboot the machine\n" - " -f --force Force immediate reboot/halt/power-off\n" - " -w --wtmp-only Don't reboot/halt/power-off, just write wtmp record\n" + " -f --force Force immediate halt/power-off/reboot\n" + " -w --wtmp-only Don't halt/power-off/reboot, just write wtmp record\n" " -d --no-wtmp Don't write wtmp record\n" - " -n --no-sync Don't sync before reboot/halt/power-off\n", + " -n --no-sync Don't sync before halt/power-off/reboot\n" + " --no-wall Don't send wall message before halt/power-off/reboot\n", program_invocation_short_name, arg_action == ACTION_REBOOT ? "Reboot" : arg_action == ACTION_POWEROFF ? "Power off" : @@ -1377,14 +2068,15 @@ static int halt_help(void) { static int shutdown_help(void) { - printf("%s [options] [TIME] [WALL...]\n\n" + printf("%s [OPTIONS...] [now] [WALL...]\n\n" "Shut down the system.\n\n" " --help Show this help\n" " -H --halt Halt the machine\n" " -P --poweroff Power-off the machine\n" " -r --reboot Reboot the machine\n" " -h Equivalent to --poweroff, overriden by --halt\n" - " -k Don't reboot/halt/power-off, just send warnings\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", program_invocation_short_name); return 0; @@ -1392,16 +2084,17 @@ static int shutdown_help(void) { static int telinit_help(void) { - printf("%s [options]\n\n" - "Send control commands to the init system.\n\n" - " --help Show this help\n\n" + printf("%s [OPTIONS...] {COMMAND}\n\n" + "Send control commands to the init daemon.\n\n" + " --help Show this help\n" + " --no-wall Don't send wall message before halt/power-off/reboot\n\n" "Commands:\n" " 0 Power-off the machine\n" " 6 Reboot the machine\n" - " 1, 2, 3, 4, 5 Start runlevelX.target unit\n" - " s, S Start the rescue.target unit\n" - " q, Q Ask systemd to reload its configuration\n" - " u, U Ask systemd to reexecute itself\n", + " 2, 3, 4, 5 Start runlevelX.target unit\n" + " 1, s, S Enter rescue mode\n" + " q, Q Reload init daemon configuration\n" + " u, U Reexecute init daemon\n", program_invocation_short_name); return 0; @@ -1409,7 +2102,7 @@ static int telinit_help(void) { static int runlevel_help(void) { - printf("%s [options]\n\n" + printf("%s [OPTIONS...]\n\n" "Prints the previous and current runlevel of the init system.\n\n" " --help Show this help\n", program_invocation_short_name); @@ -1423,18 +2116,22 @@ static int systemctl_parse_argv(int argc, char *argv[]) { ARG_REPLACE = 0x100, ARG_SESSION, ARG_SYSTEM, - ARG_BLOCK + ARG_NO_BLOCK, + ARG_NO_WALL }; static const struct option options[] = { - { "help", no_argument, NULL, 'h' }, - { "type", required_argument, NULL, 't' }, - { "all", no_argument, NULL, 'a' }, - { "replace", no_argument, NULL, ARG_REPLACE }, - { "session", no_argument, NULL, ARG_SESSION }, - { "system", no_argument, NULL, ARG_SYSTEM }, - { "block", no_argument, NULL, ARG_BLOCK }, - { NULL, 0, NULL, 0 } + { "help", no_argument, NULL, 'h' }, + { "type", required_argument, NULL, 't' }, + { "property", required_argument, NULL, 'p' }, + { "all", no_argument, NULL, 'a' }, + { "replace", no_argument, NULL, ARG_REPLACE }, + { "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 } }; int c; @@ -1442,7 +2139,7 @@ static int systemctl_parse_argv(int argc, char *argv[]) { assert(argc >= 0); assert(argv); - while ((c = getopt_long(argc, argv, "hta", options, NULL)) >= 0) { + while ((c = getopt_long(argc, argv, "ht:p:aq", options, NULL)) >= 0) { switch (c) { @@ -1454,6 +2151,15 @@ static int systemctl_parse_argv(int argc, char *argv[]) { arg_type = optarg; break; + case 'p': + arg_property = optarg; + + /* 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; break; @@ -1470,8 +2176,16 @@ static int systemctl_parse_argv(int argc, char *argv[]) { arg_session = false; break; - case ARG_BLOCK: - arg_block = true; + case ARG_NO_BLOCK: + arg_no_block = true; + break; + + case ARG_NO_WALL: + arg_no_wall = true; + break; + + case 'q': + arg_quiet = true; break; case '?': @@ -1491,7 +2205,8 @@ static int halt_parse_argv(int argc, char *argv[]) { enum { ARG_HELP = 0x100, ARG_HALT, - ARG_REBOOT + ARG_REBOOT, + ARG_NO_WALL }; static const struct option options[] = { @@ -1503,6 +2218,7 @@ static int halt_parse_argv(int argc, char *argv[]) { { "wtmp-only", no_argument, NULL, 'w' }, { "no-wtmp", no_argument, NULL, 'd' }, { "no-sync", no_argument, NULL, 'n' }, + { "no-wall", no_argument, NULL, ARG_NO_WALL }, { NULL, 0, NULL, 0 } }; @@ -1550,6 +2266,10 @@ static int halt_parse_argv(int argc, char *argv[]) { arg_no_sync = true; break; + case ARG_NO_WALL: + arg_no_wall = true; + break; + case 'i': case 'h': /* Compatibility nops */ @@ -1576,6 +2296,7 @@ static int shutdown_parse_argv(int argc, char *argv[]) { enum { ARG_HELP = 0x100, + ARG_NO_WALL }; static const struct option options[] = { @@ -1583,6 +2304,7 @@ static int shutdown_parse_argv(int argc, char *argv[]) { { "halt", no_argument, NULL, 'H' }, { "poweroff", no_argument, NULL, 'P' }, { "reboot", no_argument, NULL, 'r' }, + { "no-wall", no_argument, NULL, ARG_NO_WALL }, { NULL, 0, NULL, 0 } }; @@ -1619,6 +2341,10 @@ static int shutdown_parse_argv(int argc, char *argv[]) { arg_dry = true; break; + case ARG_NO_WALL: + arg_no_wall = true; + break; + case 't': case 'a': /* Compatibility nops */ @@ -1633,6 +2359,9 @@ 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]); + /* We ignore the time argument */ if (argc > optind + 1) arg_wall = argv + optind + 1; @@ -1640,17 +2369,18 @@ static int shutdown_parse_argv(int argc, char *argv[]) { optind = argc; return 1; - } static int telinit_parse_argv(int argc, char *argv[]) { enum { ARG_HELP = 0x100, + ARG_NO_WALL }; static const struct option options[] = { { "help", no_argument, NULL, ARG_HELP }, + { "no-wall", no_argument, NULL, ARG_NO_WALL }, { NULL, 0, NULL, 0 } }; @@ -1686,6 +2416,10 @@ static int telinit_parse_argv(int argc, char *argv[]) { telinit_help(); return 0; + case ARG_NO_WALL: + arg_no_wall = true; + break; + case '?': return -EINVAL; @@ -1696,7 +2430,7 @@ static int telinit_parse_argv(int argc, char *argv[]) { } if (optind >= argc) { - log_error("Argument missing."); + telinit_help(); return -EINVAL; } @@ -1797,14 +2531,150 @@ static int parse_argv(int argc, char *argv[]) { return systemctl_parse_argv(argc, argv); } -static int talk_upstart(DBusConnection *bus) { - log_error("Talking upstart"); - return 0; +static int action_to_runlevel(void) { + + static const char table[_ACTION_MAX] = { + [ACTION_HALT] = '0', + [ACTION_POWEROFF] = '0', + [ACTION_REBOOT] = '6', + [ACTION_RUNLEVEL2] = '2', + [ACTION_RUNLEVEL3] = '3', + [ACTION_RUNLEVEL4] = '4', + [ACTION_RUNLEVEL5] = '5', + [ACTION_RESCUE] = '1' + }; + + assert(arg_action < _ACTION_MAX); + + return table[arg_action]; +} + +static int talk_upstart(void) { + DBusMessage *m = NULL, *reply = NULL; + DBusError error; + int previous, rl, r; + char + env1_buf[] = "RUNLEVEL=X", + env2_buf[] = "PREVLEVEL=X"; + char *env1 = env1_buf, *env2 = env2_buf; + const char *emit = "runlevel"; + dbus_bool_t b_false = FALSE; + DBusMessageIter iter, sub; + DBusConnection *bus; + + dbus_error_init(&error); + + if (!(rl = action_to_runlevel())) + return 0; + + if (utmp_get_runlevel(&previous, NULL) < 0) + previous = 'N'; + + if (!(bus = dbus_connection_open("unix:abstract=/com/ubuntu/upstart", &error))) { + if (dbus_error_has_name(&error, DBUS_ERROR_NO_SERVER)) { + r = 0; + goto finish; + } + + log_error("Failed to connect to Upstart bus: %s", error.message); + r = -EIO; + goto finish; + } + + if ((r = bus_check_peercred(bus)) < 0) { + log_error("Failed to verify owner of bus."); + goto finish; + } + + if (!(m = dbus_message_new_method_call( + "com.ubuntu.Upstart", + "/com/ubuntu/Upstart", + "com.ubuntu.Upstart0_6", + "EmitEvent"))) { + + log_error("Could not allocate message."); + r = -ENOMEM; + goto finish; + } + + dbus_message_iter_init_append(m, &iter); + + env1_buf[sizeof(env1_buf)-2] = rl; + env2_buf[sizeof(env2_buf)-2] = previous; + + if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &emit) || + !dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub) || + !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &env1) || + !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &env2) || + !dbus_message_iter_close_container(&iter, &sub) || + !dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &b_false)) { + log_error("Could not append arguments to message."); + r = -ENOMEM; + goto finish; + } + + if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { + + if (error_is_no_service(&error)) { + r = 0; + goto finish; + } + + log_error("Failed to issue method call: %s", error.message); + r = -EIO; + goto finish; + } + + r = 1; + +finish: + if (m) + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); + + if (bus) + dbus_connection_unref(bus); + + dbus_error_free(&error); + + return r; } static int talk_initctl(void) { - log_error("Talking initctl"); - return 0; + struct init_request request; + int r, fd; + char rl; + + if (!(rl = action_to_runlevel())) + return 0; + + zero(request); + request.magic = INIT_MAGIC; + request.sleeptime = 0; + request.cmd = INIT_CMD_RUNLVL; + request.runlevel = rl; + + if ((fd = open(INIT_FIFO, O_WRONLY|O_NDELAY|O_CLOEXEC|O_NOCTTY)) < 0) { + + if (errno == ENOENT) + return 0; + + log_error("Failed to open "INIT_FIFO": %m"); + return -errno; + } + + errno = 0; + r = loop_write(fd, &request, sizeof(request), false) != sizeof(request); + close_nointr_nofail(fd); + + if (r < 0) { + log_error("Failed to write to "INIT_FIFO": %m"); + return errno ? -errno : -EIO; + } + + return 1; } static int systemctl_main(DBusConnection *bus, int argc, char *argv[]) { @@ -1829,15 +2699,24 @@ static int systemctl_main(DBusConnection *bus, int argc, char *argv[]) { { "reload", MORE, 2, start_unit }, { "restart", MORE, 2, start_unit }, { "isolate", EQUAL, 2, start_unit }, + { "check", MORE, 2, check_unit }, + { "show", MORE, 1, 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 }, }; int left; @@ -1853,6 +2732,11 @@ static int systemctl_main(DBusConnection *bus, int argc, char *argv[]) { /* Special rule: no arguments means "list-units" */ i = 0; else { + if (streq(argv[optind], "help")) { + systemctl_help(); + return 0; + } + for (i = 0; i < ELEMENTSOF(verbs); i++) if (streq(argv[optind], verbs[i].verb)) break; @@ -1919,7 +2803,7 @@ static int reload_with_fallback(DBusConnection *bus) { static int start_with_fallback(DBusConnection *bus) { int r; - warn_wall(); + warn_wall(arg_action); if (bus) { /* First, try systemd via D-Bus. */ @@ -1928,13 +2812,17 @@ static int start_with_fallback(DBusConnection *bus) { /* 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(bus)) > 0) + if ((r = talk_upstart()) > 0) return 0; } /* Nothing else worked, so let's try * /dev/initctl */ - return talk_initctl(); + if ((r = talk_initctl()) != 0) + return 0; + + log_error("Failed to talk to init daemon."); + return -EIO; } static int halt_main(DBusConnection *bus) { @@ -1943,8 +2831,6 @@ static int halt_main(DBusConnection *bus) { if (!arg_immediate) return start_with_fallback(bus); - warn_wall(); - if (!arg_no_wtmp) if ((r = utmp_put_shutdown(0)) < 0) log_warning("Failed to write utmp record: %s", strerror(-r)); @@ -2022,7 +2908,18 @@ int main(int argc, char*argv[]) { goto finish; } - if ((bus = dbus_bus_get(arg_session ? DBUS_BUS_SESSION : DBUS_BUS_SYSTEM, &error))) + /* If we are root, then let's not go via the bus */ + if (geteuid() == 0 && !arg_session) { + bus = dbus_connection_open("unix:abstract=/org/freedesktop/systemd1/private", &error); + + if (bus && bus_check_peercred(bus) < 0) { + log_error("Failed to verify owner of bus."); + goto finish; + } + } else + bus = dbus_bus_get(arg_session ? DBUS_BUS_SESSION : DBUS_BUS_SYSTEM, &error); + + if (bus) dbus_connection_set_exit_on_disconnect(bus, FALSE); switch (arg_action) { @@ -2049,6 +2946,8 @@ int main(int argc, char*argv[]) { case ACTION_RUNLEVEL4: case ACTION_RUNLEVEL5: case ACTION_RESCUE: + case ACTION_EMERGENCY: + case ACTION_DEFAULT: retval = start_with_fallback(bus) < 0; break; @@ -2057,6 +2956,8 @@ int main(int argc, char*argv[]) { retval = reload_with_fallback(bus) < 0; break; + case ACTION_INVALID: + case ACTION_RUNLEVEL: default: assert_not_reached("Unknown action"); }