X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fsystemctl.c;h=01deafe2a13b1d0edc3bcfe8633343ccc1eab471;hp=be32b0d152d2c849709af00dbc9ebcd0ffc04fcb;hb=d47b555bb6cabca024242e00b674da835938d286;hpb=2ded0c0442f597dc397f7b0e9a15cf453578d11e diff --git a/src/systemctl.c b/src/systemctl.c index be32b0d15..01deafe2a 100644 --- a/src/systemctl.c +++ b/src/systemctl.c @@ -19,6 +19,7 @@ along with systemd; If not, see . ***/ +#include #include #include #include @@ -27,6 +28,8 @@ #include #include #include +#include +#include #include @@ -34,15 +37,68 @@ #include "util.h" #include "macro.h" #include "set.h" +#include "utmp-wtmp.h" +#include "special.h" +#include "initreq.h" +#include "strv.h" +#include "dbus-common.h" +#include "cgroup-show.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, + ACTION_SYSTEMCTL, + ACTION_HALT, + ACTION_POWEROFF, + ACTION_REBOOT, + ACTION_RUNLEVEL2, + ACTION_RUNLEVEL3, + ACTION_RUNLEVEL4, + ACTION_RUNLEVEL5, + ACTION_RESCUE, + ACTION_EMERGENCY, + ACTION_DEFAULT, + ACTION_RELOAD, + ACTION_REEXEC, + ACTION_RUNLEVEL, + _ACTION_MAX +} arg_action = ACTION_SYSTEMCTL; + +static bool private_bus = false; + +static bool error_is_no_service(DBusError *error) { + + assert(error); + + if (!dbus_error_is_set(error)) + return false; + + if (dbus_error_has_name(error, DBUS_ERROR_NAME_HAS_NO_OWNER)) + return true; + + if (dbus_error_has_name(error, DBUS_ERROR_SERVICE_UNKNOWN)) + return true; + + return startswith(error->name, "org.freedesktop.DBus.Error.Spawn."); +} 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; @@ -54,28 +110,39 @@ static int bus_iter_get_basic_and_next(DBusMessageIter *iter, int type, void *da return 0; } -static int columns(void) { - static int parsed_columns = 0; - const char *e; +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_EMERGENCY] = "The system is going down to emergency mode NOW!" + }; + + if (arg_no_wall) + return; - if (parsed_columns > 0) - return parsed_columns; + if (arg_wall) { + char *p; - if ((e = getenv("COLUMNS"))) - parsed_columns = atoi(e); + if (!(p = strv_join(arg_wall, " "))) { + log_error("Failed to join strings."); + return; + } - if (parsed_columns <= 0) { - struct winsize ws; - zero(ws); + if (*p) { + utmp_wall(p); + free(p); + return; + } - if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) >= 0) - parsed_columns = ws.ws_col; + free(p); } - if (parsed_columns <= 0) - parsed_columns = 80; + if (!table[action]) + return; - return parsed_columns; + utmp_wall(table[action]); } static int list_units(DBusConnection *bus, char **args, unsigned n) { @@ -87,6 +154,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", @@ -146,6 +215,9 @@ static int list_units(DBusConnection *bus, char **args, unsigned n) { int a = 0, b = 0; + if (streq(active_state, "maintenance")) + fputs(ANSI_HIGHLIGHT_ON, stdout); + printf("%-45s %-6s %-12s %-12s%n", id, load_state, active_state, sub_state, &a); if (job_id != 0) @@ -157,9 +229,12 @@ static int list_units(DBusConnection *bus, char **args, unsigned n) { if (job_id == 0) printf(" "); - printf("%.*s", columns() - a - b - 2, description); + printf(" %.*s", columns() - a - b - 2, description); } + if (streq(active_state, "maintenance")) + fputs(ANSI_HIGHLIGHT_OFF, stdout); + fputs("\n", stdout); k++; } @@ -195,6 +270,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", @@ -274,6 +351,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( @@ -328,6 +408,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; @@ -407,20 +490,25 @@ 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); - /* log_debug("Got D-Bus request: %s.%s() on %s", */ - /* dbus_message_get_interface(message), */ - /* dbus_message_get_member(message), */ - /* dbus_message_get_path(message)); */ + log_debug("Got D-Bus request: %s.%s() on %s", + dbus_message_get_interface(message), + dbus_message_get_member(message), + dbus_message_get_path(message)); if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) { log_error("Warning! D-Bus connection terminated."); @@ -429,17 +517,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; } } @@ -449,13 +542,13 @@ static DBusHandlerResult wait_filter(DBusConnection *connection, DBusMessage *me static int enable_wait_for_jobs(DBusConnection *bus) { DBusError error; - DBusMessage *m = NULL, *reply = NULL; - int r; assert(bus); - dbus_error_init(&error); + if (private_bus) + return 0; + dbus_error_init(&error); dbus_bus_add_match(bus, "type='signal'," "sender='org.freedesktop.systemd1'," @@ -466,49 +559,26 @@ static int enable_wait_for_jobs(DBusConnection *bus) { if (dbus_error_is_set(&error)) { log_error("Failed to add match: %s", error.message); - r = -EIO; - goto finish; - } - - if (!(m = dbus_message_new_method_call( - "org.freedesktop.systemd1", - "/org/freedesktop/systemd1", - "org.freedesktop.systemd1.Manager", - "Subscribe"))) { - log_error("Could not allocate 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; + dbus_error_free(&error); + return -EIO; } - r = 0; - -finish: /* This is slightly dirty, since we don't undo the match registrations. */ - - if (m) - dbus_message_unref(m); - - if (reply) - dbus_message_unref(reply); - - dbus_error_free(&error); - - return r; + return 0; } 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; @@ -518,7 +588,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. */ @@ -526,147 +599,37 @@ finish: return r; } -static int start_unit(DBusConnection *bus, char **args, unsigned n) { - DBusMessage *m = NULL, *reply = NULL; - DBusError error; - int r; - unsigned i; - const char *method, *mode; - char *p = NULL; - Set *s = NULL; - - dbus_error_init(&error); - - method = - streq(args[0], "start") ? "StartUnit" : - streq(args[0], "stop") ? "StopUnit" : - streq(args[0], "reload") ? "ReloadUnit" : - "RestartUnit"; - - mode = arg_replace ? "replace" : "fail"; - - if (arg_block) { - if ((r = enable_wait_for_jobs(bus)) < 0) { - log_error("Could not watch jobs: %s", strerror(-r)); - goto finish; - } - } - - for (i = 1; i < n; i++) { - - if (!(m = dbus_message_new_method_call( - "org.freedesktop.systemd1", - "/org/freedesktop/systemd1", - "org.freedesktop.systemd1.Manager", - method))) { - log_error("Could not allocate message."); - r = -ENOMEM; - goto finish; - } - - if (!dbus_message_append_args(m, - DBUS_TYPE_STRING, &args[i], - DBUS_TYPE_STRING, &mode, - DBUS_TYPE_INVALID)) { - log_error("Could not append arguments to message."); - r = -ENOMEM; - goto finish; - } - - if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { - log_error("Failed to issue method call: %s", error.message); - r = -EIO; - goto finish; - } - - if (arg_block) { - const char *path; - - 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 (!s) - if (!(s = set_new(string_hash_func, string_compare_func))) { - log_error("Failed to allocate set."); - r = -ENOMEM; - goto finish; - } - - if (!(p = strdup(path))) { - log_error("Failed to duplicate path."); - r = -ENOMEM; - goto finish; - } - - if ((r = set_put(s, p)) < 0) { - log_error("Failed to add path to set."); - goto finish; - } - p = NULL; - } - - dbus_message_unref(m); - dbus_message_unref(reply); - - m = reply = NULL; - } - - if (arg_block) - r = wait_for_jobs(bus, s); - else - r = 0; - -finish: - free(p); - - if (s) - set_free_free(s); - - if (m) - dbus_message_unref(m); - - if (reply) - dbus_message_unref(reply); - - dbus_error_free(&error); - - return r; -} +static int start_unit_one( + DBusConnection *bus, + const char *method, + const char *name, + const char *mode, + Set *s) { -static int isolate_unit(DBusConnection *bus, char **args, unsigned n) { DBusMessage *m = NULL, *reply = NULL; DBusError error; int r; - const char *mode = "isolate"; - char *p = NULL; - Set *s = NULL; - dbus_error_init(&error); + assert(bus); + assert(method); + assert(name); + assert(mode); + assert(arg_no_block || s); - if (arg_block) { - if ((r = enable_wait_for_jobs(bus)) < 0) { - log_error("Could not watch jobs: %s", strerror(-r)); - goto finish; - } - } + dbus_error_init(&error); if (!(m = dbus_message_new_method_call( "org.freedesktop.systemd1", "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", - "StartUnit"))) { + method))) { log_error("Could not allocate message."); r = -ENOMEM; goto finish; } if (!dbus_message_append_args(m, - DBUS_TYPE_STRING, &args[1], + DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &mode, DBUS_TYPE_INVALID)) { log_error("Could not append arguments to message."); @@ -675,13 +638,22 @@ static int isolate_unit(DBusConnection *bus, char **args, unsigned n) { } if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { + + if (arg_action != ACTION_SYSTEMCTL && error_is_no_service(&error)) { + /* There's always a fallback possible for + * legacy actions. */ + r = 0; + goto finish; + } + log_error("Failed to issue method call: %s", error.message); r = -EIO; goto finish; } - if (arg_block) { + if (!arg_no_block) { const char *path; + char *p; if (!dbus_message_get_args(reply, &error, DBUS_TYPE_OBJECT_PATH, &path, @@ -691,12 +663,6 @@ static int isolate_unit(DBusConnection *bus, char **args, unsigned n) { goto finish; } - if (!(s = set_new(string_hash_func, string_compare_func))) { - log_error("Failed to allocate set."); - r = -ENOMEM; - goto finish; - } - if (!(p = strdup(path))) { log_error("Failed to duplicate path."); r = -ENOMEM; @@ -704,22 +670,15 @@ static int isolate_unit(DBusConnection *bus, char **args, unsigned n) { } if ((r = set_put(s, p)) < 0) { + free(p); log_error("Failed to add path to set."); goto finish; } - p = NULL; - - r = wait_for_jobs(bus, s); + } - } else - r = 0; + r = 1; finish: - free(p); - - if (s) - set_free_free(s); - if (m) dbus_message_unref(m); @@ -731,214 +690,227 @@ finish: return r; } -static DBusHandlerResult monitor_filter(DBusConnection *connection, DBusMessage *message, void *data) { - DBusError error; - DBusMessage *m = NULL, *reply = NULL; - - assert(connection); - assert(message); - - dbus_error_init(&error); +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; +} - /* log_debug("Got D-Bus request: %s.%s() on %s", */ - /* dbus_message_get_interface(message), */ - /* dbus_message_get_member(message), */ - /* dbus_message_get_path(message)); */ +static int start_unit(DBusConnection *bus, char **args, unsigned n) { - if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) { - log_error("Warning! D-Bus connection terminated."); - dbus_connection_close(connection); + static const char * const table[_ACTION_MAX] = { + [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 + }; - } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "UnitNew") || - dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "UnitRemoved")) { - const char *id, *path; + int r; + unsigned i; + const char *method, *mode, *one_name; + Set *s = NULL; - if (!dbus_message_get_args(message, &error, - DBUS_TYPE_STRING, &id, - DBUS_TYPE_OBJECT_PATH, &path, - DBUS_TYPE_INVALID)) - log_error("Failed to parse message: %s", error.message); - else if (streq(dbus_message_get_member(message), "UnitNew")) - printf("Unit %s added.\n", id); - else - printf("Unit %s removed.\n", id); + assert(bus); - } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobNew") || - dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobRemoved")) { - uint32_t id; - const char *path; + if (arg_action == ACTION_SYSTEMCTL) { + method = + streq(args[0], "stop") ? "StopUnit" : + streq(args[0], "reload") ? "ReloadUnit" : + streq(args[0], "restart") ? "RestartUnit" : + "StartUnit"; - if (!dbus_message_get_args(message, &error, - DBUS_TYPE_UINT32, &id, - DBUS_TYPE_OBJECT_PATH, &path, - DBUS_TYPE_INVALID)) - log_error("Failed to parse message: %s", error.message); - else if (streq(dbus_message_get_member(message), "JobNew")) - printf("Job %u added.\n", id); - else - printf("Job %u removed.\n", id); + 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 if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Unit", "Changed") || - dbus_message_is_signal(message, "org.freedesktop.systemd1.Job", "Changed")) { + } else { + assert(arg_action < ELEMENTSOF(table)); + assert(table[arg_action]); - const char *path, *interface, *property = "Id"; - DBusMessageIter iter, sub; + method = "StartUnit"; - path = dbus_message_get_path(message); - interface = dbus_message_get_interface(message); + mode = (arg_action == ACTION_EMERGENCY || + arg_action == ACTION_RESCUE) ? "isolate" : "replace"; - if (!(m = dbus_message_new_method_call( - "org.freedesktop.systemd1", - path, - "org.freedesktop.DBus.Properties", - "Get"))) { - log_error("Could not allocate message."); - goto oom; - } + one_name = table[arg_action]; + } - 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."); + if (!arg_no_block) { + if ((r = enable_wait_for_jobs(bus)) < 0) { + log_error("Could not watch jobs: %s", strerror(-r)); goto finish; } - if (!(reply = dbus_connection_send_with_reply_and_block(connection, m, -1, &error))) { - log_error("Failed to issue method call: %s", error.message); + if (!(s = set_new(string_hash_func, string_compare_func))) { + log_error("Failed to allocate set."); + r = -ENOMEM; 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."); - goto finish; - } + r = 0; - dbus_message_iter_recurse(&iter, &sub); + 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 (streq(interface, "org.freedesktop.systemd1.Unit")) { - const char *id; - - if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) { - log_error("Failed to parse reply."); - goto finish; - } - - dbus_message_iter_get_basic(&sub, &id); - printf("Unit %s changed.\n", id); - } else { - uint32_t id; - - if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT32) { - log_error("Failed to parse reply."); - goto finish; - } - - dbus_message_iter_get_basic(&sub, &id); - printf("Job %u changed.\n", id); - } - } + if (!arg_no_block) + r = wait_for_jobs(bus, s); finish: - if (m) - dbus_message_unref(m); - - if (reply) - dbus_message_unref(reply); + if (s) + set_free_free(s); - dbus_error_free(&error); - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + return r; +} -oom: - if (m) - dbus_message_unref(m); +static int start_special(DBusConnection *bus, char **args, unsigned n) { + assert(bus); + assert(args); - if (reply) - dbus_message_unref(reply); + warn_wall(verb_to_action(args[0])); - dbus_error_free(&error); - return DBUS_HANDLER_RESULT_NEED_MEMORY; + return start_unit(bus, args, n); } -static int monitor(DBusConnection *bus, char **args, unsigned 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; - int r; + unsigned i; + + assert(bus); + assert(args); dbus_error_init(&error); - dbus_bus_add_match(bus, - "type='signal'," - "sender='org.freedesktop.systemd1'," - "interface='org.freedesktop.systemd1.Manager'," - "path='/org/freedesktop/systemd1'", - &error); + for (i = 1; i < n; i++) { + const char *path = NULL; + const char *state; + DBusMessageIter iter, sub; - if (dbus_error_is_set(&error)) { - log_error("Failed to add match: %s", error.message); - r = -EIO; - goto finish; - } + 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; + } - dbus_bus_add_match(bus, - "type='signal'," - "sender='org.freedesktop.systemd1'," - "interface='org.freedesktop.systemd1.Unit'," - "member='Changed'", - &error); + 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 (dbus_error_is_set(&error)) { - log_error("Failed to add match: %s", error.message); - r = -EIO; - goto finish; - } + if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { - dbus_bus_add_match(bus, - "type='signal'," - "sender='org.freedesktop.systemd1'," - "interface='org.freedesktop.systemd1.Job'," - "member='Changed'", - &error); + /* Hmm, cannot figure out anything about this unit... */ + if (!arg_quiet) + puts("unknown"); - if (dbus_error_is_set(&error)) { - log_error("Failed to add match: %s", error.message); - r = -EIO; - goto finish; - } + dbus_error_free(&error); + continue; + } - if (!dbus_connection_add_filter(bus, monitor_filter, NULL, NULL)) { - log_error("Failed to add filter."); - r = -ENOMEM; - 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; + } - if (!(m = dbus_message_new_method_call( - "org.freedesktop.systemd1", - "/org/freedesktop/systemd1", - "org.freedesktop.systemd1.Manager", - "Subscribe"))) { - log_error("Could not allocate message."); - r = -ENOMEM; - 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 (!(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_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; + } - while (dbus_connection_read_write_dispatch(bus, -1)) - ; + 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; + } - r = 0; + if (!dbus_message_iter_init(reply, &iter) || + dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } -finish: + dbus_message_iter_recurse(&iter, &sub); - /* This is slightly dirty, since we don't undo the filter or the matches. */ + 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); @@ -950,121 +922,527 @@ finish: return r; } -static int dump(DBusConnection *bus, char **args, unsigned n) { - DBusMessage *m = NULL, *reply = NULL; - DBusError error; - int r; - const char *text; +typedef struct UnitStatusInfo { + const char *id; + const char *load_state; + const char *active_state; + const char *sub_state; - dbus_error_init(&error); + const char *description; - if (!(m = dbus_message_new_method_call( - "org.freedesktop.systemd1", - "/org/freedesktop/systemd1", - "org.freedesktop.systemd1.Manager", - "Dump"))) { - log_error("Could not allocate message."); - return -ENOMEM; - } + const char *fragment_path; + const char *default_control_group; - 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; - } + /* Service */ + pid_t main_pid; + pid_t control_pid; + const char *status_text; + bool running; - if (!dbus_message_get_args(reply, &error, - DBUS_TYPE_STRING, &text, - DBUS_TYPE_INVALID)) { - log_error("Failed to parse reply: %s", error.message); - r = -EIO; - goto finish; - } + usec_t start_timestamp; + usec_t exit_timestamp; - fputs(text, stdout); + int exit_code, exit_status; - r = 0; + /* Socket */ + unsigned n_accepted; + unsigned n_connections; -finish: - if (m) - dbus_message_unref(m); + /* Device */ + const char *sysfs_path; - if (reply) - dbus_message_unref(reply); + /* Mount, Automount */ + const char *where; - dbus_error_free(&error); + /* Swap */ + const char *what; +} UnitStatusInfo; - return r; -} +static void print_status_info(UnitStatusInfo *i) { + assert(i); -static int snapshot(DBusConnection *bus, char **args, unsigned n) { - DBusMessage *m = NULL, *reply = NULL; - DBusError error; - int r; - const char *name = "", *path, *id; - dbus_bool_t cleanup = FALSE; - DBusMessageIter iter, sub; - const char - *interface = "org.freedesktop.systemd1.Unit", - *property = "Id"; + /* This shows pretty information about a unit. See + * print_property() for a low-level property printer */ - dbus_error_init(&error); + printf("%s", strna(i->id)); - if (!(m = dbus_message_new_method_call( - "org.freedesktop.systemd1", - "/org/freedesktop/systemd1", - "org.freedesktop.systemd1.Manager", - "CreateSnapshot"))) { - log_error("Could not allocate message."); - return -ENOMEM; + if (i->description && !streq_ptr(i->id, i->description)) + printf(" - %s", i->description); + + 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 (streq_ptr(i->active_state, "maintenance")) + printf("\t Active: " ANSI_HIGHLIGHT_ON "%s (%s)" ANSI_HIGHLIGHT_OFF "\n", + strna(i->active_state), + strna(i->sub_state)); + else + printf("\t Active: %s (%s)\n", + strna(i->active_state), + strna(i->sub_state)); + + if (i->sysfs_path) + printf("\t Device: %s\n", i->sysfs_path); + else if (i->where) + printf("\t Where: %s\n", i->where); + else if (i->what) + printf("\t What: %s\n", i->what); + + if (i->status_text) + printf("\t Status: \"%s\"\n", i->status_text); + + if (i->id && endswith(i->id, ".socket")) + printf("\tAccepted: %u; Connected: %u\n", i->n_accepted, i->n_connections); + + if (i->main_pid > 0 || i->control_pid > 0) { + printf("\t"); + + if (i->main_pid > 0) { + printf(" Process: %u", (unsigned) i->main_pid); + + if (i->running) { + char *t = NULL; + get_process_name(i->main_pid, &t); + if (t) { + printf(" (%s)", t); + free(t); + } + } else { + printf(" (code=%s, ", sigchld_code_to_string(i->exit_code)); + + if (i->exit_code == CLD_EXITED) + printf("status=%i", i->exit_status); + else + printf("signal=%s", strsignal(i->exit_status)); + printf(")"); + } + } + + if (i->main_pid > 0 && i->control_pid > 0) + printf(";"); + + if (i->control_pid > 0) { + char *t = NULL; + + printf(" Control: %u", (unsigned) i->control_pid); + + get_process_name(i->control_pid, &t); + if (t) { + printf(" (%s)", t); + free(t); + } + } + + printf("\n"); } - if (n > 1) - name = args[1]; + if (i->default_control_group) { + unsigned c; - if (!dbus_message_append_args(m, - DBUS_TYPE_STRING, &name, - DBUS_TYPE_BOOLEAN, &cleanup, - DBUS_TYPE_INVALID)) { - log_error("Could not append arguments to message."); - r = -ENOMEM; - goto finish; + printf("\t CGroup: %s\n", i->default_control_group); + + if ((c = columns()) > 18) + c -= 18; + else + c = 0; + + show_cgroup_recursive(i->default_control_group, "\t\t ", c); } +} - 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; +static int status_property(const char *name, DBusMessageIter *iter, UnitStatusInfo *i) { + + switch (dbus_message_iter_get_arg_type(iter)) { + + case DBUS_TYPE_STRING: { + const char *s; + + dbus_message_iter_get_basic(iter, &s); + + if (s[0]) { + if (streq(name, "Id")) + i->id = s; + else if (streq(name, "LoadState")) + i->load_state = s; + else if (streq(name, "ActiveState")) + i->active_state = s; + else if (streq(name, "SubState")) + i->sub_state = s; + else if (streq(name, "Description")) + i->description = s; + else if (streq(name, "FragmentPath")) + i->fragment_path = s; + else if (streq(name, "DefaultControlGroup")) + i->default_control_group = s; + else if (streq(name, "StatusText")) + i->status_text = s; + else if (streq(name, "SysFSPath")) + i->sysfs_path = s; + else if (streq(name, "Where")) + i->where = s; + else if (streq(name, "What")) + i->what = s; + } + + break; } - 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; + case DBUS_TYPE_UINT32: { + uint32_t u; + + dbus_message_iter_get_basic(iter, &u); + + if (streq(name, "MainPID")) { + if (u > 0) { + i->main_pid = (pid_t) u; + i->running = true; + } + } else if (streq(name, "ControlPID")) + i->control_pid = (pid_t) u; + else if (streq(name, "ExecMainPID")) { + if (u > 0) + i->main_pid = (pid_t) u; + } else if (streq(name, "NAccepted")) + i->n_accepted = u; + else if (streq(name, "NConnections")) + i->n_connections = u; + + break; } - dbus_message_unref(m); + case DBUS_TYPE_INT32: { + int32_t j; + + dbus_message_iter_get_basic(iter, &j); + + if (streq(name, "ExecMainCode")) + i->exit_code = (int) j; + else if (streq(name, "ExecMainStatus")) + i->exit_status = (int) j; + + break; + } + + case DBUS_TYPE_UINT64: { + uint64_t u; + + dbus_message_iter_get_basic(iter, &u); + + if (streq(name, "ExecMainStartTimestamp")) + i->start_timestamp = (usec_t) u; + else if (streq(name, "ExecMainExitTimestamp")) + i->exit_timestamp = (usec_t) u; + + break; + } + } + + return 0; +} + +static int print_property(const char *name, DBusMessageIter *iter) { + assert(name); + assert(iter); + + /* This is a low-level property printer, see + * print_status_info() for the nicer output */ + + 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 if (strstr(name, "USec")) { + char timespan[FORMAT_TIMESPAN_MAX]; + + printf("%s=%s\n", name, format_timespan(timespan, sizeof(timespan), u)); + } 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") || strstr(name, "Mode")) + 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_BYTE) { + DBusMessageIter sub; + + 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) { + uint8_t u; + + assert(dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_BYTE); + dbus_message_iter_get_basic(&sub, &u); + printf("%02x", u); + + 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; + } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Timers")) { + DBusMessageIter sub, sub2; + + dbus_message_iter_recurse(iter, &sub); + + while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) { + const char *base; + uint64_t value, next_elapse; + + dbus_message_iter_recurse(&sub, &sub2); + + if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &base, true) >= 0 && + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &value, true) >= 0 && + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &next_elapse, false) >= 0) { + char timespan1[FORMAT_TIMESPAN_MAX], timespan2[FORMAT_TIMESPAN_MAX]; + + printf("%s={ value=%s ; next_elapse=%s }\n", + base, + format_timespan(timespan1, sizeof(timespan1), value), + format_timespan(timespan2, sizeof(timespan2), next_elapse)); + } + + dbus_message_iter_next(&sub); + } + + return 0; + } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && startswith(name, "Exec")) { + + DBusMessageIter sub, sub2, sub3; + + dbus_message_iter_recurse(iter, &sub); + + while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) { + const char *path; + uint64_t start_time, exit_time; + uint32_t pid; + int32_t code, status; + + dbus_message_iter_recurse(&sub, &sub2); + + if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) < 0) + continue; + + if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_ARRAY || + dbus_message_iter_get_element_type(&sub2) != DBUS_TYPE_STRING) + continue; + + printf("%s={ path=%s ; argv[]=", name, path); + + dbus_message_iter_recurse(&sub2, &sub3); + + while (dbus_message_iter_get_arg_type(&sub3) != DBUS_TYPE_INVALID) { + const char *s; + + assert(dbus_message_iter_get_arg_type(&sub3) == DBUS_TYPE_STRING); + dbus_message_iter_get_basic(&sub3, &s); + printf("%s ", s); + dbus_message_iter_next(&sub3); + } + + if (dbus_message_iter_next(&sub2) && + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &start_time, true) >= 0 && + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &exit_time, true) >= 0 && + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &pid, true) >= 0 && + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_INT32, &code, true) >= 0 && + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_INT32, &status, false) >= 0) { + + char timestamp1[FORMAT_TIMESTAMP_MAX], timestamp2[FORMAT_TIMESTAMP_MAX]; + + printf("; start=%s ; stop=%s ; pid=%u ; code=%s ; status=%i/%s", + strna(format_timestamp(timestamp1, sizeof(timestamp1), start_time)), + strna(format_timestamp(timestamp2, sizeof(timestamp2), exit_time)), + (unsigned) pid, + sigchld_code_to_string(code), + status, + strempty(code == CLD_EXITED ? NULL : strsignal(status))); + } + + printf(" }\n"); + + 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, bool show_properties, bool *new_line) { + DBusMessage *m = NULL, *reply = NULL; + const char *interface = ""; + int r; + DBusError error; + DBusMessageIter iter, sub, sub2, sub3; + UnitStatusInfo info; + + assert(bus); + assert(path); + assert(new_line); + + zero(info); + dbus_error_init(&error); + if (!(m = dbus_message_new_method_call( "org.freedesktop.systemd1", path, "org.freedesktop.DBus.Properties", - "Get"))) { + "GetAll"))) { log_error("Could not allocate message."); - return -ENOMEM; + 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; @@ -1072,7 +1450,8 @@ static int snapshot(DBusConnection *bus, char **args, unsigned n) { } if (!dbus_message_iter_init(reply, &iter) || - dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) { + 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; @@ -1080,57 +1459,53 @@ static int snapshot(DBusConnection *bus, char **args, unsigned n) { 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; - } + if (*new_line) + printf("\n"); - dbus_message_iter_get_basic(&sub, &id); - puts(id); - r = 0; + *new_line = true; -finish: - if (m) - dbus_message_unref(m); + while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { + const char *name; - if (reply) - dbus_message_unref(reply); + if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_DICT_ENTRY) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } - dbus_error_free(&error); + dbus_message_iter_recurse(&sub, &sub2); - return r; -} + if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } -static int clear_jobs(DBusConnection *bus, char **args, unsigned n) { - DBusMessage *m = NULL, *reply = NULL; - DBusError error; - int r; - const char *method; + if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_VARIANT) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } - dbus_error_init(&error); + dbus_message_iter_recurse(&sub2, &sub3); - method = - streq(args[0], "clear-jobs") ? "ClearJobs" : - streq(args[0], "daemon-reload") ? "Reload" : - streq(args[0], "daemon-reexec") ? "Reexecute" : - "Exit"; + if (show_properties) + r = print_property(name, &sub3); + else + r = status_property(name, &sub3, &info); - if (!(m = dbus_message_new_method_call( - "org.freedesktop.systemd1", - "/org/freedesktop/systemd1", - "org.freedesktop.systemd1.Manager", - method))) { - log_error("Could not allocate message."); - return -ENOMEM; - } + if (r < 0) { + log_error("Failed to parse reply."); + r = -EIO; + 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; + dbus_message_iter_next(&sub); } + if (!show_properties) + print_status_info(&info); + r = 0; finish: @@ -1145,140 +1520,1439 @@ finish: return r; } -static int show_enviroment(DBusConnection *bus, char **args, unsigned n) { +static int show(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"; + DBusError error; + unsigned i; + bool show_properties, new_line = false; + + assert(bus); + assert(args); 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; - } + show_properties = !streq(args[0], "status"); - 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 (show_properties && n <= 1) { + /* If not argument is specified inspect the manager + * itself */ - 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; + r = show_one(bus, "/org/freedesktop/systemd1", show_properties, &new_line); 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; - } + for (i = 1; i < n; i++) { + const char *path = NULL; + uint32_t id; + + if (!show_properties || safe_atou32(args[i], &id) < 0) { + + if (!(m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "LoadUnit"))) { + log_error("Could not allocate message."); + r = -ENOMEM; + goto finish; + } + + if (!dbus_message_append_args(m, + DBUS_TYPE_STRING, &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))) { + + if (!dbus_error_has_name(&error, DBUS_ERROR_ACCESS_DENIED)) { + log_error("Failed to issue method call: %s", error.message); + r = -EIO; + goto finish; + } + + dbus_error_free(&error); + + dbus_message_unref(m); + 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; + } + } + + } else { + + 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 (!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 (!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 ((r = show_one(bus, path, show_properties, &new_line)) < 0) + 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 DBusHandlerResult monitor_filter(DBusConnection *connection, DBusMessage *message, void *data) { + DBusError error; + DBusMessage *m = NULL, *reply = NULL; + + assert(connection); + assert(message); + + dbus_error_init(&error); + + log_debug("Got D-Bus request: %s.%s() on %s", + dbus_message_get_interface(message), + dbus_message_get_member(message), + dbus_message_get_path(message)); + + if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) { + log_error("Warning! D-Bus connection terminated."); + dbus_connection_close(connection); + + } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "UnitNew") || + dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "UnitRemoved")) { + const char *id, *path; + + if (!dbus_message_get_args(message, &error, + DBUS_TYPE_STRING, &id, + DBUS_TYPE_OBJECT_PATH, &path, + DBUS_TYPE_INVALID)) + log_error("Failed to parse message: %s", error.message); + else if (streq(dbus_message_get_member(message), "UnitNew")) + printf("Unit %s added.\n", id); + else + printf("Unit %s removed.\n", id); + + } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobNew") || + dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobRemoved")) { + uint32_t id; + const char *path; + + if (!dbus_message_get_args(message, &error, + DBUS_TYPE_UINT32, &id, + DBUS_TYPE_OBJECT_PATH, &path, + DBUS_TYPE_INVALID)) + log_error("Failed to parse message: %s", error.message); + 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")) { + + const char *path, *interface, *property = "Id"; + DBusMessageIter iter, sub; + + path = dbus_message_get_path(message); + interface = dbus_message_get_interface(message); + + if (!(m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + path, + "org.freedesktop.DBus.Properties", + "Get"))) { + log_error("Could not allocate message."); + goto oom; + } + + 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."); + goto finish; + } + + if (!(reply = dbus_connection_send_with_reply_and_block(connection, m, -1, &error))) { + log_error("Failed to issue method call: %s", error.message); + 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."); + goto finish; + } + + dbus_message_iter_recurse(&iter, &sub); + + if (streq(interface, "org.freedesktop.systemd1.Unit")) { + const char *id; + + if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) { + log_error("Failed to parse reply."); + goto finish; + } + + dbus_message_iter_get_basic(&sub, &id); + printf("Unit %s changed.\n", id); + } else { + uint32_t id; + + if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT32) { + log_error("Failed to parse reply."); + goto finish; + } + + dbus_message_iter_get_basic(&sub, &id); + printf("Job %u changed.\n", id); + } + } + +finish: + if (m) + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); + + dbus_error_free(&error); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + +oom: + if (m) + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); + + dbus_error_free(&error); + return DBUS_HANDLER_RESULT_NEED_MEMORY; +} + +static int monitor(DBusConnection *bus, char **args, unsigned n) { + DBusMessage *m = NULL, *reply = NULL; + DBusError error; + int r; + + dbus_error_init(&error); + + if (!private_bus) { + dbus_bus_add_match(bus, + "type='signal'," + "sender='org.freedesktop.systemd1'," + "interface='org.freedesktop.systemd1.Manager'," + "path='/org/freedesktop/systemd1'", + &error); + + if (dbus_error_is_set(&error)) { + log_error("Failed to add match: %s", error.message); + r = -EIO; + goto finish; + } + + dbus_bus_add_match(bus, + "type='signal'," + "sender='org.freedesktop.systemd1'," + "interface='org.freedesktop.systemd1.Unit'," + "member='Changed'", + &error); + + if (dbus_error_is_set(&error)) { + log_error("Failed to add match: %s", error.message); + 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."); + r = -ENOMEM; + goto finish; + } + + if (!(m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "Subscribe"))) { + log_error("Could not allocate 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; + } + + while (dbus_connection_read_write_dispatch(bus, -1)) + ; + + r = 0; + +finish: + + /* This is slightly dirty, since we don't undo the filter or the matches. */ + + if (m) + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); + + dbus_error_free(&error); + + return r; +} + +static int dump(DBusConnection *bus, char **args, unsigned n) { + DBusMessage *m = NULL, *reply = NULL; + DBusError error; + int r; + const char *text; + + dbus_error_init(&error); + + if (!(m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "Dump"))) { + log_error("Could not allocate message."); + return -ENOMEM; + } + + if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { + log_error("Failed to issue method call: %s", error.message); + r = -EIO; + goto finish; + } + + if (!dbus_message_get_args(reply, &error, + DBUS_TYPE_STRING, &text, + DBUS_TYPE_INVALID)) { + log_error("Failed to parse reply: %s", error.message); + r = -EIO; + goto finish; + } + + fputs(text, stdout); + + r = 0; + +finish: + if (m) + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); + + dbus_error_free(&error); + + return r; +} + +static int snapshot(DBusConnection *bus, char **args, unsigned n) { + DBusMessage *m = NULL, *reply = NULL; + DBusError error; + int r; + const char *name = "", *path, *id; + dbus_bool_t cleanup = FALSE; + DBusMessageIter iter, sub; + const char + *interface = "org.freedesktop.systemd1.Unit", + *property = "Id"; + + dbus_error_init(&error); + + if (!(m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "CreateSnapshot"))) { + log_error("Could not allocate message."); + return -ENOMEM; + } + + if (n > 1) + name = args[1]; + + if (!dbus_message_append_args(m, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_BOOLEAN, &cleanup, + DBUS_TYPE_INVALID)) { + log_error("Could not append arguments to message."); + r = -ENOMEM; + goto finish; + } + + 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.DBus.Properties", + "Get"))) { + log_error("Could not allocate message."); + return -ENOMEM; + } + + if (!dbus_message_append_args(m, + DBUS_TYPE_STRING, &interface, + DBUS_TYPE_STRING, &property, + DBUS_TYPE_INVALID)) { + log_error("Could not append arguments to message."); + r = -ENOMEM; + goto finish; + } + + dbus_message_unref(reply); + if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { + log_error("Failed to issue method call: %s", 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, &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: + if (m) + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); + + dbus_error_free(&error); + + return r; +} + +static int clear_jobs(DBusConnection *bus, char **args, unsigned n) { + DBusMessage *m = NULL, *reply = NULL; + DBusError error; + int r; + const char *method; + + dbus_error_init(&error); + + if (arg_action == ACTION_RELOAD) + method = "Reload"; + else if (arg_action == ACTION_REEXEC) + method = "Reexecute"; + else { + assert(arg_action == ACTION_SYSTEMCTL); + + method = + streq(args[0], "clear-jobs") ? "ClearJobs" : + streq(args[0], "daemon-reload") ? "Reload" : + streq(args[0], "daemon-reexec") ? "Reexecute" : + "Exit"; + } + + if (!(m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + method))) { + log_error("Could not allocate message."); + return -ENOMEM; + } + + if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { + + if (arg_action != ACTION_SYSTEMCTL && error_is_no_service(&error)) { + /* There's always a fallback possible for + * legacy actions. */ + r = 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); + + 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", 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_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", error.message); + 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 systemctl_help(void) { + + 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 properties 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" + " 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" + " status [NAME...] Show status of one or more units\n" + " show [NAME...|JOB...] Show properties of one or more units/jobs/manager\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" + " 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" + " 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; +} + +static int halt_help(void) { + + 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 halt/power-off/reboot\n" + " -w --wtmp-only Don't halt/power-off/reboot, just write wtmp record\n" + " -d --no-wtmp Don't write wtmp record\n" + " -n --no-sync Don't sync before halt/power-off/reboot\n" + " --no-wall Don't send wall message before halt/power-off/reboot\n", + program_invocation_short_name, + arg_action == ACTION_REBOOT ? "Reboot" : + arg_action == ACTION_POWEROFF ? "Power off" : + "Halt"); + + return 0; +} + +static int shutdown_help(void) { + + 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 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; +} + +static int telinit_help(void) { + + 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" + " 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; +} + +static int runlevel_help(void) { + + 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); + + return 0; +} + +static int systemctl_parse_argv(int argc, char *argv[]) { + + enum { + ARG_REPLACE = 0x100, + ARG_SESSION, + ARG_SYSTEM, + ARG_NO_BLOCK, + ARG_NO_WALL + }; + + 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' }, + { "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; + + assert(argc >= 0); + assert(argv); + + while ((c = getopt_long(argc, argv, "ht:p:aq", options, NULL)) >= 0) { + + switch (c) { + + case 'h': + systemctl_help(); + return 0; + + case 't': + 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; + + case ARG_REPLACE: + arg_replace = true; + break; + + case ARG_SESSION: + arg_session = true; + break; + + case ARG_SYSTEM: + arg_session = false; + break; + + 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 '?': + return -EINVAL; + + default: + log_error("Unknown option code %c", c); + return -EINVAL; + } + } + + return 1; +} + +static int halt_parse_argv(int argc, char *argv[]) { + + enum { + ARG_HELP = 0x100, + ARG_HALT, + ARG_REBOOT, + ARG_NO_WALL + }; + + static const struct option options[] = { + { "help", no_argument, NULL, ARG_HELP }, + { "halt", no_argument, NULL, ARG_HALT }, + { "poweroff", no_argument, NULL, 'p' }, + { "reboot", no_argument, NULL, ARG_REBOOT }, + { "force", no_argument, NULL, 'f' }, + { "wtmp-only", no_argument, NULL, 'w' }, + { "no-wtmp", no_argument, NULL, 'd' }, + { "no-sync", no_argument, NULL, 'n' }, + { "no-wall", no_argument, NULL, ARG_NO_WALL }, + { NULL, 0, NULL, 0 } + }; + + int c, runlevel; + + assert(argc >= 0); + assert(argv); + + if (utmp_get_runlevel(&runlevel, NULL) >= 0) + if (runlevel == '0' || runlevel == '6') + arg_immediate = true; + + while ((c = getopt_long(argc, argv, "pfwdnih", options, NULL)) >= 0) { + switch (c) { + + case ARG_HELP: + halt_help(); + return 0; + + case ARG_HALT: + arg_action = ACTION_HALT; + break; + + case 'p': + arg_action = ACTION_POWEROFF; + break; + + case ARG_REBOOT: + arg_action = ACTION_REBOOT; + break; + + case 'f': + arg_immediate = true; + break; + + case 'w': + arg_dry = true; + break; + + case 'd': + arg_no_wtmp = true; + break; + + case 'n': + arg_no_sync = true; + break; + + case ARG_NO_WALL: + arg_no_wall = true; + break; + + case 'i': + case 'h': + /* Compatibility nops */ + break; + + case '?': + return -EINVAL; + + default: + log_error("Unknown option code %c", c); + return -EINVAL; + } + } + + if (optind < argc) { + log_error("Too many arguments."); + return -EINVAL; + } + + return 1; +} + +static int shutdown_parse_argv(int argc, char *argv[]) { + + enum { + ARG_HELP = 0x100, + ARG_NO_WALL + }; + + static const struct option options[] = { + { "help", no_argument, NULL, ARG_HELP }, + { "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 } + }; + + int c; + + assert(argc >= 0); + assert(argv); + + while ((c = getopt_long(argc, argv, "HPrhkt:a", options, NULL)) >= 0) { + switch (c) { + + case ARG_HELP: + shutdown_help(); + return 0; + + case 'H': + arg_action = ACTION_HALT; + break; + + case 'P': + arg_action = ACTION_POWEROFF; + break; + + case 'r': + arg_action = ACTION_REBOOT; + break; + + case 'h': + if (arg_action != ACTION_HALT) + arg_action = ACTION_POWEROFF; + break; + + case 'k': + arg_dry = true; + break; + + case ARG_NO_WALL: + arg_no_wall = true; + break; + + case 't': + case 'a': + /* Compatibility nops */ + break; + + case '?': + return -EINVAL; + + default: + log_error("Unknown option code %c", c); + return -EINVAL; + } + } + + 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; + + 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 } + }; + + static const struct { + char from; + enum action to; + } table[] = { + { '0', ACTION_POWEROFF }, + { '6', ACTION_REBOOT }, + { '1', ACTION_RESCUE }, + { '2', ACTION_RUNLEVEL2 }, + { '3', ACTION_RUNLEVEL3 }, + { '4', ACTION_RUNLEVEL4 }, + { '5', ACTION_RUNLEVEL5 }, + { 's', ACTION_RESCUE }, + { 'S', ACTION_RESCUE }, + { 'q', ACTION_RELOAD }, + { 'Q', ACTION_RELOAD }, + { 'u', ACTION_REEXEC }, + { 'U', ACTION_REEXEC } + }; + + unsigned i; + int c; + + assert(argc >= 0); + assert(argv); + + while ((c = getopt_long(argc, argv, "", options, NULL)) >= 0) { + switch (c) { + + case ARG_HELP: + telinit_help(); + return 0; + + case ARG_NO_WALL: + arg_no_wall = true; + break; + + case '?': + return -EINVAL; + + default: + log_error("Unknown option code %c", c); + return -EINVAL; + } + } + + if (optind >= argc) { + telinit_help(); + return -EINVAL; + } + + if (optind + 1 < argc) { + log_error("Too many arguments."); + return -EINVAL; + } + + if (strlen(argv[optind]) != 1) { + log_error("Expected single character argument."); + return -EINVAL; + } + + for (i = 0; i < ELEMENTSOF(table); i++) + if (table[i].from == argv[optind][0]) + break; + + if (i >= ELEMENTSOF(table)) { + log_error("Unknown command %s.", argv[optind]); + return -EINVAL; + } + + arg_action = table[i].to; + + optind ++; + + return 1; +} + +static int runlevel_parse_argv(int argc, char *argv[]) { + + enum { + ARG_HELP = 0x100, + }; + + static const struct option options[] = { + { "help", no_argument, NULL, ARG_HELP }, + { NULL, 0, NULL, 0 } + }; + + int c; + + assert(argc >= 0); + assert(argv); + + while ((c = getopt_long(argc, argv, "", options, NULL)) >= 0) { + switch (c) { + + case ARG_HELP: + runlevel_help(); + return 0; + + case '?': + return -EINVAL; - dbus_message_iter_recurse(&iter, &sub); + default: + log_error("Unknown option code %c", c); + return -EINVAL; + } + } - 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 (optind < argc) { + log_error("Too many arguments."); + return -EINVAL; } - dbus_message_iter_recurse(&sub, &sub2); + return 1; +} - while (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_INVALID) { - const char *text; +static int parse_argv(int argc, char *argv[]) { + assert(argc >= 0); + assert(argv); - if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_STRING) { - log_error("Failed to parse reply."); - r = -EIO; - goto finish; + if (program_invocation_short_name) { + + if (strstr(program_invocation_short_name, "halt")) { + arg_action = ACTION_HALT; + return halt_parse_argv(argc, argv); + } else if (strstr(program_invocation_short_name, "poweroff")) { + arg_action = ACTION_POWEROFF; + return halt_parse_argv(argc, argv); + } else if (strstr(program_invocation_short_name, "reboot")) { + arg_action = ACTION_REBOOT; + return halt_parse_argv(argc, argv); + } else if (strstr(program_invocation_short_name, "shutdown")) { + 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); + } else if (strstr(program_invocation_short_name, "runlevel")) { + arg_action = ACTION_RUNLEVEL; + return runlevel_parse_argv(argc, argv); } - - 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); + arg_action = ACTION_SYSTEMCTL; + return systemctl_parse_argv(argc, argv); +} - if (reply) - dbus_message_unref(reply); +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' + }; - dbus_error_free(&error); + assert(arg_action < _ACTION_MAX); - return r; + return table[arg_action]; } -static int set_environment(DBusConnection *bus, char **args, unsigned n) { +static int talk_upstart(void) { DBusMessage *m = NULL, *reply = NULL; DBusError error; - int r; - const char *method; + 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; - unsigned i; + DBusConnection *bus; dbus_error_init(&error); - method = streq(args[0], "set-environment") - ? "SetEnvironment" - : "UnsetEnvironment"; + if (!(rl = action_to_runlevel())) + return 0; - if (!(m = dbus_message_new_method_call( - "org.freedesktop.systemd1", - "/org/freedesktop/systemd1", - "org.freedesktop.systemd1.Manager", - method))) { + if (utmp_get_runlevel(&previous, NULL) < 0) + previous = 'N'; - log_error("Could not allocate message."); - return -ENOMEM; + 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; } - dbus_message_iter_init_append(m, &iter); + if ((r = bus_check_peercred(bus)) < 0) { + log_error("Failed to verify owner of bus."); + goto finish; + } - if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub)) { - log_error("Could not append arguments to message."); + 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; } - 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; - } + dbus_message_iter_init_append(m, &iter); - if (!dbus_message_iter_close_container(&iter, &sub)) { + 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 = 0; + r = 1; finish: if (m) @@ -1287,115 +2961,50 @@ finish: if (reply) dbus_message_unref(reply); + if (bus) + dbus_connection_unref(bus); + dbus_error_free(&error); return r; } -static int help(void) { - - printf("%s [options]\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" - "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" - " 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" - " 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", - __progname); - - return 0; -} - -static int parse_argv(int argc, char *argv[]) { - - enum { - ARG_REPLACE = 0x100, - ARG_SESSION, - ARG_SYSTEM, - ARG_BLOCK, - }; - - 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 } - }; - - int c; +static int talk_initctl(void) { + struct init_request request; + int r, fd; + char rl; - assert(argc >= 1); - assert(argv); + if (!(rl = action_to_runlevel())) + return 0; - while ((c = getopt_long(argc, argv, "hta", options, NULL)) >= 0) { + zero(request); + request.magic = INIT_MAGIC; + request.sleeptime = 0; + request.cmd = INIT_CMD_RUNLVL; + request.runlevel = rl; - switch (c) { + if ((fd = open(INIT_FIFO, O_WRONLY|O_NDELAY|O_CLOEXEC|O_NOCTTY)) < 0) { - case 'h': - help(); + if (errno == ENOENT) return 0; - case 't': - arg_type = optarg; - break; - - case 'a': - arg_all = true; - break; - - case ARG_REPLACE: - arg_replace = true; - break; - - case ARG_SESSION: - arg_session = true; - break; - - case ARG_SYSTEM: - arg_session = false; - break; - - case ARG_BLOCK: - arg_block = true; - break; + log_error("Failed to open "INIT_FIFO": %m"); + return -errno; + } - case '?': - return -EINVAL; + errno = 0; + r = loop_write(fd, &request, sizeof(request), false) != sizeof(request); + close_nointr_nofail(fd); - default: - log_error("Unknown option code %c", c); - return -EINVAL; - } + if (r < 0) { + log_error("Failed to write to "INIT_FIFO": %m"); + return errno ? -errno : -EIO; } return 1; } -int main(int argc, char*argv[]) { +static int systemctl_main(DBusConnection *bus, int argc, char *argv[]) { static const struct { const char* verb; @@ -1416,34 +3025,34 @@ int main(int argc, char*argv[]) { { "stop", MORE, 2, start_unit }, { "reload", MORE, 2, start_unit }, { "restart", MORE, 2, start_unit }, - { "isolate", EQUAL, 2, isolate_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 } }; - int r, retval = 1, left; + int left; unsigned i; - DBusConnection *bus = NULL; - DBusError error; - - dbus_error_init(&error); - log_set_target(LOG_TARGET_CONSOLE); - log_parse_environment(); - - if ((r = parse_argv(argc, argv)) < 0) - goto finish; - else if (r == 0) { - retval = 0; - goto finish; - } + assert(bus); + assert(argc >= 0); + assert(argv); left = argc - optind; @@ -1451,13 +3060,18 @@ int main(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; if (i >= ELEMENTSOF(verbs)) { log_error("Unknown operation %s", argv[optind]); - goto finish; + return -EINVAL; } } @@ -1466,7 +3080,7 @@ int main(int argc, char*argv[]) { case EQUAL: if (left != verbs[i].argc) { log_error("Invalid number of arguments."); - goto finish; + return -EINVAL; } break; @@ -1474,7 +3088,7 @@ int main(int argc, char*argv[]) { case MORE: if (left < verbs[i].argc) { log_error("Too few arguments."); - goto finish; + return -EINVAL; } break; @@ -1482,7 +3096,7 @@ int main(int argc, char*argv[]) { case LESS: if (left > verbs[i].argc) { log_error("Too many arguments."); - goto finish; + return -EINVAL; } break; @@ -1491,20 +3105,186 @@ int main(int argc, char*argv[]) { assert_not_reached("Unknown comparison operator."); } - if (!(bus = dbus_bus_get(arg_session ? DBUS_BUS_SESSION : DBUS_BUS_SYSTEM, &error))) { - log_error("Failed to get D-Bus connection: %s", error.message); + return verbs[i].dispatch(bus, argv + optind, left); +} + +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) + return 0; + } + + /* Nothing else worked, so let's try signals */ + assert(arg_action == ACTION_RELOAD || arg_action == ACTION_REEXEC); + + if (kill(1, arg_action == ACTION_RELOAD ? SIGHUP : SIGTERM) < 0) { + log_error("kill() failed: %m"); + return -errno; + } + + return 0; +} + +static int start_with_fallback(DBusConnection *bus) { + int r; + + warn_wall(arg_action); + + if (bus) { + /* First, try systemd via D-Bus. */ + if ((r = start_unit(bus, NULL, 0)) > 0) + return 0; + + /* 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) + return 0; + } + + /* Nothing else worked, so let's try + * /dev/initctl */ + if ((r = talk_initctl()) != 0) + return 0; + + log_error("Failed to talk to init daemon."); + return -EIO; +} + +static int halt_main(DBusConnection *bus) { + int r; + + if (!arg_dry && !arg_immediate) + return start_with_fallback(bus); + + if (!arg_no_wtmp) + if ((r = utmp_put_shutdown(0)) < 0) + log_warning("Failed to write utmp record: %s", strerror(-r)); + + if (!arg_no_sync) + sync(); + + if (arg_dry) + return 0; + + /* Make sure C-A-D is handled by the kernel from this + * point on... */ + reboot(RB_ENABLE_CAD); + + switch (arg_action) { + + case ACTION_HALT: + log_info("Halting"); + reboot(RB_HALT_SYSTEM); + break; + + case ACTION_POWEROFF: + log_info("Powering off"); + reboot(RB_POWER_OFF); + break; + + case ACTION_REBOOT: + log_info("Rebooting"); + reboot(RB_AUTOBOOT); + break; + + default: + assert_not_reached("Unknown halt action."); + } + + /* We should never reach this. */ + return -ENOSYS; +} + +static int runlevel_main(void) { + int r, runlevel, previous; + + if ((r = utmp_get_runlevel(&runlevel, &previous)) < 0) { + printf("unknown"); + return r; + } + + printf("%c %c\n", + previous <= 0 ? 'N' : previous, + runlevel <= 0 ? 'N' : runlevel); + + return 0; +} + +int main(int argc, char*argv[]) { + int r, retval = 1; + DBusConnection *bus = NULL; + DBusError error; + + dbus_error_init(&error); + + log_parse_environment(); + + if ((r = parse_argv(argc, argv)) < 0) + goto finish; + else if (r == 0) { + retval = 0; + 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; goto finish; } - dbus_connection_set_exit_on_disconnect(bus, FALSE); + bus_connect(arg_session ? DBUS_BUS_SESSION : DBUS_BUS_SYSTEM, &bus, &private_bus, &error); + + 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; + break; + } + + case ACTION_HALT: + case ACTION_POWEROFF: + case ACTION_REBOOT: + retval = halt_main(bus) < 0; + break; + + case ACTION_RUNLEVEL2: + case ACTION_RUNLEVEL3: + case ACTION_RUNLEVEL4: + case ACTION_RUNLEVEL5: + case ACTION_RESCUE: + case ACTION_EMERGENCY: + case ACTION_DEFAULT: + retval = start_with_fallback(bus) < 0; + break; + + case ACTION_RELOAD: + case ACTION_REEXEC: + retval = reload_with_fallback(bus) < 0; + break; - retval = verbs[i].dispatch(bus, argv + optind, left) < 0; + case ACTION_INVALID: + case ACTION_RUNLEVEL: + default: + assert_not_reached("Unknown action"); + } finish: if (bus) dbus_connection_unref(bus); + dbus_error_free(&error); + dbus_shutdown(); return retval;