X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fsystemctl.c;h=0de2444d43edb62bd420e7435fc364610fb0fadf;hp=671745b7d001500ac5bfcf45d126960b88cdbee2;hb=798e258d301ac237cb1d72b5fc4b19ee900d6f7d;hpb=560d8f23811162542c1748f711ea6dce269d2720 diff --git a/src/systemctl.c b/src/systemctl.c index 671745b7d..0de2444d4 100644 --- a/src/systemctl.c +++ b/src/systemctl.c @@ -32,7 +32,7 @@ #include #include #include - +#include #include #include "log.h" @@ -55,15 +55,19 @@ #include "bus-errors.h" #include "build.h" #include "unit-name.h" +#include "pager.h" +#include "spawn-agent.h" +#include "install.h" static const char *arg_type = NULL; static char **arg_property = NULL; static bool arg_all = false; -static bool arg_fail = false; -static bool arg_session = false; -static bool arg_global = false; +static const char *arg_job_mode = "replace"; +static UnitFileScope arg_scope = UNIT_FILE_SYSTEM; static bool arg_immediate = false; static bool arg_no_block = false; +static bool arg_no_legend = false; +static bool arg_no_pager = false; static bool arg_no_wtmp = false; static bool arg_no_sync = false; static bool arg_no_wall = false; @@ -72,8 +76,14 @@ static bool arg_dry = false; static bool arg_quiet = false; static bool arg_full = false; static bool arg_force = false; -static bool arg_defaults = false; +static bool arg_ask_password = false; +static bool arg_failed = false; +static bool arg_runtime = false; static char **arg_wall = NULL; +static const char *arg_kill_who = NULL; +static const char *arg_kill_mode = NULL; +static int arg_signal = SIGTERM; +static const char *arg_root = NULL; static usec_t arg_when = 0; static enum action { ACTION_INVALID, @@ -81,6 +91,8 @@ static enum action { ACTION_HALT, ACTION_POWEROFF, ACTION_REBOOT, + ACTION_KEXEC, + ACTION_EXIT, ACTION_RUNLEVEL2, ACTION_RUNLEVEL3, ACTION_RUNLEVEL4, @@ -99,20 +111,56 @@ static enum dot { DOT_ORDER, DOT_REQUIRE } arg_dot = DOT_ALL; +static enum transport { + TRANSPORT_NORMAL, + TRANSPORT_SSH, + TRANSPORT_POLKIT +} arg_transport = TRANSPORT_NORMAL; +static const char *arg_host = NULL; static bool private_bus = false; -static int daemon_reload(DBusConnection *bus, char **args, unsigned n); +static int daemon_reload(DBusConnection *bus, char **args); static bool on_tty(void) { static int t = -1; + /* Note that this is invoked relatively early, before we start + * the pager. That means the value we return reflects whether + * we originally were started on a tty, not if we currently + * are. But this is intended, since we want colour and so on + * when run in our own pager. */ + if (_unlikely_(t < 0)) t = isatty(STDOUT_FILENO) > 0; return t; } +static void pager_open_if_enabled(void) { + + /* Cache result before we open the pager */ + on_tty(); + + if (arg_no_pager) + return; + + pager_open(); +} + +static void agent_open_if_enabled(void) { + + /* Open the password agent as a child process if necessary */ + + if (!arg_ask_password) + return; + + if (arg_scope != UNIT_FILE_SYSTEM) + return; + + agent_open(); +} + static const char *ansi_highlight(bool b) { if (!on_tty()) @@ -172,27 +220,12 @@ static int translate_bus_error_to_exit_status(int r, const DBusError *error) { return EXIT_FAILURE; } -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; - - dbus_message_iter_get_basic(iter, data); - - if (!dbus_message_iter_next(iter) != !next) - return -EIO; - - return 0; -} - 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_KEXEC] = "The system is going down for kexec reboot NOW!", [ACTION_RESCUE] = "The system is going down to rescue mode NOW!", [ACTION_EMERGENCY] = "The system is going down to emergency mode NOW!" }; @@ -209,7 +242,7 @@ static void warn_wall(enum action action) { } if (*p) { - utmp_wall(p); + utmp_wall(p, NULL); free(p); return; } @@ -220,7 +253,24 @@ static void warn_wall(enum action action) { if (!table[action]) return; - utmp_wall(table[action]); + utmp_wall(table[action], NULL); +} + +static bool avoid_bus(void) { + + if (running_in_chroot() > 0) + return true; + + if (sd_booted() <= 0) + return true; + + if (!isempty(arg_root)) + return true; + + if (arg_scope == UNIT_FILE_GLOBAL) + return true; + + return false; } struct unit_info { @@ -253,50 +303,80 @@ static int compare_unit_info(const void *a, const void *b) { return strcasecmp(u->id, v->id); } -static bool output_show_job(const struct unit_info *u) { +static bool output_show_unit(const struct unit_info *u) { const char *dot; + if (arg_failed) + return streq(u->active_state, "failed"); + return (!arg_type || ((dot = strrchr(u->id, '.')) && streq(dot+1, arg_type))) && (arg_all || !(streq(u->active_state, "inactive") || u->following[0]) || u->job_id > 0); } static void output_units_list(const struct unit_info *unit_infos, unsigned c) { - unsigned active_len, sub_len, job_len; + unsigned id_len, max_id_len, active_len, sub_len, job_len, desc_len, n_shown = 0; const struct unit_info *u; + max_id_len = sizeof("UNIT")-1; active_len = sizeof("ACTIVE")-1; sub_len = sizeof("SUB")-1; job_len = sizeof("JOB")-1; + desc_len = 0; for (u = unit_infos; u < unit_infos + c; u++) { - if (!output_show_job(u)) + if (!output_show_unit(u)) continue; + max_id_len = MAX(max_id_len, strlen(u->id)); active_len = MAX(active_len, strlen(u->active_state)); sub_len = MAX(sub_len, strlen(u->sub_state)); if (u->job_id != 0) job_len = MAX(job_len, strlen(u->job_type)); } - if (on_tty()) { - printf("%-25s %-6s %-*s %-*s %-*s", "UNIT", "LOAD", + if (!arg_full) { + unsigned basic_len; + id_len = MIN(max_id_len, 25); + basic_len = 5 + id_len + 6 + active_len + sub_len + job_len; + if (basic_len < (unsigned) columns()) { + unsigned extra_len, incr; + extra_len = columns() - basic_len; + /* Either UNIT already got 25, or is fully satisfied. + * Grant up to 25 to DESC now. */ + incr = MIN(extra_len, 25); + desc_len += incr; + extra_len -= incr; + /* split the remaining space between UNIT and DESC, + * but do not give UNIT more than it needs. */ + if (extra_len > 0) { + incr = MIN(extra_len / 2, max_id_len - id_len); + id_len += incr; + desc_len += extra_len - incr; + } + } + } else + id_len = max_id_len; + + if (!arg_no_legend) { + printf("%-*s %-6s %-*s %-*s %-*s ", id_len, "UNIT", "LOAD", active_len, "ACTIVE", sub_len, "SUB", job_len, "JOB"); - if (columns() >= 80+12 || arg_full) - printf(" %s\n", "DESCRIPTION"); + if (!arg_full && arg_no_pager) + printf("%.*s\n", desc_len, "DESCRIPTION"); else - printf("\n"); + printf("%s\n", "DESCRIPTION"); } for (u = unit_infos; u < unit_infos + c; u++) { char *e; - int a = 0, b = 0; const char *on_loaded, *off_loaded; const char *on_active, *off_active; - if (!output_show_job(u)) + if (!output_show_unit(u)) continue; + n_shown++; + if (!streq(u->load_state, "loaded") && !streq(u->load_state, "banned")) { on_loaded = ansi_highlight(true); @@ -310,52 +390,36 @@ static void output_units_list(const struct unit_info *unit_infos, unsigned c) { } else on_active = off_active = ""; - e = arg_full ? NULL : ellipsize(u->id, 25, 33); + e = arg_full ? NULL : ellipsize(u->id, id_len, 33); - printf("%-25s %s%-6s%s %s%-*s %-*s%s%n", - e ? e : u->id, + printf("%-*s %s%-6s%s %s%-*s %-*s%s %-*s ", + id_len, e ? e : u->id, on_loaded, u->load_state, off_loaded, on_active, active_len, u->active_state, sub_len, u->sub_state, off_active, - &a); - - free(e); - - a -= strlen(on_loaded) + strlen(off_loaded); - a -= strlen(on_active) + strlen(off_active); - - if (u->job_id != 0) - printf(" %-*s", job_len, u->job_type); + job_len, u->job_id ? u->job_type : ""); + if (!arg_full && arg_no_pager) + printf("%.*s\n", desc_len, u->description); else - b = 1 + job_len; - - if (a + b + 1 < columns()) { - if (u->job_id == 0) - printf(" %-*s", job_len, ""); - - if (arg_full) - printf(" %s", u->description); - else - printf(" %.*s", columns() - a - b - 1, u->description); - } + printf("%s\n", u->description); - fputs("\n", stdout); + free(e); } - if (on_tty()) { + if (!arg_no_legend) { printf("\nLOAD = Reflects whether the unit definition was properly loaded.\n" "ACTIVE = The high-level unit activation state, i.e. generalization of SUB.\n" "SUB = The low-level unit activation state, values depend on unit type.\n" "JOB = Pending job for the unit.\n"); if (arg_all) - printf("\n%u units listed.\n", c); + printf("\n%u units listed.\n", n_shown); else - printf("\n%u units listed. Pass --all to see inactive units, too.\n", c); + printf("\n%u units listed. Pass --all to see inactive units, too.\n", n_shown); } } -static int list_units(DBusConnection *bus, char **args, unsigned n) { +static int list_units(DBusConnection *bus, char **args) { DBusMessage *m = NULL, *reply = NULL; DBusError error; int r; @@ -367,6 +431,8 @@ static int list_units(DBusConnection *bus, char **args, unsigned n) { assert(bus); + pager_open_if_enabled(); + if (!(m = dbus_message_new_method_call( "org.freedesktop.systemd1", "/org/freedesktop/systemd1", @@ -439,8 +505,10 @@ static int list_units(DBusConnection *bus, char **args, unsigned n) { c++; } - qsort(unit_infos, c, sizeof(struct unit_info), compare_unit_info); - output_units_list(unit_infos, c); + if (c > 0) { + qsort(unit_infos, c, sizeof(struct unit_info), compare_unit_info); + output_units_list(unit_infos, c); + } r = 0; @@ -458,6 +526,211 @@ finish: return r; } +static int compare_unit_file_list(const void *a, const void *b) { + const char *d1, *d2; + const UnitFileList *u = a, *v = b; + + d1 = strrchr(u->path, '.'); + d2 = strrchr(v->path, '.'); + + if (d1 && d2) { + int r; + + r = strcasecmp(d1, d2); + if (r != 0) + return r; + } + + return strcasecmp(file_name_from_path(u->path), file_name_from_path(v->path)); +} + +static bool output_show_unit_file(const UnitFileList *u) { + const char *dot; + + return !arg_type || ((dot = strrchr(u->path, '.')) && streq(dot+1, arg_type)); +} + +static void output_unit_file_list(const UnitFileList *units, unsigned c) { + unsigned n_shown = 0; + const UnitFileList *u; + + if (on_tty()) + printf("%-25s %-6s\n", "UNIT FILE", "STATE"); + + for (u = units; u < units + c; u++) { + char *e; + const char *on, *off; + const char *id; + + if (!output_show_unit_file(u)) + continue; + + n_shown++; + + if (u->state == UNIT_FILE_MASKED || + u->state == UNIT_FILE_MASKED_RUNTIME || + u->state == UNIT_FILE_DISABLED) { + on = ansi_highlight(true); + off = ansi_highlight(false); + } else if (u->state == UNIT_FILE_ENABLED) { + on = ansi_highlight_green(true); + off = ansi_highlight_green(false); + } else + on = off = ""; + + id = file_name_from_path(u->path); + + e = arg_full ? NULL : ellipsize(id, 25, 33); + + printf("%-25s %s%-6s%s\n", + e ? e : id, + on, unit_file_state_to_string(u->state), off); + + free(e); + } + + if (on_tty()) + printf("\n%u unit files listed.\n", n_shown); +} + +static int list_unit_files(DBusConnection *bus, char **args) { + DBusMessage *m = NULL, *reply = NULL; + DBusError error; + int r; + DBusMessageIter iter, sub, sub2; + unsigned c = 0, n_units = 0; + UnitFileList *units = NULL; + + dbus_error_init(&error); + + assert(bus); + + pager_open_if_enabled(); + + if (avoid_bus()) { + Hashmap *h; + UnitFileList *u; + Iterator i; + + h = hashmap_new(string_hash_func, string_compare_func); + if (!h) { + log_error("Out of memory"); + return -ENOMEM; + } + + r = unit_file_get_list(arg_scope, arg_root, h); + if (r < 0) { + unit_file_list_free(h); + log_error("Failed to get unit file list: %s", strerror(-r)); + return r; + } + + n_units = hashmap_size(h); + units = new(UnitFileList, n_units); + if (!units) { + unit_file_list_free(h); + log_error("Out of memory"); + return -ENOMEM; + } + + HASHMAP_FOREACH(u, h, i) { + memcpy(units + c++, u, sizeof(UnitFileList)); + free(u); + } + + hashmap_free(h); + } else { + m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "ListUnitFiles"); + if (!m) { + log_error("Could not allocate message."); + return -ENOMEM; + } + + reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error); + if (!reply) { + log_error("Failed to issue method call: %s", bus_error_message(&error)); + r = -EIO; + goto finish; + } + + if (!dbus_message_iter_init(reply, &iter) || + dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY || + dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } + + dbus_message_iter_recurse(&iter, &sub); + + while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { + UnitFileList *u; + const char *state; + + if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } + + if (c >= n_units) { + UnitFileList *w; + + n_units = MAX(2*c, 16); + w = realloc(units, sizeof(struct UnitFileList) * n_units); + + if (!w) { + log_error("Failed to allocate unit array."); + r = -ENOMEM; + goto finish; + } + + units = w; + } + + u = units+c; + + dbus_message_iter_recurse(&sub, &sub2); + + if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->path, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &state, false) < 0) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } + + u->state = unit_file_state_from_string(state); + + dbus_message_iter_next(&sub); + c++; + } + } + + if (c > 0) { + qsort(units, c, sizeof(UnitFileList), compare_unit_file_list); + output_unit_file_list(units, c); + } + + r = 0; + +finish: + if (m) + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); + + free(units); + + dbus_error_free(&error); + + return r; +} + static int dot_one_property(const char *name, const char *prop, DBusMessageIter *iter) { static const char * const colors[] = { "Requires", "[color=\"black\"]", @@ -610,7 +883,7 @@ finish: return r; } -static int dot(DBusConnection *bus, char **args, unsigned n) { +static int dot(DBusConnection *bus, char **args) { DBusMessage *m = NULL, *reply = NULL; DBusError error; int r; @@ -684,7 +957,7 @@ static int dot(DBusConnection *bus, char **args, unsigned n) { " red = Conflicts\n" " green = After\n"); - if (isatty(fileno(stdout))) + if (on_tty()) log_notice("-- You probably want to process this output with graphviz' dot tool.\n" "-- Try a shell pipeline like 'systemctl dot | dot -Tsvg > systemd.svg'!\n"); @@ -702,7 +975,7 @@ finish: return r; } -static int list_jobs(DBusConnection *bus, char **args, unsigned n) { +static int list_jobs(DBusConnection *bus, char **args) { DBusMessage *m = NULL, *reply = NULL; DBusError error; int r; @@ -713,6 +986,8 @@ static int list_jobs(DBusConnection *bus, char **args, unsigned n) { assert(bus); + pager_open_if_enabled(); + if (!(m = dbus_message_new_method_call( "org.freedesktop.systemd1", "/org/freedesktop/systemd1", @@ -738,7 +1013,7 @@ static int list_jobs(DBusConnection *bus, char **args, unsigned n) { dbus_message_iter_recurse(&iter, &sub); - if (isatty(STDOUT_FILENO)) + if (on_tty()) printf("%4s %-25s %-15s %-7s\n", "JOB", "UNIT", "TYPE", "STATE"); while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { @@ -774,7 +1049,7 @@ static int list_jobs(DBusConnection *bus, char **args, unsigned n) { dbus_message_iter_next(&sub); } - if (isatty(STDOUT_FILENO)) + if (on_tty()) printf("\n%u jobs listed.\n", k); r = 0; @@ -791,18 +1066,19 @@ finish: return r; } -static int load_unit(DBusConnection *bus, char **args, unsigned n) { - DBusMessage *m = NULL, *reply = NULL; +static int load_unit(DBusConnection *bus, char **args) { + DBusMessage *m = NULL; DBusError error; int r; - unsigned i; + char **name; dbus_error_init(&error); assert(bus); assert(args); - for (i = 1; i < n; i++) { + STRV_FOREACH(name, args+1) { + DBusMessage *reply; if (!(m = dbus_message_new_method_call( "org.freedesktop.systemd1", @@ -815,7 +1091,7 @@ static int load_unit(DBusConnection *bus, char **args, unsigned n) { } if (!dbus_message_append_args(m, - DBUS_TYPE_STRING, &args[i], + DBUS_TYPE_STRING, name, DBUS_TYPE_INVALID)) { log_error("Could not append arguments to message."); r = -ENOMEM; @@ -840,29 +1116,26 @@ finish: if (m) dbus_message_unref(m); - if (reply) - dbus_message_unref(reply); - dbus_error_free(&error); return r; } -static int cancel_job(DBusConnection *bus, char **args, unsigned n) { +static int cancel_job(DBusConnection *bus, char **args) { DBusMessage *m = NULL, *reply = NULL; DBusError error; int r; - unsigned i; + char **name; dbus_error_init(&error); assert(bus); assert(args); - if (n <= 1) - return daemon_reload(bus, args, n); + if (strv_length(args) <= 1) + return daemon_reload(bus, args); - for (i = 1; i < n; i++) { + STRV_FOREACH(name, args+1) { unsigned id; const char *path; @@ -876,7 +1149,7 @@ static int cancel_job(DBusConnection *bus, char **args, unsigned n) { goto finish; } - if ((r = safe_atou(args[i], &id)) < 0) { + if ((r = safe_atou(*name, &id)) < 0) { log_error("Failed to parse job id: %s", strerror(-r)); goto finish; } @@ -1014,7 +1287,7 @@ finish: typedef struct WaitData { Set *set; - bool failed; + char *result; } WaitData; static DBusHandlerResult wait_filter(DBusConnection *connection, DBusMessage *message, void *data) { @@ -1038,26 +1311,52 @@ 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; + const char *path, *result; 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", bus_error_message(&error)); - else { + if (dbus_message_get_args(message, &error, + DBUS_TYPE_UINT32, &id, + DBUS_TYPE_OBJECT_PATH, &path, + DBUS_TYPE_STRING, &result, + DBUS_TYPE_INVALID)) { + char *p; + + if ((p = set_remove(d->set, (char*) path))) + free(p); + + if (*result) + d->result = strdup(result); + + goto finish; + } +#ifndef LEGACY + dbus_error_free(&error); + + if (dbus_message_get_args(message, &error, + DBUS_TYPE_UINT32, &id, + DBUS_TYPE_OBJECT_PATH, &path, + DBUS_TYPE_BOOLEAN, &success, + DBUS_TYPE_INVALID)) { char *p; + /* Compatibility with older systemd versions < + * 19 during upgrades. This should be dropped + * one day */ + if ((p = set_remove(d->set, (char*) path))) free(p); if (!success) - d->failed = true; + d->result = strdup("failed"); + + goto finish; } +#endif + + log_error("Failed to parse message: %s", bus_error_message(&error)); } +finish: dbus_error_free(&error); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } @@ -1098,7 +1397,6 @@ static int wait_for_jobs(DBusConnection *bus, Set *s) { zero(d); d.set = s; - d.failed = false; if (!dbus_connection_add_filter(bus, wait_filter, &d, NULL)) { log_error("Failed to add filter."); @@ -1110,10 +1408,27 @@ static int wait_for_jobs(DBusConnection *bus, Set *s) { dbus_connection_read_write_dispatch(bus, -1)) ; - if (!arg_quiet && d.failed) - log_error("Job failed, see system logs for details."); + if (!arg_quiet && d.result) { + if (streq(d.result, "timeout")) + log_error("Job timed out."); + else if (streq(d.result, "canceled")) + log_error("Job canceled."); + else if (streq(d.result, "dependency")) + log_error("A dependency job failed. See system logs for details."); + else if (!streq(d.result, "done") && !streq(d.result, "skipped")) + log_error("Job failed. See system logs and 'systemctl status' for details."); + } + + if (streq_ptr(d.result, "timeout")) + r = -ETIME; + else if (streq_ptr(d.result, "canceled")) + r = -ECANCELED; + else if (!streq_ptr(d.result, "done") && !streq_ptr(d.result, "skipped")) + r = -EIO; + else + r = 0; - r = d.failed ? -EIO : 0; + free(d.result); finish: /* This is slightly dirty, since we don't undo the filter registration. */ @@ -1182,8 +1497,8 @@ static int start_unit_one( } if (need_daemon_reload(bus, name)) - log_warning("Unit file of created job changed on disk, 'systemctl %s daemon-reload' recommended.", - arg_session ? "--session" : "--system"); + log_warning("Warning: Unit file of created job changed on disk, 'systemctl %s daemon-reload' recommended.", + arg_scope == UNIT_FILE_SYSTEM ? "--system" : "--user"); if (!arg_no_block) { char *p; @@ -1220,59 +1535,71 @@ static enum action verb_to_action(const char *verb) { return ACTION_POWEROFF; else if (streq(verb, "reboot")) return ACTION_REBOOT; + else if (streq(verb, "kexec")) + return ACTION_KEXEC; else if (streq(verb, "rescue")) return ACTION_RESCUE; else if (streq(verb, "emergency")) return ACTION_EMERGENCY; else if (streq(verb, "default")) return ACTION_DEFAULT; + else if (streq(verb, "exit")) + return ACTION_EXIT; else return ACTION_INVALID; } -static int start_unit(DBusConnection *bus, char **args, unsigned n) { +static int start_unit(DBusConnection *bus, char **args) { static const char * const table[_ACTION_MAX] = { [ACTION_HALT] = SPECIAL_HALT_TARGET, [ACTION_POWEROFF] = SPECIAL_POWEROFF_TARGET, [ACTION_REBOOT] = SPECIAL_REBOOT_TARGET, + [ACTION_KEXEC] = SPECIAL_KEXEC_TARGET, [ACTION_RUNLEVEL2] = SPECIAL_RUNLEVEL2_TARGET, [ACTION_RUNLEVEL3] = SPECIAL_RUNLEVEL3_TARGET, [ACTION_RUNLEVEL4] = SPECIAL_RUNLEVEL4_TARGET, [ACTION_RUNLEVEL5] = SPECIAL_RUNLEVEL5_TARGET, [ACTION_RESCUE] = SPECIAL_RESCUE_TARGET, [ACTION_EMERGENCY] = SPECIAL_EMERGENCY_TARGET, - [ACTION_DEFAULT] = SPECIAL_DEFAULT_TARGET + [ACTION_DEFAULT] = SPECIAL_DEFAULT_TARGET, + [ACTION_EXIT] = SPECIAL_EXIT_TARGET }; int r, ret = 0; - unsigned i; const char *method, *mode, *one_name; Set *s = NULL; DBusError error; + char **name; dbus_error_init(&error); assert(bus); + agent_open_if_enabled(); + if (arg_action == ACTION_SYSTEMCTL) { method = - streq(args[0], "stop") ? "StopUnit" : + streq(args[0], "stop") || + streq(args[0], "condstop") ? "StopUnit" : streq(args[0], "reload") ? "ReloadUnit" : streq(args[0], "restart") ? "RestartUnit" : + streq(args[0], "try-restart") || streq(args[0], "condrestart") ? "TryRestartUnit" : + streq(args[0], "reload-or-restart") ? "ReloadOrRestartUnit" : + streq(args[0], "reload-or-try-restart") || + streq(args[0], "condreload") || + streq(args[0], "force-reload") ? "ReloadOrTryRestartUnit" : "StartUnit"; mode = (streq(args[0], "isolate") || streq(args[0], "rescue") || - streq(args[0], "emergency")) ? "isolate" : - arg_fail ? "fail" : - "replace"; + streq(args[0], "emergency")) ? "isolate" : arg_job_mode; one_name = table[verb_to_action(args[0])]; @@ -1309,8 +1636,8 @@ static int start_unit(DBusConnection *bus, char **args, unsigned n) { if ((ret = start_unit_one(bus, method, one_name, mode, &error, s)) <= 0) goto finish; } else { - for (i = 1; i < n; i++) - if ((r = start_unit_one(bus, method, args[i], mode, &error, s)) != 0) { + STRV_FOREACH(name, args+1) + if ((r = start_unit_one(bus, method, *name, mode, &error, s)) != 0) { ret = translate_bus_error_to_exit_status(r, &error); dbus_error_free(&error); } @@ -1331,13 +1658,21 @@ finish: return ret; } -static int start_special(DBusConnection *bus, char **args, unsigned n) { +static int start_special(DBusConnection *bus, char **args) { int r; assert(bus); assert(args); - r = start_unit(bus, args, n); + if (arg_force && + (streq(args[0], "halt") || + streq(args[0], "poweroff") || + streq(args[0], "reboot") || + streq(args[0], "kexec") || + streq(args[0], "exit"))) + return daemon_reload(bus, args); + + r = start_unit(bus, args); if (r >= 0) warn_wall(verb_to_action(args[0])); @@ -1345,21 +1680,21 @@ static int start_special(DBusConnection *bus, char **args, unsigned n) { return r; } -static int check_unit(DBusConnection *bus, char **args, unsigned n) { +static int check_unit(DBusConnection *bus, char **args) { DBusMessage *m = NULL, *reply = NULL; const char *interface = "org.freedesktop.systemd1.Unit", *property = "ActiveState"; int r = 3; /* According to LSB: "program is not running" */ DBusError error; - unsigned i; + char **name; assert(bus); assert(args); dbus_error_init(&error); - for (i = 1; i < n; i++) { + STRV_FOREACH(name, args+1) { const char *path = NULL; const char *state; DBusMessageIter iter, sub; @@ -1375,7 +1710,7 @@ static int check_unit(DBusConnection *bus, char **args, unsigned n) { } if (!dbus_message_append_args(m, - DBUS_TYPE_STRING, &args[i], + DBUS_TYPE_STRING, name, DBUS_TYPE_INVALID)) { log_error("Could not append arguments to message."); r = -ENOMEM; @@ -1389,6 +1724,8 @@ static int check_unit(DBusConnection *bus, char **args, unsigned n) { puts("unknown"); dbus_error_free(&error); + dbus_message_unref(m); + m = NULL; continue; } @@ -1467,43 +1804,109 @@ finish: return r; } -typedef struct ExecStatusInfo { - char *path; - char **argv; +static int kill_unit(DBusConnection *bus, char **args) { + DBusMessage *m = NULL; + int r = 0; + DBusError error; + char **name; - bool ignore; + assert(bus); + assert(args); - usec_t start_timestamp; - usec_t exit_timestamp; - pid_t pid; - int code; - int status; + dbus_error_init(&error); - LIST_FIELDS(struct ExecStatusInfo, exec); -} ExecStatusInfo; + if (!arg_kill_who) + arg_kill_who = "all"; -static void exec_status_info_free(ExecStatusInfo *i) { - assert(i); + if (!arg_kill_mode) + arg_kill_mode = streq(arg_kill_who, "all") ? "control-group" : "process"; - free(i->path); - strv_free(i->argv); - free(i); -} + STRV_FOREACH(name, args+1) { + DBusMessage *reply; -static int exec_status_info_deserialize(DBusMessageIter *sub, ExecStatusInfo *i) { - uint64_t start_timestamp, exit_timestamp; - DBusMessageIter sub2, sub3; - const char*path; - unsigned n; - uint32_t pid; - int32_t code, status; - dbus_bool_t ignore; + if (!(m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "KillUnit"))) { + log_error("Could not allocate message."); + r = -ENOMEM; + goto finish; + } - assert(i); - assert(i); + if (!dbus_message_append_args(m, + DBUS_TYPE_STRING, name, + DBUS_TYPE_STRING, &arg_kill_who, + DBUS_TYPE_STRING, &arg_kill_mode, + DBUS_TYPE_INT32, &arg_signal, + DBUS_TYPE_INVALID)) { + log_error("Could not append arguments to message."); + r = -ENOMEM; + goto finish; + } - if (dbus_message_iter_get_arg_type(sub) != DBUS_TYPE_STRUCT) - return -EIO; + if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { + log_error("Failed to issue method call: %s", bus_error_message(&error)); + dbus_error_free(&error); + r = -EIO; + } + + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); + m = reply = NULL; + } + +finish: + if (m) + dbus_message_unref(m); + + dbus_error_free(&error); + + return r; +} + +typedef struct ExecStatusInfo { + char *name; + + char *path; + char **argv; + + bool ignore; + + usec_t start_timestamp; + usec_t exit_timestamp; + pid_t pid; + int code; + int status; + + LIST_FIELDS(struct ExecStatusInfo, exec); +} ExecStatusInfo; + +static void exec_status_info_free(ExecStatusInfo *i) { + assert(i); + + free(i->name); + free(i->path); + strv_free(i->argv); + free(i); +} + +static int exec_status_info_deserialize(DBusMessageIter *sub, ExecStatusInfo *i) { + uint64_t start_timestamp, exit_timestamp, start_timestamp_monotonic, exit_timestamp_monotonic; + DBusMessageIter sub2, sub3; + const char*path; + unsigned n; + uint32_t pid; + int32_t code, status; + dbus_bool_t ignore; + + assert(i); + assert(i); + + if (dbus_message_iter_get_arg_type(sub) != DBUS_TYPE_STRUCT) + return -EIO; dbus_message_iter_recurse(sub, &sub2); @@ -1545,7 +1948,9 @@ static int exec_status_info_deserialize(DBusMessageIter *sub, ExecStatusInfo *i) if (!dbus_message_iter_next(&sub2) || bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_BOOLEAN, &ignore, true) < 0 || bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &start_timestamp, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &start_timestamp_monotonic, true) < 0 || bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &exit_timestamp, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &exit_timestamp_monotonic, 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) @@ -1566,6 +1971,7 @@ typedef struct UnitStatusInfo { const char *load_state; const char *active_state; const char *sub_state; + const char *unit_file_state; const char *description; const char *following; @@ -1573,6 +1979,8 @@ typedef struct UnitStatusInfo { const char *path; const char *default_control_group; + const char *load_error; + usec_t inactive_exit_timestamp; usec_t active_enter_timestamp; usec_t active_exit_timestamp; @@ -1594,6 +2002,9 @@ typedef struct UnitStatusInfo { int exit_code, exit_status; + usec_t condition_timestamp; + bool condition_result; + /* Socket */ unsigned n_accepted; unsigned n_connections; @@ -1640,7 +2051,11 @@ static void print_status_info(UnitStatusInfo *i) { } else on = off = ""; - if (i->path) + if (i->load_error) + printf("\t Loaded: %s%s%s (Reason: %s)\n", on, strna(i->load_state), off, i->load_error); + else if (i->path && i->unit_file_state) + printf("\t Loaded: %s%s%s (%s; %s)\n", on, strna(i->load_state), off, i->path, i->unit_file_state); + else if (i->path) printf("\t Loaded: %s%s%s (%s)\n", on, strna(i->load_state), off, i->path); else printf("\t Loaded: %s%s%s\n", on, strna(i->load_state), off); @@ -1685,11 +2100,21 @@ static void print_status_info(UnitStatusInfo *i) { else printf("\n"); + if (!i->condition_result && i->condition_timestamp > 0) { + s1 = format_timestamp_pretty(since1, sizeof(since1), i->condition_timestamp); + s2 = format_timestamp(since2, sizeof(since2), i->condition_timestamp); + + if (s1) + printf("\t start condition failed at %s; %s\n", s2, s1); + else if (s2) + printf("\t start condition failed at %s\n", s2); + } + if (i->sysfs_path) printf("\t Device: %s\n", i->sysfs_path); - else if (i->where) + if (i->where) printf("\t Where: %s\n", i->where); - else if (i->what) + if (i->what) printf("\t What: %s\n", i->what); if (i->accept) @@ -1697,15 +2122,31 @@ static void print_status_info(UnitStatusInfo *i) { LIST_FOREACH(exec, p, i->exec) { char *t; + bool good; /* Only show exited processes here */ if (p->code == 0) continue; t = strv_join(p->argv, " "); - printf("\t Process: %u (%s, code=%s, ", p->pid, strna(t), sigchld_code_to_string(p->code)); + printf("\t Process: %u %s=%s ", p->pid, p->name, strna(t)); free(t); +#ifdef HAVE_SYSV_COMPAT + if (i->is_sysv) + good = is_clean_exit_lsb(p->code, p->status); + else +#endif + good = is_clean_exit(p->code, p->status); + + if (!good) { + on = ansi_highlight(true); + off = ansi_highlight(false); + } else + on = off = ""; + + printf("%s(code=%s, ", on, sigchld_code_to_string(p->code)); + if (p->code == CLD_EXITED) { const char *c; @@ -1720,7 +2161,8 @@ static void print_status_info(UnitStatusInfo *i) { } else printf("signal=%s", signal_to_string(p->status)); - printf(")\n"); + + printf(")%s\n", off); if (i->main_pid == p->pid && i->start_timestamp == p->start_timestamp && @@ -1792,23 +2234,29 @@ static void print_status_info(UnitStatusInfo *i) { printf("\t CGroup: %s\n", i->default_control_group); - if ((c = columns()) > 18) - c -= 18; - else - c = 0; + if (arg_transport != TRANSPORT_SSH) { + if ((c = columns()) > 18) + c -= 18; + else + c = 0; - show_cgroup_by_path(i->default_control_group, "\t\t ", c); + show_cgroup_by_path(i->default_control_group, "\t\t ", c); + } } if (i->need_daemon_reload) printf("\n%sWarning:%s Unit file changed on disk, 'systemctl %s daemon-reload' recommended.\n", ansi_highlight(true), ansi_highlight(false), - arg_session ? "--session" : "--system"); + arg_scope == UNIT_FILE_SYSTEM ? "--system" : "--user"); } static int status_property(const char *name, DBusMessageIter *iter, UnitStatusInfo *i) { + assert(name); + assert(iter); + assert(i); + switch (dbus_message_iter_get_arg_type(iter)) { case DBUS_TYPE_STRING: { @@ -1816,7 +2264,7 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn dbus_message_iter_get_basic(iter, &s); - if (s[0]) { + if (!isempty(s)) { if (streq(name, "Id")) i->id = s; else if (streq(name, "LoadState")) @@ -1847,6 +2295,8 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn i->what = s; else if (streq(name, "Following")) i->following = s; + else if (streq(name, "UnitFileState")) + i->unit_file_state = s; } break; @@ -1861,6 +2311,8 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn i->accept = b; else if (streq(name, "NeedDaemonReload")) i->need_daemon_reload = b; + else if (streq(name, "ConditionResult")) + i->condition_result = b; break; } @@ -1918,6 +2370,8 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn i->inactive_exit_timestamp = (usec_t) u; else if (streq(name, "ActiveExitTimestamp")) i->active_exit_timestamp = (usec_t) u; + else if (streq(name, "ConditionTimestamp")) + i->condition_timestamp = (usec_t) u; break; } @@ -1936,6 +2390,11 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn if (!(info = new0(ExecStatusInfo, 1))) return -ENOMEM; + if (!(info->name = strdup(name))) { + free(info); + return -ENOMEM; + } + if ((r = exec_status_info_deserialize(&sub, info)) < 0) { free(info); return r; @@ -1949,6 +2408,30 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn break; } + + case DBUS_TYPE_STRUCT: { + + if (streq(name, "LoadError")) { + DBusMessageIter sub; + const char *n, *message; + int r; + + dbus_message_iter_recurse(iter, &sub); + + r = bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &n, true); + if (r < 0) + return r; + + r = bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &message, false); + if (r < 0) + return r; + + if (!isempty(message)) + i->load_error = message; + } + + break; + } } return 0; @@ -1966,74 +2449,6 @@ static int print_property(const char *name, DBusMessageIter *iter) { 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_DOUBLE: { - double d; - dbus_message_iter_get_basic(iter, &d); - - printf("%s=%g\n", name, d); - return 0; - } - case DBUS_TYPE_STRUCT: { DBusMessageIter sub; dbus_message_iter_recurse(iter, &sub); @@ -2057,6 +2472,16 @@ static int print_property(const char *name, DBusMessageIter *iter) { if (arg_all || s[0]) printf("%s=%s\n", name, s); + return 0; + } else if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "LoadError")) { + const char *a = NULL, *b = NULL; + + if (bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &a, true) >= 0) + bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &b, false); + + if (arg_all || !isempty(a) || !isempty(b)) + printf("%s=%s \"%s\"\n", name, strempty(a), strempty(b)); + return 0; } @@ -2065,50 +2490,21 @@ static int print_property(const char *name, DBusMessageIter *iter) { 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; + if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "EnvironmentFiles")) { + DBusMessageIter sub, sub2; 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; + while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) { + const char *path; + dbus_bool_t ignore; - assert(dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_BYTE); - dbus_message_iter_get_basic(&sub, &u); - printf("%02x", u); + dbus_message_iter_recurse(&sub, &sub2); - dbus_message_iter_next(&sub); - } + if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) >= 0 && + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_BOOLEAN, &ignore, false) >= 0) + printf("EnvironmentFile=%s (ignore_errors=%s)\n", path, yes_no(ignore)); - puts(""); + dbus_message_iter_next(&sub); } return 0; @@ -2157,6 +2553,30 @@ static int print_property(const char *name, DBusMessageIter *iter) { return 0; + } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "ControlGroupAttributes")) { + DBusMessageIter sub, sub2; + + dbus_message_iter_recurse(iter, &sub); + while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) { + const char *controller, *attr, *value; + + dbus_message_iter_recurse(&sub, &sub2); + + if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &controller, true) >= 0 && + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &attr, true) >= 0 && + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &value, false) >= 0) { + + printf("ControlGroupAttribute={ controller=%s ; attribute=%s ; value=\"%s\" }\n", + controller, + attr, + value); + } + + dbus_message_iter_next(&sub); + } + + return 0; + } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && startswith(name, "Exec")) { DBusMessageIter sub; @@ -2171,7 +2591,7 @@ static int print_property(const char *name, DBusMessageIter *iter) { t = strv_join(info.argv, " "); - printf("%s={ path=%s ; argv[]=%s ; ignore=%s ; start_time=[%s] ; stop_time=[%s] ; pid=%u ; code=%s ; status=%i%s%s }\n", + printf("%s={ path=%s ; argv[]=%s ; ignore_errors=%s ; start_time=[%s] ; stop_time=[%s] ; pid=%u ; code=%s ; status=%i%s%s }\n", name, strna(info.path), strna(t), @@ -2199,13 +2619,16 @@ static int print_property(const char *name, DBusMessageIter *iter) { break; } + if (generic_print_property(name, iter, arg_all) > 0) + return 0; + 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) { +static int show_one(const char *verb, DBusConnection *bus, const char *path, bool show_properties, bool *new_line) { DBusMessage *m = NULL, *reply = NULL; const char *interface = ""; int r; @@ -2305,7 +2728,8 @@ static int show_one(DBusConnection *bus, const char *path, bool show_properties, print_status_info(&info); if (!streq_ptr(info.active_state, "active") && - !streq_ptr(info.active_state, "reloading")) + !streq_ptr(info.active_state, "reloading") && + streq(verb, "status")) /* According to LSB: "program not running" */ r = 3; @@ -2326,12 +2750,12 @@ finish: return r; } -static int show(DBusConnection *bus, char **args, unsigned n) { +static int show(DBusConnection *bus, char **args) { DBusMessage *m = NULL, *reply = NULL; int r, ret = 0; DBusError error; - unsigned i; bool show_properties, new_line = false; + char **name; assert(bus); assert(args); @@ -2340,19 +2764,22 @@ static int show(DBusConnection *bus, char **args, unsigned n) { show_properties = !streq(args[0], "status"); - if (show_properties && n <= 1) { + if (show_properties) + pager_open_if_enabled(); + + if (show_properties && strv_length(args) <= 1) { /* If not argument is specified inspect the manager * itself */ - ret = show_one(bus, "/org/freedesktop/systemd1", show_properties, &new_line); + ret = show_one(args[0], bus, "/org/freedesktop/systemd1", show_properties, &new_line); goto finish; } - for (i = 1; i < n; i++) { + STRV_FOREACH(name, args+1) { const char *path = NULL; uint32_t id; - if (safe_atou32(args[i], &id) < 0) { + if (safe_atou32(*name, &id) < 0) { /* Interpret as unit name */ @@ -2367,7 +2794,7 @@ static int show(DBusConnection *bus, char **args, unsigned n) { } if (!dbus_message_append_args(m, - DBUS_TYPE_STRING, &args[i], + DBUS_TYPE_STRING, name, DBUS_TYPE_INVALID)) { log_error("Could not append arguments to message."); ret = -ENOMEM; @@ -2396,7 +2823,7 @@ static int show(DBusConnection *bus, char **args, unsigned n) { } if (!dbus_message_append_args(m, - DBUS_TYPE_STRING, &args[i], + DBUS_TYPE_STRING, name, DBUS_TYPE_INVALID)) { log_error("Could not append arguments to message."); ret = -ENOMEM; @@ -2478,7 +2905,7 @@ static int show(DBusConnection *bus, char **args, unsigned n) { goto finish; } - if ((r = show_one(bus, path, show_properties, &new_line)) != 0) + if ((r = show_one(args[0], bus, path, show_properties, &new_line)) != 0) ret = r; dbus_message_unref(m); @@ -2498,284 +2925,69 @@ finish: return ret; } -static DBusHandlerResult monitor_filter(DBusConnection *connection, DBusMessage *message, void *data) { - DBusError error; +static int dump(DBusConnection *bus, char **args) { DBusMessage *m = NULL, *reply = NULL; - - assert(connection); - assert(message); + DBusError error; + int r; + const char *text; 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)); + pager_open_if_enabled(); - if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) { - log_error("Warning! D-Bus connection terminated."); - dbus_connection_close(connection); + 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; + } - } 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 (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) { + log_error("Failed to issue method call: %s", bus_error_message(&error)); + r = -EIO; + goto finish; + } - if (!dbus_message_get_args(message, &error, - DBUS_TYPE_STRING, &id, - DBUS_TYPE_OBJECT_PATH, &path, - DBUS_TYPE_INVALID)) - log_error("Failed to parse message: %s", bus_error_message(&error)); - else if (streq(dbus_message_get_member(message), "UnitNew")) - printf("Unit %s added.\n", id); - else - printf("Unit %s removed.\n", id); + if (!dbus_message_get_args(reply, &error, + DBUS_TYPE_STRING, &text, + DBUS_TYPE_INVALID)) { + log_error("Failed to parse reply: %s", bus_error_message(&error)); + r = -EIO; + goto finish; + } - } 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; + fputs(text, stdout); - 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", bus_error_message(&error)); - else if (streq(dbus_message_get_member(message), "JobNew")) - printf("Job %u added.\n", id); - else - printf("Job %u removed.\n", id); + r = 0; +finish: + if (m) + dbus_message_unref(m); - } else if (dbus_message_is_signal(message, "org.freedesktop.DBus.Properties", "PropertiesChanged")) { + if (reply) + dbus_message_unref(reply); - const char *path, *interface, *property = "Id"; - DBusMessageIter iter, sub; + dbus_error_free(&error); - path = dbus_message_get_path(message); + return r; +} - if (!dbus_message_get_args(message, &error, - DBUS_TYPE_STRING, &interface, - DBUS_TYPE_INVALID)) { - log_error("Failed to parse message: %s", bus_error_message(&error)); - goto finish; - } +static int snapshot(DBusConnection *bus, char **args) { + 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"; - if (!streq(interface, "org.freedesktop.systemd1.Job") && - !streq(interface, "org.freedesktop.systemd1.Unit")) - goto finish; + dbus_error_init(&error); - 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", bus_error_message(&error)); - 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", bus_error_message(&error)); - r = -EIO; - goto finish; - } - - dbus_bus_add_match(bus, - "type='signal'," - "sender='org.freedesktop.systemd1'," - "interface='org.freedesktop.DBus.Properties'," - "member='PropertiesChanged'", - &error); - - if (dbus_error_is_set(&error)) { - log_error("Failed to add match: %s", bus_error_message(&error)); - 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", bus_error_message(&error)); - 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", bus_error_message(&error)); - 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", bus_error_message(&error)); - 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( + if (!(m = dbus_message_new_method_call( "org.freedesktop.systemd1", "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", @@ -2784,7 +2996,7 @@ static int snapshot(DBusConnection *bus, char **args, unsigned n) { return -ENOMEM; } - if (n > 1) + if (strv_length(args) > 1) name = args[1]; if (!dbus_message_append_args(m, @@ -2869,18 +3081,18 @@ finish: return r; } -static int delete_snapshot(DBusConnection *bus, char **args, unsigned n) { +static int delete_snapshot(DBusConnection *bus, char **args) { DBusMessage *m = NULL, *reply = NULL; int r; DBusError error; - unsigned i; + char **name; assert(bus); assert(args); dbus_error_init(&error); - for (i = 1; i < n; i++) { + STRV_FOREACH(name, args+1) { const char *path = NULL; if (!(m = dbus_message_new_method_call( @@ -2894,7 +3106,7 @@ static int delete_snapshot(DBusConnection *bus, char **args, unsigned n) { } if (!dbus_message_append_args(m, - DBUS_TYPE_STRING, &args[i], + DBUS_TYPE_STRING, name, DBUS_TYPE_INVALID)) { log_error("Could not append arguments to message."); r = -ENOMEM; @@ -2952,7 +3164,7 @@ finish: return r; } -static int daemon_reload(DBusConnection *bus, char **args, unsigned n) { +static int daemon_reload(DBusConnection *bus, char **args) { DBusMessage *m = NULL, *reply = NULL; DBusError error; int r; @@ -2968,12 +3180,16 @@ static int daemon_reload(DBusConnection *bus, char **args, unsigned n) { assert(arg_action == ACTION_SYSTEMCTL); method = - streq(args[0], "clear-jobs") || - streq(args[0], "cancel") ? "ClearJobs" : - streq(args[0], "daemon-reexec") ? "Reexecute" : - streq(args[0], "reset-failed") ? "ResetFailed" : - streq(args[0], "daemon-exit") ? "Exit" : - "Reload"; + streq(args[0], "clear-jobs") || + streq(args[0], "cancel") ? "ClearJobs" : + streq(args[0], "daemon-reexec") ? "Reexecute" : + streq(args[0], "reset-failed") ? "ResetFailed" : + streq(args[0], "halt") ? "Halt" : + streq(args[0], "poweroff") ? "PowerOff" : + streq(args[0], "reboot") ? "Reboot" : + streq(args[0], "kexec") ? "KExec" : + streq(args[0], "exit") ? "Exit" : + /* "daemon-reload" */ "Reload"; } if (!(m = dbus_message_new_method_call( @@ -2994,6 +3210,13 @@ static int daemon_reload(DBusConnection *bus, char **args, unsigned n) { goto finish; } + if (streq(method, "Reexecute") && dbus_error_has_name(&error, DBUS_ERROR_NO_REPLY)) { + /* On reexecution, we expect a disconnect, not + * a reply */ + r = 0; + goto finish; + } + log_error("Failed to issue method call: %s", bus_error_message(&error)); r = -EIO; goto finish; @@ -3013,19 +3236,20 @@ finish: return r; } -static int reset_failed(DBusConnection *bus, char **args, unsigned n) { - DBusMessage *m = NULL, *reply = NULL; - unsigned i; +static int reset_failed(DBusConnection *bus, char **args) { + DBusMessage *m = NULL; int r; DBusError error; + char **name; assert(bus); dbus_error_init(&error); - if (n <= 1) - return daemon_reload(bus, args, n); + if (strv_length(args) <= 1) + return daemon_reload(bus, args); - for (i = 1; i < n; i++) { + STRV_FOREACH(name, args+1) { + DBusMessage *reply; if (!(m = dbus_message_new_method_call( "org.freedesktop.systemd1", @@ -3038,7 +3262,7 @@ static int reset_failed(DBusConnection *bus, char **args, unsigned n) { } if (!dbus_message_append_args(m, - DBUS_TYPE_STRING, args + i, + DBUS_TYPE_STRING, name, DBUS_TYPE_INVALID)) { log_error("Could not append arguments to message."); r = -ENOMEM; @@ -3062,15 +3286,12 @@ 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) { +static int show_enviroment(DBusConnection *bus, char **args) { DBusMessage *m = NULL, *reply = NULL; DBusError error; DBusMessageIter iter, sub, sub2; @@ -3081,6 +3302,8 @@ static int show_enviroment(DBusConnection *bus, char **args, unsigned n) { dbus_error_init(&error); + pager_open_if_enabled(); + if (!(m = dbus_message_new_method_call( "org.freedesktop.systemd1", "/org/freedesktop/systemd1", @@ -3152,13 +3375,13 @@ finish: return r; } -static int set_environment(DBusConnection *bus, char **args, unsigned n) { +static int set_environment(DBusConnection *bus, char **args) { DBusMessage *m = NULL, *reply = NULL; DBusError error; int r; const char *method; DBusMessageIter iter, sub; - unsigned i; + char **name; dbus_error_init(&error); @@ -3184,8 +3407,8 @@ static int set_environment(DBusConnection *bus, char **args, unsigned n) { goto finish; } - for (i = 1; i < n; i++) - if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &args[i])) { + STRV_FOREACH(name, args+1) + if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, name)) { log_error("Could not append arguments to message."); r = -ENOMEM; goto finish; @@ -3217,711 +3440,515 @@ finish: return r; } -typedef struct { - char *name; - char *path; - - char **aliases; - char **wanted_by; -} InstallInfo; - -static Hashmap *will_install = NULL, *have_installed = NULL; -static Set *remove_symlinks_to = NULL; -static unsigned n_symlinks = 0; - -static void install_info_free(InstallInfo *i) { - assert(i); - - free(i->name); - free(i->path); - strv_free(i->aliases); - strv_free(i->wanted_by); - free(i); -} - -static void install_info_hashmap_free(Hashmap *m) { - InstallInfo *i; - - while ((i = hashmap_steal_first(m))) - install_info_free(i); - - hashmap_free(m); -} - -static int install_info_add(const char *name) { - InstallInfo *i; - int r; - - assert(will_install); - - if (!unit_name_is_valid_no_type(name, true)) { - log_warning("Unit name %s is not a valid unit name.", name); - return -EINVAL; - } - - if (hashmap_get(have_installed, name) || - hashmap_get(will_install, name)) - return 0; - - if (!(i = new0(InstallInfo, 1))) { - r = -ENOMEM; - goto fail; - } - - if (!(i->name = strdup(name))) { - r = -ENOMEM; - goto fail; - } - - if ((r = hashmap_put(will_install, i->name, i)) < 0) - goto fail; - - return 0; - -fail: - if (i) - install_info_free(i); - - return r; -} - -static int config_parse_also( - const char *filename, - unsigned line, - const char *section, - const char *lvalue, - const char *rvalue, - void *data, - void *userdata) { - - char *w; - size_t l; - char *state; - - assert(filename); - assert(lvalue); - assert(rvalue); - - FOREACH_WORD_QUOTED(w, l, rvalue, state) { - char *n; - int r; - - if (!(n = strndup(w, l))) - return -ENOMEM; - - if ((r = install_info_add(n)) < 0) { - log_warning("Cannot install unit %s: %s", n, strerror(-r)); - free(n); - return r; - } - - free(n); - } - - return 0; -} - -static int mark_symlink_for_removal(const char *p) { - char *n; - int r; - - assert(p); - assert(path_is_absolute(p)); - - if (!remove_symlinks_to) - return 0; - - if (!(n = strdup(p))) - return -ENOMEM; - - path_kill_slashes(n); - - if ((r = set_put(remove_symlinks_to, n)) < 0) { - free(n); - return r == -EEXIST ? 0 : r; - } - - return 0; -} - -static int remove_marked_symlinks_fd(int fd, const char *config_path, const char *root, bool *deleted) { +static int enable_sysv_units(char **args) { int r = 0; - DIR *d; - struct dirent *de; - - assert(fd >= 0); - assert(root); - assert(deleted); - - if (!(d = fdopendir(fd))) { - close_nointr_nofail(fd); - return -errno; - } - - rewinddir(d); - - while ((de = readdir(d))) { - bool is_dir = false, is_link = false; - - if (ignore_file(de->d_name)) - continue; - - if (de->d_type == DT_LNK) - is_link = true; - else if (de->d_type == DT_DIR) - is_dir = true; - else if (de->d_type == DT_UNKNOWN) { - struct stat st; - - if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) { - log_error("Failed to stat %s/%s: %m", root, de->d_name); - - if (r == 0) - r = -errno; - continue; - } - - is_link = S_ISLNK(st.st_mode); - is_dir = S_ISDIR(st.st_mode); - } else - continue; - - if (is_dir) { - int nfd, q; - char *p; - - if ((nfd = openat(fd, de->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW)) < 0) { - log_error("Failed to open %s/%s: %m", root, de->d_name); - - if (r == 0) - r = -errno; - continue; - } - - if (asprintf(&p, "%s/%s", root, de->d_name) < 0) { - log_error("Failed to allocate directory string."); - close_nointr_nofail(nfd); - r = -ENOMEM; - break; - } - - /* This will close nfd, regardless whether it succeeds or not */ - q = remove_marked_symlinks_fd(nfd, config_path, p, deleted); - free(p); - - if (r == 0) - r = q; - } else if (is_link) { - char *p, *dest, *c; - int q; - - if (asprintf(&p, "%s/%s", root, de->d_name) < 0) { - log_error("Failed to allocate symlink string."); - r = -ENOMEM; - break; - } - - if ((q = readlink_and_make_absolute(p, &dest)) < 0) { - log_error("Cannot read symlink %s: %s", p, strerror(-q)); - free(p); - - if (r == 0) - r = q; - continue; - } - - if ((c = canonicalize_file_name(dest))) { - /* This might fail if the destination - * is already removed */ - - free(dest); - dest = c; - } - - path_kill_slashes(dest); - if (set_get(remove_symlinks_to, dest)) { - - if (!arg_quiet) - log_info("rm '%s'", p); - - if (unlink(p) < 0) { - log_error("Cannot unlink symlink %s: %m", p); - - if (r == 0) - r = -errno; - } else { - rmdir_parents(p, config_path); - path_kill_slashes(p); - - if (!set_get(remove_symlinks_to, p)) { - - if ((r = mark_symlink_for_removal(p)) < 0) { - if (r == 0) - r = q; - } else - *deleted = true; - } - } - } - - free(p); - free(dest); - } - } - - closedir(d); - - return r; -} - -static int remove_marked_symlinks(const char *config_path) { - int fd, r = 0; - bool deleted; - - assert(config_path); +#if defined (HAVE_SYSV_COMPAT) && (defined(TARGET_FEDORA) || defined(TARGET_MANDRIVA) || defined(TARGET_SUSE) || defined(TARGET_MEEGO) || defined(TARGET_ALTLINUX)) + const char *verb = args[0]; + unsigned f = 1, t = 1; + LookupPaths paths; - if (set_size(remove_symlinks_to) <= 0) + if (arg_scope != UNIT_FILE_SYSTEM) return 0; - if ((fd = open(config_path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW)) < 0) - return -errno; - - do { - int q, cfd; - deleted = false; - - if ((cfd = dup(fd)) < 0) { - r = -errno; - break; - } - - /* This takes possession of cfd and closes it */ - if ((q = remove_marked_symlinks_fd(cfd, config_path, config_path, &deleted)) < 0) { - if (r == 0) - r = q; - } - } while (deleted); - - close_nointr_nofail(fd); - - return r; -} - -static int create_symlink(const char *verb, const char *old_path, const char *new_path) { - int r; - - assert(old_path); - assert(new_path); - assert(verb); - - if (streq(verb, "enable")) { - char *dest; - - mkdir_parents(new_path, 0755); - - if (symlink(old_path, new_path) >= 0) { - - if (!arg_quiet) - log_info("ln -s '%s' '%s'", old_path, new_path); - - return 0; - } - - if (errno != EEXIST) { - log_error("Cannot link %s to %s: %m", old_path, new_path); - return -errno; - } - - if ((r = readlink_and_make_absolute(new_path, &dest)) < 0) { - - if (errno == EINVAL) { - log_error("Cannot link %s to %s, file exists already and is not a symlink.", old_path, new_path); - return -EEXIST; - } - - log_error("readlink() failed: %s", strerror(-r)); - return r; - } - - if (streq(dest, old_path)) { - free(dest); - return 0; - } - - if (!arg_force) { - log_error("Cannot link %s to %s, symlink exists already and points to %s.", old_path, new_path, dest); - free(dest); - return -EEXIST; - } - - free(dest); - unlink(new_path); - - if (!arg_quiet) - log_info("ln -s '%s' '%s'", old_path, new_path); - - if (symlink(old_path, new_path) >= 0) - return 0; - - log_error("Cannot link %s to %s: %m", old_path, new_path); - return -errno; - - } else if (streq(verb, "disable")) { - char *dest; - - if ((r = mark_symlink_for_removal(old_path)) < 0) - return r; - - if ((r = readlink_and_make_absolute(new_path, &dest)) < 0) { - if (errno == ENOENT) - return 0; - - if (errno == EINVAL) { - log_warning("File %s not a symlink, ignoring.", old_path); - return 0; - } - - log_error("readlink() failed: %s", strerror(-r)); - return r; - } - - if (!streq(dest, old_path)) { - log_warning("File %s not a symlink to %s but points to %s, ignoring.", new_path, old_path, dest); - free(dest); - return 0; - } - - free(dest); - - if ((r = mark_symlink_for_removal(new_path)) < 0) - return r; + if (!streq(verb, "enable") && + !streq(verb, "disable") && + !streq(verb, "is-enabled")) + return 0; - if (!arg_quiet) - log_info("rm '%s'", new_path); + /* Processes all SysV units, and reshuffles the array so that + * afterwards only the native units remain */ - if (unlink(new_path) >= 0) - return 0; + zero(paths); + r = lookup_paths_init(&paths, MANAGER_SYSTEM, false); + if (r < 0) + return r; - log_error("Cannot unlink %s: %m", new_path); - return -errno; + r = 0; - } else if (streq(verb, "is-enabled")) { - char *dest; + for (f = 1; args[f]; f++) { + const char *name; + char *p; + bool found_native = false, found_sysv; + unsigned c = 1; + const char *argv[6] = { "/sbin/chkconfig", NULL, NULL, NULL, NULL }; + char **k, *l, *q = NULL; + int j; + pid_t pid; + siginfo_t status; - if ((r = readlink_and_make_absolute(new_path, &dest)) < 0) { + name = args[f]; - if (errno == ENOENT || errno == EINVAL) - return 0; + if (!endswith(name, ".service")) + continue; - log_error("readlink() failed: %s", strerror(-r)); - return r; - } + if (path_is_absolute(name)) + continue; - if (streq(dest, old_path)) { - free(dest); - return 1; - } + STRV_FOREACH(k, paths.unit_path) { + p = NULL; - return 0; - } + if (!isempty(arg_root)) + asprintf(&p, "%s/%s/%s", arg_root, *k, name); + else + asprintf(&p, "%s/%s", *k, name); - assert_not_reached("Unknown action."); -} + if (!p) { + log_error("No memory"); + r = -ENOMEM; + goto finish; + } -static int install_info_symlink_alias(const char *verb, InstallInfo *i, const char *config_path) { - char **s; - char *alias_path = NULL; - int r; + found_native = access(p, F_OK) >= 0; + free(p); - assert(verb); - assert(i); - assert(config_path); + if (found_native) + break; + } - STRV_FOREACH(s, i->aliases) { + if (found_native) + continue; - free(alias_path); - if (!(alias_path = path_make_absolute(*s, config_path))) { - log_error("Out of memory"); + p = NULL; + if (!isempty(arg_root)) + asprintf(&p, "%s/" SYSTEM_SYSVINIT_PATH "/%s", arg_root, name); + else + asprintf(&p, SYSTEM_SYSVINIT_PATH "/%s", name); + if (!p) { + log_error("No memory"); r = -ENOMEM; goto finish; } - if ((r = create_symlink(verb, i->path, alias_path)) != 0) - goto finish; + p[strlen(p) - sizeof(".service") + 1] = 0; + found_sysv = access(p, F_OK) >= 0; - if (streq(verb, "disable")) - rmdir_parents(alias_path, config_path); - } - r = 0; + if (!found_sysv) { + free(p); + continue; + } -finish: - free(alias_path); + /* Mark this entry, so that we don't try enabling it as native unit */ + args[f] = (char*) ""; - return r; -} + log_info("%s is not a native service, redirecting to /sbin/chkconfig.", name); -static int install_info_symlink_wants(const char *verb, InstallInfo *i, const char *config_path) { - char **s; - char *alias_path = NULL; - int r; + if (!isempty(arg_root)) + argv[c++] = q = strappend("--root=", arg_root); - assert(verb); - assert(i); - assert(config_path); + argv[c++] = file_name_from_path(p); + argv[c++] = + streq(verb, "enable") ? "on" : + streq(verb, "disable") ? "off" : "--level=5"; + argv[c] = NULL; - STRV_FOREACH(s, i->wanted_by) { - if (!unit_name_is_valid_no_type(*s, true)) { - log_error("Invalid name %s.", *s); - r = -EINVAL; + l = strv_join((char**)argv, " "); + if (!l) { + log_error("No memory."); + free(q); + free(p); + r = -ENOMEM; goto finish; } - free(alias_path); - alias_path = NULL; + log_info("Executing %s", l); + free(l); - if (asprintf(&alias_path, "%s/%s.wants/%s", config_path, *s, i->name) < 0) { - log_error("Out of memory"); - r = -ENOMEM; + pid = fork(); + if (pid < 0) { + log_error("Failed to fork: %m"); + free(p); + free(q); + r = -errno; goto finish; + } else if (pid == 0) { + /* Child */ + + execv(argv[0], (char**) argv); + _exit(EXIT_FAILURE); } - if ((r = create_symlink(verb, i->path, alias_path)) != 0) + free(p); + free(q); + + j = wait_for_terminate(pid, &status); + if (j < 0) { + log_error("Failed to wait for child: %s", strerror(-r)); + r = j; goto finish; + } - if (streq(verb, "disable")) - rmdir_parents(alias_path, config_path); - } + if (status.si_code == CLD_EXITED) { + if (streq(verb, "is-enabled")) { + if (status.si_status == 0) { + if (!arg_quiet) + puts("enabled"); + r = 1; + } else { + if (!arg_quiet) + puts("disabled"); + } - r = 0; + } else if (status.si_status != 0) { + r = -EINVAL; + goto finish; + } + } else { + r = -EPROTO; + goto finish; + } + } finish: - free(alias_path); + lookup_paths_free(&paths); + + /* Drop all SysV units */ + for (f = 1, t = 1; args[f]; f++) { + + if (isempty(args[f])) + continue; + + args[t++] = args[f]; + } + + args[t] = NULL; +#endif return r; } -static int install_info_apply(const char *verb, LookupPaths *paths, InstallInfo *i, const char *config_path) { +static int enable_unit(DBusConnection *bus, char **args) { + const char *verb = args[0]; + UnitFileChange *changes = NULL; + unsigned n_changes = 0, i; + int carries_install_info = -1; + DBusMessage *m = NULL, *reply = NULL; + int r; + DBusError error; - const ConfigItem items[] = { - { "Alias", config_parse_strv, &i->aliases, "Install" }, - { "WantedBy", config_parse_strv, &i->wanted_by, "Install" }, - { "Also", config_parse_also, NULL, "Install" }, + dbus_error_init(&error); - { NULL, NULL, NULL, NULL } - }; + r = enable_sysv_units(args); + if (r < 0) + return r; - char **p; - char *filename = NULL; - FILE *f = NULL; - int r; + if (!bus || avoid_bus()) { + if (streq(verb, "enable")) { + r = unit_file_enable(arg_scope, arg_runtime, arg_root, args+1, arg_force, &changes, &n_changes); + carries_install_info = r; + } else if (streq(verb, "disable")) + r = unit_file_disable(arg_scope, arg_runtime, arg_root, args+1, &changes, &n_changes); + else if (streq(verb, "reenable")) { + r = unit_file_reenable(arg_scope, arg_runtime, arg_root, args+1, arg_force, &changes, &n_changes); + carries_install_info = r; + } else if (streq(verb, "link")) + r = unit_file_link(arg_scope, arg_runtime, arg_root, args+1, arg_force, &changes, &n_changes); + else if (streq(verb, "preset")) { + r = unit_file_preset(arg_scope, arg_runtime, arg_root, args+1, arg_force, &changes, &n_changes); + carries_install_info = r; + } else if (streq(verb, "mask")) + r = unit_file_mask(arg_scope, arg_runtime, arg_root, args+1, arg_force, &changes, &n_changes); + else if (streq(verb, "unmask")) + r = unit_file_unmask(arg_scope, arg_runtime, arg_root, args+1, &changes, &n_changes); + else + assert_not_reached("Unknown verb"); - assert(paths); - assert(i); + if (r < 0) { + log_error("Operation failed: %s", strerror(-r)); + goto finish; + } - STRV_FOREACH(p, paths->unit_path) { - int fd; + for (i = 0; i < n_changes; i++) { + if (changes[i].type == UNIT_FILE_SYMLINK) + log_info("ln -s '%s' '%s'", changes[i].source, changes[i].path); + else + log_info("rm '%s'", changes[i].path); + } - if (!(filename = path_make_absolute(i->name, *p))) { + } else { + const char *method; + bool send_force = true, expect_carries_install_info = false; + dbus_bool_t a, b; + DBusMessageIter iter, sub, sub2; + + if (streq(verb, "enable")) { + method = "EnableUnitFiles"; + expect_carries_install_info = true; + } else if (streq(verb, "disable")) { + method = "DisableUnitFiles"; + send_force = false; + } else if (streq(verb, "reenable")) { + method = "ReenableUnitFiles"; + expect_carries_install_info = true; + } else if (streq(verb, "link")) + method = "LinkUnitFiles"; + else if (streq(verb, "preset")) { + method = "PresetUnitFiles"; + expect_carries_install_info = true; + } else if (streq(verb, "mask")) + method = "MaskUnitFiles"; + else if (streq(verb, "unmask")) { + method = "UnmaskUnitFiles"; + send_force = false; + } else + assert_not_reached("Unknown verb"); + + m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + method); + if (!m) { log_error("Out of memory"); - return -ENOMEM; + r = -ENOMEM; + goto finish; } - /* Ensure that we don't follow symlinks */ - if ((fd = open(filename, O_RDONLY|O_CLOEXEC|O_NOFOLLOW|O_NOCTTY)) >= 0) - if ((f = fdopen(fd, "re"))) - break; + dbus_message_iter_init_append(m, &iter); - if (errno == ELOOP) { - log_error("Refusing to operate on symlinks, please pass unit names or absolute paths to unit files."); - free(filename); - return -errno; + r = bus_append_strv_iter(&iter, args+1); + if (r < 0) { + log_error("Failed to append unit files."); + goto finish; } - if (errno != ENOENT) { - log_error("Failed to open %s: %m", filename); - free(filename); - return -errno; + a = arg_runtime; + if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &a)) { + log_error("Failed to append runtime boolean."); + r = -ENOMEM; + goto finish; } - free(filename); - filename = NULL; - } + if (send_force) { + b = arg_force; - if (!f) { - log_error("Couldn't find %s.", i->name); - return -ENOENT; - } + if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &b)) { + log_error("Failed to append force boolean."); + r = -ENOMEM; + goto finish; + } + } - i->path = filename; + reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error); + if (!reply) { + log_error("Failed to issue method call: %s", bus_error_message(&error)); + r = -EIO; + goto finish; + } - if ((r = config_parse(filename, f, NULL, items, true, i)) < 0) { - fclose(f); - return r; - } + if (!dbus_message_iter_init(reply, &iter)) { + log_error("Failed to initialize iterator."); + goto finish; + } - n_symlinks += strv_length(i->aliases); - n_symlinks += strv_length(i->wanted_by); + if (expect_carries_install_info) { + r = bus_iter_get_basic_and_next(&iter, DBUS_TYPE_BOOLEAN, &b, true); + if (r < 0) { + log_error("Failed to parse reply."); + goto finish; + } - fclose(f); + carries_install_info = b; + } - if ((r = install_info_symlink_alias(verb, i, config_path)) != 0) - return r; + if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY || + dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } - if ((r = install_info_symlink_wants(verb, i, config_path)) != 0) - return r; + dbus_message_iter_recurse(&iter, &sub); + while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { + const char *type, *path, *source; - if ((r = mark_symlink_for_removal(filename)) < 0) - return r; + if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } - if ((r = remove_marked_symlinks(config_path)) < 0) - return r; + dbus_message_iter_recurse(&sub, &sub2); - return 0; -} + 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, true) < 0 || + bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &source, false) < 0) { + log_error("Failed to parse reply."); + r = -EIO; + goto finish; + } -static char *get_config_path(void) { + if (streq(type, "symlink")) + log_info("ln -s '%s' '%s'", source, path); + else + log_info("rm '%s'", path); - if (arg_session && arg_global) - return strdup(SESSION_CONFIG_UNIT_PATH); + dbus_message_iter_next(&sub); + } - if (arg_session) { - char *p; + /* Try to reload if enabeld */ + if (!arg_no_reload) + r = daemon_reload(bus, args); + } - if (session_config_home(&p) < 0) - return NULL; + if (carries_install_info == 0) + log_warning("Warning: unit files do not carry install information. No operation executed."); - return p; - } +finish: + if (m) + dbus_message_unref(m); + + if (reply) + dbus_message_unref(reply); - return strdup(SYSTEM_CONFIG_UNIT_PATH); + unit_file_changes_free(changes, n_changes); + + dbus_error_free(&error); + return r; } -static int enable_unit(DBusConnection *bus, char **args, unsigned n) { +static int unit_is_enabled(DBusConnection *bus, char **args) { DBusError error; int r; - LookupPaths paths; - char *config_path = NULL; - unsigned j; - InstallInfo *i; - const char *verb = args[0]; + DBusMessage *m = NULL, *reply = NULL; + bool enabled; + char **name; dbus_error_init(&error); - zero(paths); - if ((r = lookup_paths_init(&paths, arg_session ? MANAGER_SESSION : MANAGER_SYSTEM)) < 0) { - log_error("Failed to determine lookup paths: %s", strerror(-r)); - goto finish; - } + r = enable_sysv_units(args); + if (r < 0) + return r; - if (!(config_path = get_config_path())) { - log_error("Failed to determine config path"); - r = -ENOMEM; - goto finish; - } + enabled = r > 0; - will_install = hashmap_new(string_hash_func, string_compare_func); - have_installed = hashmap_new(string_hash_func, string_compare_func); + if (!bus || avoid_bus()) { - if (!will_install || !have_installed) { - log_error("Failed to allocate unit sets."); - r = -ENOMEM; - goto finish; - } + STRV_FOREACH(name, args+1) { + UnitFileState state; - if (!arg_defaults && streq(verb, "disable")) - if (!(remove_symlinks_to = set_new(string_hash_func, string_compare_func))) { - log_error("Failed to allocate symlink sets."); - r = -ENOMEM; - goto finish; - } + state = unit_file_get_state(arg_scope, arg_root, *name); + if (state < 0) { + r = state; + goto finish; + } - for (j = 1; j < n; j++) - if ((r = install_info_add(args[j])) < 0) { - log_warning("Cannot install unit %s: %s", args[j], strerror(-r)); - goto finish; + if (state == UNIT_FILE_ENABLED || + state == UNIT_FILE_ENABLED_RUNTIME || + state == UNIT_FILE_STATIC) + enabled = true; + + if (!arg_quiet) + puts(unit_file_state_to_string(state)); } - while ((i = hashmap_first(will_install))) { - int q; + } else { + STRV_FOREACH(name, args+1) { + const char *s; + + m = dbus_message_new_method_call( + "org.freedesktop.systemd1", + "/org/freedesktop/systemd1", + "org.freedesktop.systemd1.Manager", + "GetUnitFileState"); + if (!m) { + log_error("Out of memory"); + r = -ENOMEM; + goto finish; + } - assert_se(hashmap_move_one(have_installed, will_install, i->name) == 0); + if (!dbus_message_append_args(m, + DBUS_TYPE_STRING, name, + DBUS_TYPE_INVALID)) { + log_error("Could not append arguments to message."); + r = -ENOMEM; + goto finish; + } - if ((q = install_info_apply(verb, &paths, i, config_path)) != 0) { + reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error); + if (!reply) { + log_error("Failed to issue method call: %s", bus_error_message(&error)); + r = -EIO; + goto finish; + } - if (q < 0) { - if (r == 0) - r = q; + if (!dbus_message_get_args(reply, &error, + DBUS_TYPE_STRING, &s, + DBUS_TYPE_INVALID)) { + log_error("Failed to parse reply: %s", bus_error_message(&error)); + r = -EIO; goto finish; } - /* In test mode and found something */ - r = 1; - break; - } - } + dbus_message_unref(m); + dbus_message_unref(reply); + m = reply = NULL; - if (streq(verb, "is-enabled")) - r = r > 0 ? 0 : -ENOENT; - else { - if (n_symlinks <= 0) - log_warning("Unit files contain no applicable installation information. Ignoring."); - - if (bus && - /* Don't try to reload anything if the user asked us to not do this */ - !arg_no_reload && - /* Don't try to reload anything when updating a unit globally */ - !arg_global && - /* Don't try to reload anything if we are called for system changes but the system wasn't booted with systemd */ - (arg_session || sd_booted() > 0) && - /* Don't try to reload anything if we are running in a chroot environment */ - (arg_session || running_in_chroot() <= 0) ) { - int q; - - if ((q = daemon_reload(bus, args, n)) < 0) - r = q; + if (streq(s, "enabled") || + streq(s, "enabled-runtime") || + streq(s, "static")) + enabled = true; + + if (!arg_quiet) + puts(s); } } -finish: - install_info_hashmap_free(will_install); - install_info_hashmap_free(have_installed); - - set_free_free(remove_symlinks_to); + r = enabled ? 0 : 1; - lookup_paths_free(&paths); +finish: + if (m) + dbus_message_unref(m); - free(config_path); + if (reply) + dbus_message_unref(reply); + dbus_error_free(&error); return r; } static int systemctl_help(void) { + pager_open_if_enabled(); + printf("%s [OPTIONS...] {COMMAND} ...\n\n" - "Send control commands to or query the systemd manager.\n\n" - " -h --help Show this help\n" - " --version Show package version\n" - " -t --type=TYPE List only units of a particular type\n" - " -p --property=NAME Show only properties by this name\n" - " -a --all Show all units/properties, including dead/empty ones\n" - " --full Don't ellipsize unit names on output\n" - " --fail When queueing a new job, fail if conflicting jobs are\n" - " pending\n" - " -q --quiet Suppress output\n" - " --no-block Do not wait until operation finished\n" - " --system Connect to system bus\n" - " --session Connect to session bus\n" - " --order When generating graph for dot, show only order\n" - " --require When generating graph for dot, show only requirement\n" - " --no-wall Don't send wall message before halt/power-off/reboot\n" - " --global Enable/disable unit files globally\n" - " --no-reload When enabling/disabling unit files, don't reload daemon\n" - " configuration\n" - " --force When enabling unit files, override existing symlinks\n" - " --defaults When disabling unit files, remove default symlinks only\n\n" - "Commands:\n" - " list-units List units\n" + "Query or send control commands to the systemd manager.\n\n" + " -h --help Show this help\n" + " --version Show package version\n" + " -t --type=TYPE List only units of a particular type\n" + " -p --property=NAME Show only properties by this name\n" + " -a --all Show all units/properties, including dead/empty ones\n" + " --failed Show only failed units\n" + " --full Don't ellipsize unit names on output\n" + " --fail When queueing a new job, fail if conflicting jobs are\n" + " pending\n" + " --ignore-dependencies\n" + " When queueing a new job, ignore all its dependencies\n" + " --kill-who=WHO Who to send signal to\n" + " -s --signal=SIGNAL Which signal to send\n" + " -H --host=[USER@]HOST\n" + " Show information for remote host\n" + " -P --privileged Acquire privileges before execution\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" + " --no-reload When enabling/disabling unit files, don't reload daemon\n" + " configuration\n" + " --no-legend Do not print a legend (column headers and hints)\n" + " --no-pager Do not pipe output into a pager\n" + " --no-ask-password\n" + " Do not ask for system passwords\n" + " --order When generating graph for dot, show only order\n" + " --require When generating graph for dot, show only requirement\n" + " --system Connect to system manager\n" + " --user Connect to user service manager\n" + " --global Enable/disable unit files globally\n" + " -f --force When enabling unit files, override existing symlinks\n" + " When shutting down, execute action immediately\n" + " --root=PATH Enable unit files in the specified root directory\n" + " --runtime Enable unit files only temporarily until next reboot\n\n" + "Unit Commands:\n" + " list-units List loaded units\n" " start [NAME...] Start (activate) one or more units\n" " stop [NAME...] Stop (deactivate) one or more units\n" " reload [NAME...] Reload one or more units\n" @@ -3932,35 +3959,51 @@ static int systemctl_help(void) { " reload-or-try-restart [NAME...] Reload one or more units is possible,\n" " otherwise restart if active\n" " isolate [NAME] Start one unit and stop all others\n" + " kill [NAME...] Send signal to processes of a unit\n" " is-active [NAME...] Check whether units are active\n" " status [NAME...|PID...] Show runtime status of one or more units\n" " show [NAME...|JOB...] Show properties of one or more\n" " units/jobs or the manager\n" " reset-failed [NAME...] Reset failed state for all, one, or more\n" " units\n" + " load [NAME...] Load one or more units\n\n" + "Unit File Commands:\n" + " list-unit-files List installed unit files\n" " enable [NAME...] Enable one or more unit files\n" " disable [NAME...] Disable one or more unit files\n" - " is-enabled [NAME...] Check whether unit files are enabled\n" - " load [NAME...] Load one or more units\n" + " reenable [NAME...] Reenable one or more unit files\n" + " preset [NAME...] Enable/disable one or more unit files\n" + " based on preset configuration\n" + " mask [NAME...] Mask one or more units\n" + " unmask [NAME...] Unmask one or more units\n" + " link [PATH...] Link one or more units files into\n" + " the search path\n" + " is-enabled [NAME...] Check whether unit files are enabled\n\n" + "Job Commands:\n" " list-jobs List jobs\n" - " cancel [JOB...] Cancel all, one, or more jobs\n" - " monitor Monitor unit/job changes\n" + " cancel [JOB...] Cancel all, one, or more jobs\n\n" + "Status Commands:\n" " dump Dump server status\n" - " dot Dump dependency graph for dot(1)\n" + " dot Dump dependency graph for dot(1)\n\n" + "Snapshot Commands:\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" + " delete [NAME...] Remove one or more snapshots\n\n" + "Environment Commands:\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\n" + "Manager Lifecycle Commands:\n" + " daemon-reload Reload systemd manager configuration\n" + " daemon-reexec Reexecute systemd manager\n\n" + "System Commands:\n" + " default Enter system default mode\n" + " rescue Enter system rescue mode\n" + " emergency Enter system emergency mode\n" " halt Shut down and halt the system\n" " poweroff Shut down and power-off the system\n" " reboot Shut down and reboot the system\n" - " rescue Enter system rescue mode\n" - " emergency Enter system emergency mode\n" - " default Enter system default mode\n", + " kexec Shut down and reboot the system with kexec\n" + " exit Ask for user instance termination\n", program_invocation_short_name); return 0; @@ -4036,18 +4079,25 @@ static int systemctl_parse_argv(int argc, char *argv[]) { enum { ARG_FAIL = 0x100, + ARG_IGNORE_DEPENDENCIES, ARG_VERSION, - ARG_SESSION, + ARG_USER, ARG_SYSTEM, ARG_GLOBAL, ARG_NO_BLOCK, + ARG_NO_LEGEND, + ARG_NO_PAGER, ARG_NO_WALL, ARG_ORDER, ARG_REQUIRE, + ARG_ROOT, ARG_FULL, - ARG_FORCE, ARG_NO_RELOAD, - ARG_DEFAULTS + ARG_KILL_MODE, + ARG_KILL_WHO, + ARG_NO_ASK_PASSWORD, + ARG_FAILED, + ARG_RUNTIME }; static const struct option options[] = { @@ -4056,19 +4106,30 @@ static int systemctl_parse_argv(int argc, char *argv[]) { { "type", required_argument, NULL, 't' }, { "property", required_argument, NULL, 'p' }, { "all", no_argument, NULL, 'a' }, + { "failed", no_argument, NULL, ARG_FAILED }, { "full", no_argument, NULL, ARG_FULL }, { "fail", no_argument, NULL, ARG_FAIL }, - { "session", no_argument, NULL, ARG_SESSION }, + { "ignore-dependencies", no_argument, NULL, ARG_IGNORE_DEPENDENCIES }, + { "user", no_argument, NULL, ARG_USER }, { "system", no_argument, NULL, ARG_SYSTEM }, { "global", no_argument, NULL, ARG_GLOBAL }, { "no-block", no_argument, NULL, ARG_NO_BLOCK }, + { "no-legend", no_argument, NULL, ARG_NO_LEGEND }, + { "no-pager", no_argument, NULL, ARG_NO_PAGER }, { "no-wall", no_argument, NULL, ARG_NO_WALL }, { "quiet", no_argument, NULL, 'q' }, { "order", no_argument, NULL, ARG_ORDER }, { "require", no_argument, NULL, ARG_REQUIRE }, - { "force", no_argument, NULL, ARG_FORCE }, + { "root", required_argument, NULL, ARG_ROOT }, + { "force", no_argument, NULL, 'f' }, { "no-reload", no_argument, NULL, ARG_NO_RELOAD }, - { "defaults", no_argument, NULL, ARG_DEFAULTS }, + { "kill-mode", required_argument, NULL, ARG_KILL_MODE }, /* undocumented on purpose */ + { "kill-who", required_argument, NULL, ARG_KILL_WHO }, + { "signal", required_argument, NULL, 's' }, + { "no-ask-password", no_argument, NULL, ARG_NO_ASK_PASSWORD }, + { "host", required_argument, NULL, 'H' }, + { "privileged",no_argument, NULL, 'P' }, + { "runtime", no_argument, NULL, ARG_RUNTIME }, { NULL, 0, NULL, 0 } }; @@ -4077,7 +4138,10 @@ static int systemctl_parse_argv(int argc, char *argv[]) { assert(argc >= 0); assert(argv); - while ((c = getopt_long(argc, argv, "ht:p:aq", options, NULL)) >= 0) { + /* Only when running as systemctl we ask for passwords */ + arg_ask_password = true; + + while ((c = getopt_long(argc, argv, "ht:p:aqfs:H:P", options, NULL)) >= 0) { switch (c) { @@ -4116,21 +4180,37 @@ static int systemctl_parse_argv(int argc, char *argv[]) { break; case ARG_FAIL: - arg_fail = true; + arg_job_mode = "fail"; + break; + + case ARG_IGNORE_DEPENDENCIES: + arg_job_mode = "ignore-dependencies"; break; - case ARG_SESSION: - arg_session = true; + case ARG_USER: + arg_scope = UNIT_FILE_USER; break; case ARG_SYSTEM: - arg_session = false; + arg_scope = UNIT_FILE_SYSTEM; + break; + + case ARG_GLOBAL: + arg_scope = UNIT_FILE_GLOBAL; break; case ARG_NO_BLOCK: arg_no_block = true; break; + case ARG_NO_LEGEND: + arg_no_legend = true; + break; + + case ARG_NO_PAGER: + arg_no_pager = true; + break; + case ARG_NO_WALL: arg_no_wall = true; break; @@ -4143,15 +4223,23 @@ static int systemctl_parse_argv(int argc, char *argv[]) { arg_dot = DOT_REQUIRE; break; + case ARG_ROOT: + arg_root = optarg; + break; + case ARG_FULL: arg_full = true; break; + case ARG_FAILED: + arg_failed = true; + break; + case 'q': arg_quiet = true; break; - case ARG_FORCE: + case 'f': arg_force = true; break; @@ -4159,13 +4247,36 @@ static int systemctl_parse_argv(int argc, char *argv[]) { arg_no_reload = true; break; - case ARG_GLOBAL: - arg_global = true; - arg_session = true; + case ARG_KILL_WHO: + arg_kill_who = optarg; + break; + + case ARG_KILL_MODE: + arg_kill_mode = optarg; + break; + + case 's': + if ((arg_signal = signal_from_string_try_harder(optarg)) < 0) { + log_error("Failed to parse signal string %s.", optarg); + return -EINVAL; + } + break; + + case ARG_NO_ASK_PASSWORD: + arg_ask_password = false; + break; + + case 'P': + arg_transport = TRANSPORT_POLKIT; break; - case ARG_DEFAULTS: - arg_defaults = true; + case 'H': + arg_transport = TRANSPORT_SSH; + arg_host = optarg; + break; + + case ARG_RUNTIME: + arg_runtime = true; break; case '?': @@ -4177,6 +4288,11 @@ static int systemctl_parse_argv(int argc, char *argv[]) { } } + if (arg_transport != TRANSPORT_NORMAL && arg_scope != UNIT_FILE_SYSTEM) { + log_error("Cannot access user instance remotely."); + return -EINVAL; + } + return 1; } @@ -4279,10 +4395,10 @@ static int parse_time_spec(const char *t, usec_t *_u) { if (streq(t, "now")) *_u = 0; - else if (t[0] == '+') { + else if (!strchr(t, ':')) { uint64_t u; - if (safe_atou64(t + 1, &u) < 0) + if (safe_atou64(t, &u) < 0) return -EINVAL; *_u = now(CLOCK_REALTIME) + USEC_PER_MINUTE * u; @@ -4360,7 +4476,10 @@ static int shutdown_parse_argv(int argc, char *argv[]) { break; case 'r': - arg_action = ACTION_REBOOT; + if (kexec_loaded()) + arg_action = ACTION_KEXEC; + else + arg_action = ACTION_REBOOT; break; case 'h': @@ -4553,7 +4672,10 @@ static int parse_argv(int argc, char *argv[]) { arg_action = ACTION_POWEROFF; return halt_parse_argv(argc, argv); } else if (strstr(program_invocation_short_name, "reboot")) { - arg_action = ACTION_REBOOT; + if (kexec_loaded()) + arg_action = ACTION_KEXEC; + else + arg_action = ACTION_REBOOT; return halt_parse_argv(argc, argv); } else if (strstr(program_invocation_short_name, "shutdown")) { arg_action = ACTION_POWEROFF; @@ -4679,7 +4801,7 @@ static int talk_upstart(void) { goto finish; } - r = 0; + r = 1; finish: if (m) @@ -4744,48 +4866,57 @@ static int systemctl_main(DBusConnection *bus, int argc, char *argv[], DBusError EQUAL } argc_cmp; const int argc; - int (* const dispatch)(DBusConnection *bus, char **args, unsigned n); + int (* const dispatch)(DBusConnection *bus, char **args); } verbs[] = { { "list-units", LESS, 1, list_units }, + { "list-unit-files", EQUAL, 1, list_unit_files }, { "list-jobs", EQUAL, 1, list_jobs }, { "clear-jobs", EQUAL, 1, daemon_reload }, { "load", MORE, 2, load_unit }, { "cancel", MORE, 2, cancel_job }, { "start", MORE, 2, start_unit }, { "stop", MORE, 2, start_unit }, + { "condstop", MORE, 2, start_unit }, /* For compatibility with ALTLinux */ { "reload", MORE, 2, start_unit }, { "restart", MORE, 2, start_unit }, { "try-restart", MORE, 2, start_unit }, { "reload-or-restart", MORE, 2, start_unit }, { "reload-or-try-restart", MORE, 2, start_unit }, { "force-reload", MORE, 2, start_unit }, /* For compatibility with SysV */ + { "condreload", MORE, 2, start_unit }, /* For compatibility with ALTLinux */ { "condrestart", MORE, 2, start_unit }, /* For compatibility with RH */ { "isolate", EQUAL, 2, start_unit }, + { "kill", MORE, 2, kill_unit }, { "is-active", MORE, 2, check_unit }, { "check", MORE, 2, check_unit }, { "show", MORE, 1, show }, { "status", MORE, 2, show }, - { "monitor", EQUAL, 1, monitor }, { "dump", EQUAL, 1, dump }, { "dot", EQUAL, 1, dot }, { "snapshot", LESS, 2, snapshot }, { "delete", MORE, 2, delete_snapshot }, { "daemon-reload", EQUAL, 1, daemon_reload }, { "daemon-reexec", EQUAL, 1, daemon_reload }, - { "daemon-exit", EQUAL, 1, daemon_reload }, { "show-environment", EQUAL, 1, show_enviroment }, { "set-environment", MORE, 2, set_environment }, { "unset-environment", MORE, 2, set_environment }, { "halt", EQUAL, 1, start_special }, { "poweroff", EQUAL, 1, start_special }, { "reboot", EQUAL, 1, start_special }, + { "kexec", EQUAL, 1, start_special }, { "default", EQUAL, 1, start_special }, { "rescue", EQUAL, 1, start_special }, { "emergency", EQUAL, 1, start_special }, + { "exit", EQUAL, 1, start_special }, { "reset-failed", MORE, 1, reset_failed }, { "enable", MORE, 2, enable_unit }, { "disable", MORE, 2, enable_unit }, - { "is-enabled", MORE, 2, enable_unit } + { "is-enabled", MORE, 2, unit_is_enabled }, + { "reenable", MORE, 2, enable_unit }, + { "preset", MORE, 2, enable_unit }, + { "mask", MORE, 2, enable_unit }, + { "unmask", MORE, 2, enable_unit }, + { "link", MORE, 2, enable_unit } }; int left; @@ -4850,15 +4981,37 @@ static int systemctl_main(DBusConnection *bus, int argc, char *argv[], DBusError * enable/disable */ if (!streq(verbs[i].verb, "enable") && !streq(verbs[i].verb, "disable") && - !bus) { - log_error("Failed to get D-Bus connection: %s", error->message); - return -EIO; + !streq(verbs[i].verb, "is-enable") && + !streq(verbs[i].verb, "reenable") && + !streq(verbs[i].verb, "preset") && + !streq(verbs[i].verb, "mask") && + !streq(verbs[i].verb, "unmask") && + !streq(verbs[i].verb, "link")) { + + if (running_in_chroot() > 0) { + log_info("Running in chroot, ignoring request."); + return 0; + } + + if (!bus) { + log_error("Failed to get D-Bus connection: %s", + dbus_error_is_set(error) ? error->message : "No connection to service manager."); + return -EIO; + } + + } else { + + if (!bus && !avoid_bus()) { + log_error("Failed to get D-Bus connection: %s", + dbus_error_is_set(error) ? error->message : "No connection to service manager."); + return -EIO; + } } - return verbs[i].dispatch(bus, argv + optind, left); + return verbs[i].dispatch(bus, argv + optind); } -static int send_shutdownd(usec_t t, char mode, bool warn, const char *message) { +static int send_shutdownd(usec_t t, char mode, bool dry_run, bool warn, const char *message) { int fd = -1; struct msghdr msghdr; struct iovec iovec; @@ -4868,6 +5021,7 @@ static int send_shutdownd(usec_t t, char mode, bool warn, const char *message) { zero(c); c.elapse = t; c.mode = mode; + c.dry_run = dry_run; c.warn_wall = warn; if (message) @@ -4879,7 +5033,7 @@ static int send_shutdownd(usec_t t, char mode, bool warn, const char *message) { zero(sockaddr); sockaddr.sa.sa_family = AF_UNIX; sockaddr.un.sun_path[0] = 0; - strncpy(sockaddr.un.sun_path+1, "/org/freedesktop/systemd1/shutdownd", sizeof(sockaddr.un.sun_path)-1); + strncpy(sockaddr.un.sun_path, "/run/systemd/shutdownd", sizeof(sockaddr.un.sun_path)); zero(iovec); iovec.iov_base = (char*) &c; @@ -4887,7 +5041,7 @@ static int send_shutdownd(usec_t t, char mode, bool warn, const char *message) { zero(msghdr); msghdr.msg_name = &sockaddr; - msghdr.msg_namelen = offsetof(struct sockaddr_un, sun_path) + 1 + sizeof("/org/freedesktop/systemd1/shutdownd") - 1; + msghdr.msg_namelen = offsetof(struct sockaddr_un, sun_path) + sizeof("/run/systemd/shutdownd") - 1; msghdr.msg_iov = &iovec; msghdr.msg_iovlen = 1; @@ -4905,7 +5059,7 @@ static int reload_with_fallback(DBusConnection *bus) { if (bus) { /* First, try systemd via D-Bus. */ - if (daemon_reload(bus, NULL, 0) > 0) + if (daemon_reload(bus, NULL) >= 0) return 0; } @@ -4924,7 +5078,7 @@ static int start_with_fallback(DBusConnection *bus) { if (bus) { /* First, try systemd via D-Bus. */ - if (start_unit(bus, NULL, 0) >= 0) + if (start_unit(bus, NULL) >= 0) goto done; } @@ -4963,6 +5117,7 @@ static int halt_main(DBusConnection *bus) { arg_action == ACTION_HALT ? 'H' : arg_action == ACTION_POWEROFF ? 'P' : 'r', + arg_dry, !arg_no_wall, m); free(m); @@ -5024,8 +5179,9 @@ static int halt_main(DBusConnection *bus) { static int runlevel_main(void) { int r, runlevel, previous; - if ((r = utmp_get_runlevel(&runlevel, &previous)) < 0) { - printf("unknown\n"); + r = utmp_get_runlevel(&runlevel, &previous); + if (r < 0) { + puts("unknown"); return r; } @@ -5061,7 +5217,24 @@ int main(int argc, char*argv[]) { goto finish; } - bus_connect(arg_session ? DBUS_BUS_SESSION : DBUS_BUS_SYSTEM, &bus, &private_bus, &error); + if (running_in_chroot() > 0 && arg_action != ACTION_SYSTEMCTL) { + log_info("Running in chroot, ignoring request."); + retval = 0; + goto finish; + } + + if (!avoid_bus()) { + if (arg_transport == TRANSPORT_NORMAL) + bus_connect(arg_scope == UNIT_FILE_SYSTEM ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, &bus, &private_bus, &error); + else if (arg_transport == TRANSPORT_POLKIT) { + bus_connect_system_polkit(&bus, &error); + private_bus = false; + } else if (arg_transport == TRANSPORT_SSH) { + bus_connect_system_ssh(NULL, arg_host, &bus, &error); + private_bus = false; + } else + assert_not_reached("Uh, invalid transport..."); + } switch (arg_action) { @@ -5072,6 +5245,7 @@ int main(int argc, char*argv[]) { case ACTION_HALT: case ACTION_POWEROFF: case ACTION_REBOOT: + case ACTION_KEXEC: r = halt_main(bus); break; @@ -5091,7 +5265,7 @@ int main(int argc, char*argv[]) { break; case ACTION_CANCEL_SHUTDOWN: - r = send_shutdownd(0, 0, false, NULL); + r = send_shutdownd(0, 0, false, false, NULL); break; case ACTION_INVALID: @@ -5103,7 +5277,6 @@ int main(int argc, char*argv[]) { retval = r < 0 ? EXIT_FAILURE : r; finish: - if (bus) { dbus_connection_flush(bus); dbus_connection_close(bus); @@ -5116,5 +5289,8 @@ finish: strv_free(arg_property); + pager_close(); + agent_close(); + return retval; }