1689N/A

1689N/A

1689N/A#include <sys/reboot.h>

1689N/A#include <linux/reboot.h>

5080N/A#include <sys/syscall.h>

1689N/A#include <stdio.h>

1689N/A#include <getopt.h>

2086N/A#include <locale.h>

1689N/A#include <stdbool.h>

1689N/A#include <string.h>

1689N/A#include <errno.h>

1689N/A#include <sys/ioctl.h>

1689N/A#include <termios.h>

1689N/A#include <unistd.h>

1689N/A#include <fcntl.h>

1689N/A#include <sys/socket.h>

1689N/A#include <sys/stat.h>

1689N/A#include <stddef.h>

1689N/A#include <sys/prctl.h>

1689N/A

2086N/A#include "sd-daemon.h"

1689N/A#include "sd-shutdown.h"

1689N/A#include "sd-login.h"

1689N/A#include "sd-bus.h"

1689N/A#include "log.h"

1689N/A#include "util.h"

1689N/A#include "macro.h"

1689N/A#include "set.h"

1689N/A#include "utmp-wtmp.h"

1689N/A#include "special.h"

3352N/A#include "initreq.h"

3853N/A#include "path-util.h"

1689N/A#include "strv.h"

1689N/A#include "cgroup-show.h"

1689N/A#include "cgroup-util.h"

3352N/A#include "list.h"

1689N/A#include "path-lookup.h"

1689N/A#include "conf-parser.h"

1689N/A#include "exit-status.h"

3853N/A#include "bus-errors.h"

1689N/A#include "build.h"

1689N/A#include "unit-name.h"

1689N/A#include "pager.h"

1689N/A#include "spawn-ask-password-agent.h"

1689N/A#include "spawn-polkit-agent.h"

1689N/A#include "install.h"

1689N/A#include "logs-show.h"

1689N/A#include "path-util.h"

1689N/A#include "socket-util.h"

1689N/A#include "fileio.h"

1689N/A#include "bus-util.h"

1689N/A#include "bus-message.h"

1689N/A#include "bus-error.h"

1689N/A

1689N/Astatic char **arg_types = NULL;

1689N/Astatic char **arg_states = NULL;

1689N/Astatic char **arg_properties = NULL;

1689N/Astatic bool arg_all = false;

1689N/Astatic bool original_stdout_is_tty;

1689N/Astatic enum dependency {

1689N/A DEPENDENCY_FORWARD,

1689N/A DEPENDENCY_REVERSE,

1689N/A DEPENDENCY_AFTER,

1689N/A DEPENDENCY_BEFORE,

1689N/A} arg_dependency = DEPENDENCY_FORWARD;

1689N/Astatic const char *arg_job_mode = "replace";

1689N/Astatic UnitFileScope arg_scope = UNIT_FILE_SYSTEM;

1689N/Astatic bool arg_no_block = false;

1689N/Astatic bool arg_no_legend = false;

1689N/Astatic bool arg_no_pager = false;

1689N/Astatic bool arg_no_wtmp = false;

1689N/Astatic bool arg_no_wall = false;

1689N/Astatic bool arg_no_reload = false;

1689N/Astatic bool arg_show_types = false;

1689N/Astatic bool arg_ignore_inhibitors = false;

1689N/Astatic bool arg_dry = false;

1689N/Astatic bool arg_quiet = false;

1689N/Astatic bool arg_full = false;

1689N/Astatic int arg_force = 0;

1689N/Astatic bool arg_ask_password = true;

1689N/Astatic bool arg_runtime = false;

1689N/Astatic char **arg_wall = NULL;

1689N/Astatic const char *arg_kill_who = NULL;

1689N/Astatic int arg_signal = SIGTERM;

1689N/Astatic const char *arg_root = NULL;

1689N/Astatic usec_t arg_when = 0;

1689N/Astatic enum action {

1689N/A _ACTION_INVALID,

3840N/A ACTION_SYSTEMCTL,

3840N/A ACTION_HALT,

1689N/A ACTION_POWEROFF,

1689N/A ACTION_REBOOT,

1689N/A ACTION_KEXEC,

1689N/A ACTION_EXIT,

1689N/A ACTION_SUSPEND,

1689N/A ACTION_HIBERNATE,

1689N/A ACTION_HYBRID_SLEEP,

1689N/A ACTION_RUNLEVEL2,

1689N/A ACTION_RUNLEVEL3,

1689N/A ACTION_RUNLEVEL4,

1689N/A ACTION_RUNLEVEL5,

1689N/A ACTION_RESCUE,

1689N/A ACTION_EMERGENCY,

1689N/A ACTION_DEFAULT,

1689N/A ACTION_RELOAD,

1689N/A ACTION_REEXEC,

1689N/A ACTION_RUNLEVEL,

1689N/A ACTION_CANCEL_SHUTDOWN,

1689N/A _ACTION_MAX

1689N/A} arg_action = ACTION_SYSTEMCTL;

1689N/Astatic BusTransport arg_transport = BUS_TRANSPORT_LOCAL;

1689N/Astatic char *arg_host = NULL;

1689N/Astatic unsigned arg_lines = 10;

1689N/Astatic OutputMode arg_output = OUTPUT_SHORT;

1689N/Astatic bool arg_plain = false;

1689N/A

1689N/Astatic int daemon_reload(sd_bus *bus, char **args);

1689N/Astatic void halt_now(enum action a);

1689N/A

1689N/Astatic void pager_open_if_enabled(void) {

1689N/A

1689N/A if (arg_no_pager)

1689N/A return;

1689N/A

1689N/A pager_open(false);

1689N/A}

1689N/A

1689N/Astatic void ask_password_agent_open_if_enabled(void) {

1689N/A

1689N/A /* Open the password agent as a child process if necessary */

1689N/A

1689N/A if (!arg_ask_password)

1689N/A return;

1689N/A

1689N/A if (arg_scope != UNIT_FILE_SYSTEM)

1689N/A return;

1689N/A

1689N/A if (arg_transport != BUS_TRANSPORT_LOCAL)

1689N/A return;

1689N/A

1689N/A ask_password_agent_open();

1689N/A}

1689N/A

1689N/A#ifdef HAVE_LOGIND

1689N/Astatic void polkit_agent_open_if_enabled(void) {

1689N/A

1689N/A /* Open the polkit agent as a child process if necessary */

1689N/A

1689N/A if (!arg_ask_password)

1689N/A return;

1689N/A

1689N/A if (arg_scope != UNIT_FILE_SYSTEM)

1689N/A return;

1689N/A

1689N/A if (arg_transport != BUS_TRANSPORT_LOCAL)

1689N/A return;

4134N/A

1689N/A polkit_agent_open();

1689N/A}

1689N/A#endif

4134N/A

1689N/Astatic int translate_bus_error_to_exit_status(int r, const sd_bus_error *error) {

1689N/A assert(error);

4134N/A

1689N/A if (!sd_bus_error_is_set(error))

1689N/A return r;

1689N/A

1689N/A if (sd_bus_error_has_name(error, SD_BUS_ERROR_ACCESS_DENIED) ||

1689N/A sd_bus_error_has_name(error, BUS_ERROR_ONLY_BY_DEPENDENCY) ||

1689N/A sd_bus_error_has_name(error, BUS_ERROR_NO_ISOLATION) ||

1689N/A sd_bus_error_has_name(error, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE))

1689N/A return EXIT_NOPERMISSION;

1689N/A

1689N/A if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT))

1689N/A return EXIT_NOTINSTALLED;

1689N/A

1689N/A if (sd_bus_error_has_name(error, BUS_ERROR_JOB_TYPE_NOT_APPLICABLE) ||

1689N/A sd_bus_error_has_name(error, BUS_ERROR_NOT_SUPPORTED))

1689N/A return EXIT_NOTIMPLEMENTED;

1689N/A

1689N/A if (sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED))

1689N/A return EXIT_NOTCONFIGURED;

1689N/A

1689N/A if (r != 0)

1689N/A return r;

1689N/A

1689N/A return EXIT_FAILURE;

1689N/A}

1689N/A

1689N/Astatic void warn_wall(enum action a) {

1689N/A static const char *table[_ACTION_MAX] = {

1689N/A [ACTION_HALT] = "The system is going down for system halt NOW!",

1689N/A [ACTION_REBOOT] = "The system is going down for reboot NOW!",

1689N/A [ACTION_POWEROFF] = "The system is going down for power-off NOW!",

1689N/A [ACTION_KEXEC] = "The system is going down for kexec reboot NOW!",

1689N/A [ACTION_RESCUE] = "The system is going down to rescue mode NOW!",

1689N/A [ACTION_EMERGENCY] = "The system is going down to emergency mode NOW!",

1689N/A [ACTION_CANCEL_SHUTDOWN] = "The system shutdown has been cancelled NOW!"

1689N/A };

1689N/A

1689N/A if (arg_no_wall)

1689N/A return;

1689N/A

1689N/A if (arg_wall) {

1689N/A _cleanup_free_ char *p;

1689N/A

1689N/A p = strv_join(arg_wall, " ");

1689N/A if (!p) {

1689N/A log_oom();

1689N/A return;

1689N/A }

1689N/A

1689N/A if (*p) {

1689N/A utmp_wall(p, NULL);

1689N/A return;

1689N/A }

1689N/A }

1689N/A

1689N/A if (!table[a])

1689N/A return;

1689N/A

1689N/A utmp_wall(table[a], NULL);

1689N/A}

1689N/A

1689N/Astatic bool avoid_bus(void) {

1689N/A

1689N/A if (running_in_chroot() > 0)

1689N/A return true;

1689N/A

1689N/A if (sd_booted() <= 0)

1689N/A return true;

2086N/A

1689N/A if (!isempty(arg_root))

1689N/A return true;

1689N/A

1689N/A if (arg_scope == UNIT_FILE_GLOBAL)

1689N/A return true;

1689N/A

1689N/A return false;

1689N/A}

1689N/A

1689N/Astatic int compare_unit_info(const void *a, const void *b) {

1689N/A const UnitInfo *u = a, *v = b;

1689N/A const char *d1, *d2;

1689N/A

1689N/A d1 = strrchr(u->id, '.');

1689N/A d2 = strrchr(v->id, '.');

1689N/A

1689N/A if (d1 && d2) {

1689N/A int r;

1689N/A

1689N/A r = strcasecmp(d1, d2);

1689N/A if (r != 0)

1689N/A return r;

1689N/A }

1689N/A

1689N/A return strcasecmp(u->id, v->id);

1689N/A}

1689N/A

1689N/Astatic bool output_show_unit(const UnitInfo *u) {

1689N/A const char *dot;

1689N/A

1689N/A if (!strv_isempty(arg_states))

1689N/A return

1689N/A strv_contains(arg_states, u->load_state) ||

1689N/A strv_contains(arg_states, u->sub_state) ||

1689N/A strv_contains(arg_states, u->active_state);

1689N/A

1689N/A return (!arg_types || ((dot = strrchr(u->id, '.')) &&

1689N/A strv_find(arg_types, dot+1))) &&

1689N/A (arg_all || !(streq(u->active_state, "inactive")

1689N/A || u->following[0]) || u->job_id > 0);

1689N/A}

1689N/A

1689N/Astatic void output_units_list(const UnitInfo *unit_infos, unsigned c) {

1689N/A unsigned id_len, max_id_len, load_len, active_len, sub_len, job_len, desc_len;

1689N/A const UnitInfo *u;

1689N/A unsigned n_shown = 0;

1689N/A int job_count = 0;

1689N/A

1689N/A max_id_len = sizeof("UNIT")-1;

1689N/A load_len = sizeof("LOAD")-1;

1689N/A active_len = sizeof("ACTIVE")-1;

1689N/A sub_len = sizeof("SUB")-1;

1689N/A job_len = sizeof("JOB")-1;

1689N/A desc_len = 0;

1689N/A

1689N/A for (u = unit_infos; u < unit_infos + c; u++) {

1689N/A if (!output_show_unit(u))

1689N/A continue;

1689N/A

1689N/A max_id_len = MAX(max_id_len, strlen(u->id));

1689N/A load_len = MAX(load_len, strlen(u->load_state));

1689N/A active_len = MAX(active_len, strlen(u->active_state));

1689N/A sub_len = MAX(sub_len, strlen(u->sub_state));

1689N/A

1689N/A if (u->job_id != 0) {

1689N/A job_len = MAX(job_len, strlen(u->job_type));

1689N/A job_count++;

1689N/A }

1689N/A }

1689N/A

1689N/A if (!arg_full && original_stdout_is_tty) {

1689N/A unsigned basic_len;

1689N/A

1689N/A id_len = MIN(max_id_len, 25u);

1689N/A basic_len = 5 + id_len + 5 + active_len + sub_len;

1689N/A

1689N/A if (job_count)

1689N/A basic_len += job_len + 1;

1689N/A

1689N/A if (basic_len < (unsigned) columns()) {

1689N/A unsigned extra_len, incr;

1689N/A extra_len = columns() - basic_len;

1689N/A

1689N/A /* Either UNIT already got 25, or is fully satisfied.

1689N/A incr = MIN(extra_len, 25u);

1689N/A desc_len += incr;

1689N/A extra_len -= incr;

1689N/A

1689N/A /* split the remaining space between UNIT and DESC,

1689N/A if (extra_len > 0) {

1689N/A incr = MIN(extra_len / 2, max_id_len - id_len);

1689N/A id_len += incr;

1689N/A desc_len += extra_len - incr;

1689N/A }

1689N/A }

1689N/A } else

1689N/A id_len = max_id_len;

1689N/A

1689N/A for (u = unit_infos; u < unit_infos + c; u++) {

1689N/A _cleanup_free_ char *e = NULL;

1689N/A const char *on_loaded, *off_loaded, *on = "";

1689N/A const char *on_active, *off_active, *off = "";

1689N/A

3840N/A if (!output_show_unit(u))

3840N/A continue;

1689N/A

1689N/A if (!n_shown && !arg_no_legend) {

1689N/A printf("%-*s %-*s %-*s %-*s ",

1689N/A id_len, "UNIT",

1689N/A load_len, "LOAD",

1689N/A active_len, "ACTIVE",

1689N/A sub_len, "SUB");

1689N/A

1689N/A if (job_count)

1689N/A printf("%-*s ", job_len, "JOB");

1689N/A

1689N/A if (!arg_full && arg_no_pager)

1689N/A printf("%.*s\n", desc_len, "DESCRIPTION");

1689N/A else

1689N/A printf("%s\n", "DESCRIPTION");

1689N/A }

1689N/A

1689N/A n_shown++;

1689N/A

3853N/A if (streq(u->load_state, "error") ||

3853N/A streq(u->load_state, "not-found")) {

2086N/A on_loaded = on = ansi_highlight_red();

2086N/A off_loaded = off = ansi_highlight_off();

3853N/A } else

3853N/A on_loaded = off_loaded = "";

1689N/A

3853N/A if (streq(u->active_state, "failed")) {

3853N/A on_active = on = ansi_highlight_red();

3853N/A off_active = off = ansi_highlight_off();

3853N/A } else

3853N/A on_active = off_active = "";

3853N/A

3853N/A e = arg_full ? NULL : ellipsize(u->id, id_len, 33);

3853N/A

3853N/A printf("%s%-*s%s %s%-*s%s %s%-*s %-*s%s %-*s",

3853N/A on, id_len, e ? e : u->id, off,

3853N/A on_loaded, load_len, u->load_state, off_loaded,

3853N/A on_active, active_len, u->active_state,

3853N/A sub_len, u->sub_state, off_active,

3853N/A job_count ? job_len + 1 : 0, u->job_id ? u->job_type : "");

3853N/A

3853N/A if (desc_len > 0)

3853N/A printf("%.*s\n", desc_len, u->description);

3853N/A else

3853N/A printf("%s\n", u->description);

1689N/A }

1689N/A

1689N/A if (!arg_no_legend) {

1689N/A const char *on, *off;

1689N/A

1689N/A if (n_shown) {

1689N/A printf("\nLOAD = Reflects whether the unit definition was properly loaded.\n"

1689N/A "ACTIVE = The high-level unit activation state, i.e. generalization of SUB.\n"

1689N/A "SUB = The low-level unit activation state, values depend on unit type.\n");

1689N/A if (job_count)

1689N/A printf("JOB = Pending job for the unit.\n");

1689N/A puts("");

1689N/A on = ansi_highlight();

1689N/A off = ansi_highlight_off();

1689N/A } else {

1689N/A on = ansi_highlight_red();

1689N/A off = ansi_highlight_off();

1689N/A }

1689N/A

1689N/A if (arg_all)

1689N/A printf("%s%u loaded units listed.%s\n"

1689N/A "To show all installed unit files use 'systemctl list-unit-files'.\n",

1689N/A on, n_shown, off);

1689N/A else

1689N/A printf("%s%u loaded units listed.%s Pass --all to see loaded but inactive units, too.\n"

1689N/A "To show all installed unit files use 'systemctl list-unit-files'.\n",

1689N/A on, n_shown, off);

1689N/A }

1689N/A}

1689N/A

1689N/Astatic int get_unit_list(

1689N/A sd_bus *bus,

1689N/A sd_bus_message **_reply,

1689N/A UnitInfo **_unit_infos) {

1689N/A

1689N/A _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

1689N/A _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;

1689N/A _cleanup_free_ UnitInfo *unit_infos = NULL;

1689N/A size_t size = 0;

1689N/A int r, c = 0;

1689N/A UnitInfo u;

1689N/A

1689N/A assert(bus);

1689N/A assert(_reply);

1689N/A assert(_unit_infos);

1689N/A

1689N/A r = sd_bus_call_method(

3853N/A bus,

3853N/A "org.freedesktop.systemd1",

1689N/A "/org/freedesktop/systemd1",

1689N/A "org.freedesktop.systemd1.Manager",

3853N/A "ListUnits",

3853N/A &error,

3853N/A &reply,

1689N/A NULL);

1689N/A if (r < 0) {

1689N/A log_error("Failed to list units: %s", bus_error_message(&error, r));

3853N/A return r;

1689N/A }

1689N/A

1689N/A r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssssouso)");

1689N/A if (r < 0)

1689N/A return bus_log_parse_error(r);

1689N/A

1689N/A while ((r = bus_parse_unit_info(reply, &u)) > 0) {

1689N/A

1689N/A if (!GREEDY_REALLOC(unit_infos, size, c+1))

1689N/A return log_oom();

1689N/A

2086N/A unit_infos[c++] = u;

1689N/A }

1689N/A if (r < 0)

1689N/A return bus_log_parse_error(r);

1689N/A

3840N/A r = sd_bus_message_exit_container(reply);

5080N/A if (r < 0)

1689N/A return bus_log_parse_error(r);

1689N/A

1689N/A *_reply = reply;

1689N/A reply = NULL;

1689N/A

1689N/A *_unit_infos = unit_infos;

1689N/A unit_infos = NULL;

1689N/A

1689N/A return c;

1689N/A}

1689N/A

1689N/Astatic int list_units(sd_bus *bus, char **args) {

1689N/A _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;

1689N/A _cleanup_free_ UnitInfo *unit_infos = NULL;

1689N/A int r;

1689N/A

1689N/A pager_open_if_enabled();

1689N/A

1689N/A r = get_unit_list(bus, &reply, &unit_infos);

1689N/A if (r < 0)

1689N/A return r;

1689N/A

1689N/A qsort_safe(unit_infos, r, sizeof(UnitInfo), compare_unit_info);

1689N/A output_units_list(unit_infos, r);

1689N/A

1689N/A return 0;

1689N/A}

1689N/A

1689N/Astatic int get_triggered_units(

1689N/A sd_bus *bus,

1689N/A const char* path,

1689N/A char*** ret) {

1689N/A

1689N/A _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

1689N/A int r;

1689N/A

1689N/A r = sd_bus_get_property_strv(

1689N/A bus,

1689N/A "org.freedesktop.systemd1",

1689N/A path,

1689N/A "org.freedesktop.systemd1.Unit",

1689N/A "Triggers",

1689N/A &error,

1689N/A ret);

1689N/A

1689N/A if (r < 0)

1689N/A log_error("Failed to determine triggers: %s", bus_error_message(&error, r));

1689N/A

1689N/A return 0;

1689N/A}

1689N/A

1689N/Astatic int get_listening(

1689N/A sd_bus *bus,

1689N/A const char* unit_path,

1689N/A char*** listen,

1689N/A unsigned *c) {

1689N/A

1689N/A _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;

1689N/A _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

1689N/A const char *type, *path;

1689N/A int r;

1689N/A

1689N/A r = sd_bus_get_property(

1689N/A bus,

1689N/A "org.freedesktop.systemd1",

1689N/A unit_path,

1689N/A "org.freedesktop.systemd1.Socket",

1689N/A "Listen",

1689N/A &error,

1689N/A &reply,

1689N/A "a(ss)");

1689N/A if (r < 0) {

1689N/A log_error("Failed to get list of listening sockets: %s", bus_error_message(&error, r));

1689N/A return r;

1689N/A }

1689N/A

1689N/A r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ss)");

1689N/A if (r < 0)

1689N/A return bus_log_parse_error(r);

1689N/A

1689N/A while ((r = sd_bus_message_read(reply, "(ss)", &type, &path)) > 0) {

1689N/A

1689N/A r = strv_extend(listen, type);

1689N/A if (r < 0)

1689N/A return log_oom();

1689N/A

1689N/A r = strv_extend(listen, path);

1689N/A if (r < 0)

1689N/A return log_oom();

1689N/A

1689N/A (*c)++;

1689N/A }

1689N/A if (r < 0)

1689N/A return bus_log_parse_error(r);

1689N/A

1689N/A r = sd_bus_message_exit_container(reply);

1689N/A if (r < 0)

1689N/A return bus_log_parse_error(r);

1689N/A

1689N/A return 0;

1689N/A}

1689N/A

1689N/Astruct socket_info {

1689N/A const char* id;

1689N/A

1689N/A char* type;

1689N/A char* path;

1689N/A

2086N/A /* Note: triggered is a list here, although it almost certainly

1689N/A char** triggered;

1689N/A

1689N/A /* The strv above is shared. free is set only in the first one. */

1689N/A bool own_triggered;

1689N/A};

1689N/A

1689N/Astatic int socket_info_compare(struct socket_info *a, struct socket_info *b) {

1689N/A int o;

1689N/A

1689N/A o = strcmp(a->path, b->path);

1689N/A if (o == 0)

1689N/A o = strcmp(a->type, b->type);

1689N/A

1689N/A return o;

1689N/A}

1689N/A

1689N/Astatic int output_sockets_list(struct socket_info *socket_infos, unsigned cs) {

1689N/A struct socket_info *s;

1689N/A unsigned pathlen = sizeof("LISTEN") - 1,

1689N/A typelen = (sizeof("TYPE") - 1) * arg_show_types,

1689N/A socklen = sizeof("UNIT") - 1,

1689N/A servlen = sizeof("ACTIVATES") - 1;

1689N/A const char *on, *off;

1689N/A

1689N/A for (s = socket_infos; s < socket_infos + cs; s++) {

1689N/A unsigned tmp = 0;

1689N/A char **a;

1689N/A

1689N/A socklen = MAX(socklen, strlen(s->id));

1689N/A if (arg_show_types)

1689N/A typelen = MAX(typelen, strlen(s->type));

1689N/A pathlen = MAX(pathlen, strlen(s->path));

1689N/A

1689N/A STRV_FOREACH(a, s->triggered)

1689N/A tmp += strlen(*a) + 2*(a != s->triggered);

1689N/A servlen = MAX(servlen, tmp);

1689N/A }

1689N/A

1689N/A if (cs) {

1689N/A if (!arg_no_legend)

1689N/A printf("%-*s %-*.*s%-*s %s\n",

1689N/A pathlen, "LISTEN",

1689N/A typelen + arg_show_types, typelen + arg_show_types, "TYPE ",

1689N/A socklen, "UNIT",

1689N/A "ACTIVATES");

1689N/A

1689N/A for (s = socket_infos; s < socket_infos + cs; s++) {

1689N/A char **a;

1689N/A

1689N/A if (arg_show_types)

1689N/A printf("%-*s %-*s %-*s",

1689N/A pathlen, s->path, typelen, s->type, socklen, s->id);

1689N/A else

1689N/A printf("%-*s %-*s",

1689N/A pathlen, s->path, socklen, s->id);

1689N/A STRV_FOREACH(a, s->triggered)

1689N/A printf("%s %s",

1689N/A a == s->triggered ? "" : ",", *a);

1689N/A printf("\n");

1689N/A }

1689N/A

1689N/A on = ansi_highlight();

1689N/A off = ansi_highlight_off();

1689N/A if (!arg_no_legend)

1689N/A printf("\n");

1689N/A } else {

1689N/A on = ansi_highlight_red();

1689N/A off = ansi_highlight_off();

1689N/A }

1689N/A

1689N/A if (!arg_no_legend) {

1689N/A printf("%s%u sockets listed.%s\n", on, cs, off);

1689N/A if (!arg_all)

1689N/A printf("Pass --all to see loaded but inactive sockets, too.\n");

1689N/A }

1689N/A

1689N/A return 0;

1689N/A}

1689N/A

1689N/Astatic int list_sockets(sd_bus *bus, char **args) {

1689N/A _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;

1689N/A _cleanup_free_ UnitInfo *unit_infos = NULL;

1689N/A struct socket_info *socket_infos = NULL;

1689N/A const UnitInfo *u;

1689N/A struct socket_info *s;

1689N/A unsigned cu = 0, cs = 0;

1689N/A size_t size = 0;

1689N/A int r;

1689N/A

1689N/A pager_open_if_enabled();

1689N/A

1689N/A r = get_unit_list(bus, &reply, &unit_infos);

1689N/A if (r < 0)

1689N/A return r;

1689N/A

1689N/A cu = (unsigned) r;

1689N/A

1689N/A for (u = unit_infos; u < unit_infos + cu; u++) {

1689N/A _cleanup_strv_free_ char **listen = NULL, **triggered = NULL;

1689N/A unsigned c = 0, i;

1689N/A

1689N/A if (!output_show_unit(u))

1689N/A continue;

1689N/A

1689N/A if (!endswith(u->id, ".socket"))

1689N/A continue;

1689N/A

1689N/A r = get_triggered_units(bus, u->unit_path, &triggered);

1689N/A if (r < 0)

1689N/A goto cleanup;

1689N/A

1689N/A r = get_listening(bus, u->unit_path, &listen, &c);

1689N/A if (r < 0)

1689N/A goto cleanup;

1689N/A

1689N/A if (!GREEDY_REALLOC(socket_infos, size, cs + c)) {

1689N/A r = log_oom();

1689N/A goto cleanup;

1689N/A }

3352N/A

3352N/A for (i = 0; i < c; i++)

1689N/A socket_infos[cs + i] = (struct socket_info) {

3352N/A .id = u->id,

3352N/A .type = listen[i*2],

1689N/A .path = listen[i*2 + 1],

1689N/A .triggered = triggered,

1689N/A .own_triggered = i==0,

1689N/A };

1689N/A

1881N/A /* from this point on we will cleanup those socket_infos */

1881N/A cs += c;

1881N/A free(listen);

3352N/A listen = triggered = NULL; /* avoid cleanup */

1689N/A }

3352N/A

3352N/A qsort_safe(socket_infos, cs, sizeof(struct socket_info),

3352N/A (__compar_fn_t) socket_info_compare);

1689N/A

3352N/A output_sockets_list(socket_infos, cs);

1689N/A

3352N/A cleanup:

3352N/A assert(cs == 0 || socket_infos);

1689N/A for (s = socket_infos; s < socket_infos + cs; s++) {

3352N/A free(s->type);

3352N/A free(s->path);

3352N/A if (s->own_triggered)

3352N/A strv_free(s->triggered);

1689N/A }

1689N/A free(socket_infos);

1689N/A

3352N/A return r;

3352N/A}

1689N/A

1689N/Astatic int compare_unit_file_list(const void *a, const void *b) {

1689N/A const char *d1, *d2;

1689N/A const UnitFileList *u = a, *v = b;

1689N/A

1689N/A d1 = strrchr(u->path, '.');

3352N/A d2 = strrchr(v->path, '.');

1689N/A

1689N/A if (d1 && d2) {

1689N/A int r;

1689N/A

1689N/A r = strcasecmp(d1, d2);

1689N/A if (r != 0)

1689N/A return r;

1689N/A }

1689N/A

1689N/A return strcasecmp(path_get_file_name(u->path), path_get_file_name(v->path));

1689N/A}

3352N/A

1689N/Astatic bool output_show_unit_file(const UnitFileList *u) {

1689N/A const char *dot;

1881N/A

1881N/A return !arg_types || ((dot = strrchr(u->path, '.')) && strv_find(arg_types, dot+1));

3352N/A}

3352N/A

3352N/Astatic void output_unit_file_list(const UnitFileList *units, unsigned c) {

3352N/A unsigned max_id_len, id_cols, state_cols, n_shown = 0;

3352N/A const UnitFileList *u;

3352N/A

3352N/A max_id_len = sizeof("UNIT FILE")-1;

1881N/A state_cols = sizeof("STATE")-1;

3352N/A

3352N/A for (u = units; u < units + c; u++) {

3352N/A if (!output_show_unit_file(u))

3352N/A continue;

3352N/A

3352N/A max_id_len = MAX(max_id_len, strlen(path_get_file_name(u->path)));

1881N/A state_cols = MAX(state_cols, strlen(unit_file_state_to_string(u->state)));

1881N/A }

1881N/A

1881N/A if (!arg_full) {

5154N/A unsigned basic_cols;

5154N/A

5154N/A id_cols = MIN(max_id_len, 25u);

3352N/A basic_cols = 1 + id_cols + state_cols;

3352N/A if (basic_cols < (unsigned) columns())

3352N/A id_cols += MIN(columns() - basic_cols, max_id_len - id_cols);

3352N/A } else

3352N/A id_cols = max_id_len;

3352N/A

3352N/A if (!arg_no_legend)

3352N/A printf("%-*s %-*s\n",

3352N/A id_cols, "UNIT FILE",

3902N/A state_cols, "STATE");

3902N/A

3902N/A for (u = units; u < units + c; u++) {

3902N/A _cleanup_free_ char *e = NULL;

1881N/A const char *on, *off;

1881N/A const char *id;

1881N/A

1881N/A if (!output_show_unit_file(u))

3352N/A continue;

3352N/A

3352N/A n_shown++;

3352N/A

3352N/A if (u->state == UNIT_FILE_MASKED ||

1689N/A u->state == UNIT_FILE_MASKED_RUNTIME ||

1881N/A u->state == UNIT_FILE_DISABLED ||

1881N/A u->state == UNIT_FILE_INVALID) {

1881N/A on = ansi_highlight_red();

1881N/A off = ansi_highlight_off();

1881N/A } else if (u->state == UNIT_FILE_ENABLED) {

1881N/A on = ansi_highlight_green();

1881N/A off = ansi_highlight_off();

1881N/A } else

1881N/A on = off = "";

1881N/A

1881N/A id = path_get_file_name(u->path);

1881N/A

1881N/A e = arg_full ? NULL : ellipsize(id, id_cols, 33);

1881N/A

1881N/A printf("%-*s %s%-*s%s\n",

1881N/A id_cols, e ? e : id,

1881N/A on, state_cols, unit_file_state_to_string(u->state), off);

1881N/A }

1881N/A

1881N/A if (!arg_no_legend)

1881N/A printf("\n%u unit files listed.\n", n_shown);

1881N/A}

1881N/A

3853N/Astatic int list_unit_files(sd_bus *bus, char **args) {

3853N/A _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;

1881N/A _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

1881N/A _cleanup_free_ UnitFileList *units = NULL;

1881N/A unsigned c = 0;

1881N/A const char *state;

1881N/A char *path;

1881N/A int r;

1881N/A

1881N/A pager_open_if_enabled();

1881N/A

1881N/A if (avoid_bus()) {

1881N/A Hashmap *h;

1881N/A UnitFileList *u;

1881N/A Iterator i;

1881N/A unsigned n_units;

1881N/A

1881N/A h = hashmap_new(string_hash_func, string_compare_func);

1881N/A if (!h)

1881N/A return log_oom();

1881N/A

1881N/A r = unit_file_get_list(arg_scope, arg_root, h);

1881N/A if (r < 0) {

1689N/A unit_file_list_free(h);

1689N/A log_error("Failed to get unit file list: %s", strerror(-r));

1689N/A return r;

1689N/A }

1689N/A

1689N/A n_units = hashmap_size(h);

1689N/A units = new(UnitFileList, n_units);

1689N/A if (!units) {

1689N/A unit_file_list_free(h);

1689N/A return log_oom();

1689N/A }

1689N/A

1689N/A HASHMAP_FOREACH(u, h, i) {

1689N/A memcpy(units + c++, u, sizeof(UnitFileList));

1689N/A free(u);

1689N/A }

3004N/A

1689N/A assert(c == n_units);

3004N/A hashmap_free(h);

1689N/A } else {

1689N/A size_t size = 0;

1689N/A

2086N/A r = sd_bus_call_method(

3004N/A bus,

1689N/A "org.freedesktop.systemd1",

3004N/A "/org/freedesktop/systemd1",

3004N/A "org.freedesktop.systemd1.Manager",

3004N/A "ListUnitFiles",

3004N/A &error,

3004N/A &reply,

3004N/A NULL);

1689N/A if (r < 0) {

3004N/A log_error("Failed to list unit files: %s", bus_error_message(&error, r));

3004N/A return r;

3004N/A }

3004N/A

1689N/A r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ss)");

1689N/A if (r < 0)

1689N/A return bus_log_parse_error(r);

1689N/A

1689N/A while ((r = sd_bus_message_read(reply, "(ss)", &path, &state)) > 0) {

1689N/A

1689N/A if (!GREEDY_REALLOC(units, size, c + 1))

1689N/A return log_oom();

1689N/A

1689N/A units[c++] = (struct UnitFileList) {

1689N/A path,

1689N/A unit_file_state_from_string(state)

1689N/A };

1689N/A }

1689N/A if (r < 0)

return bus_log_parse_error(r);

r = sd_bus_message_exit_container(reply);

if (r < 0)

return bus_log_parse_error(r);

}

if (c > 0) {

qsort(units, c, sizeof(UnitFileList), compare_unit_file_list);

output_unit_file_list(units, c);

}

return 0;

}

static int list_dependencies_print(const char *name, int level, unsigned int branches, bool last) {

_cleanup_free_ char *n = NULL;

size_t max_len = MAX(columns(),20u);

size_t len = 0;

int i;

if (!arg_plain) {

for (i = level - 1; i >= 0; i--) {

len += 2;

if(len > max_len - 3 && !arg_full) {

printf("%s...\n",max_len % 2 ? "" : " ");

return 0;

}

printf("%s", draw_special_char(branches & (1 << i) ? DRAW_TREE_VERT : DRAW_TREE_SPACE));

}

len += 2;

if(len > max_len - 3 && !arg_full) {

printf("%s...\n",max_len % 2 ? "" : " ");

return 0;

}

printf("%s", draw_special_char(last ? DRAW_TREE_RIGHT : DRAW_TREE_BRANCH));

}

if (arg_full){

printf("%s\n", name);

return 0;

}

n = ellipsize(name, max_len-len, 100);

if(!n)

return log_oom();

printf("%s\n", n);

return 0;

}

static int list_dependencies_get_dependencies(sd_bus *bus, const char *name, char ***deps) {

static const char *dependencies[] = {

[DEPENDENCY_FORWARD] = "Requires\0"

"RequiresOverridable\0"

"Requisite\0"

"RequisiteOverridable\0"

"Wants\0",

[DEPENDENCY_REVERSE] = "RequiredBy\0"

"RequiredByOverridable\0"

"WantedBy\0"

"PartOf\0",

[DEPENDENCY_AFTER] = "After\0",

[DEPENDENCY_BEFORE] = "Before\0",

};

_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;

_cleanup_strv_free_ char **ret = NULL;

_cleanup_free_ char *path = NULL;

int r;

assert(bus);

assert(name);

assert(deps);

assert(arg_dependency < ELEMENTSOF(dependencies));

path = unit_dbus_path_from_name(name);

if (!path)

return log_oom();

r = sd_bus_call_method(

bus,

"org.freedesktop.systemd1",

path,

"org.freedesktop.DBus.Properties",

"GetAll",

&error,

&reply,

"s", "org.freedesktop.systemd1.Unit");

if (r < 0) {

log_error("Failed to get properties of %s: %s", name, bus_error_message(&error, r));

return r;

}

r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "{sv}");

if (r < 0)

return bus_log_parse_error(r);

while ((r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {

const char *prop;

r = sd_bus_message_read(reply, "s", &prop);

if (r < 0)

return bus_log_parse_error(r);

if (!nulstr_contains(dependencies[arg_dependency], prop)) {

r = sd_bus_message_skip(reply, "v");

if (r < 0)

return bus_log_parse_error(r);

} else {

r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_VARIANT, "as");

if (r < 0)

return bus_log_parse_error(r);

r = bus_message_read_strv_extend(reply, &ret);

if (r < 0)

return bus_log_parse_error(r);

r = sd_bus_message_exit_container(reply);

if (r < 0)

return bus_log_parse_error(r);

}

r = sd_bus_message_exit_container(reply);

if (r < 0)

return bus_log_parse_error(r);

}

if (r < 0)

return bus_log_parse_error(r);

r = sd_bus_message_exit_container(reply);

if (r < 0)

return bus_log_parse_error(r);

*deps = ret;

ret = NULL;

return 0;

}

static int list_dependencies_compare(const void *_a, const void *_b) {

const char **a = (const char**) _a, **b = (const char**) _b;

if (unit_name_to_type(*a) == UNIT_TARGET && unit_name_to_type(*b) != UNIT_TARGET)

return 1;

if (unit_name_to_type(*a) != UNIT_TARGET && unit_name_to_type(*b) == UNIT_TARGET)

return -1;

return strcasecmp(*a, *b);

}

static int list_dependencies_one(

sd_bus *bus,

const char *name,

int level,

char ***units,

unsigned int branches) {

_cleanup_strv_free_ char **deps = NULL, **u;

char **c;

int r = 0;

assert(bus);

assert(name);

assert(units);

u = strv_append(*units, name);

if (!u)

return log_oom();

r = list_dependencies_get_dependencies(bus, name, &deps);

if (r < 0)

return r;

qsort_safe(deps, strv_length(deps), sizeof (char*), list_dependencies_compare);

STRV_FOREACH(c, deps) {

if (strv_contains(u, *c)) {

if (!arg_plain) {

r = list_dependencies_print("...", level + 1, (branches << 1) | (c[1] == NULL ? 0 : 1), 1);

if (r < 0)

return r;

}

continue;

}

r = list_dependencies_print(*c, level, branches, c[1] == NULL);

if (r < 0)

return r;

if (arg_all || unit_name_to_type(*c) == UNIT_TARGET) {

r = list_dependencies_one(bus, *c, level + 1, &u, (branches << 1) | (c[1] == NULL ? 0 : 1));

if(r < 0)

return r;

}

}

if (arg_plain) {

strv_free(*units);

*units = u;

u = NULL;

}

return 0;

}

static int list_dependencies(sd_bus *bus, char **args) {

_cleanup_strv_free_ char **units = NULL;

_cleanup_free_ char *unit = NULL;

const char *u;

assert(bus);

if (args[1]) {

unit = unit_name_mangle(args[1]);

if (!unit)

return log_oom();

u = unit;

} else

u = SPECIAL_DEFAULT_TARGET;

pager_open_if_enabled();

puts(u);

return list_dependencies_one(bus, u, 0, &units, 0);

}

static int get_default(sd_bus *bus, char **args) {

_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;

_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_free_ char *_path = NULL;

const char *path;

int r;

if (!bus || avoid_bus()) {

r = unit_file_get_default(arg_scope, arg_root, &_path);

if (r < 0) {

log_error("Failed to get default target: %s", strerror(-r));

return r;

}

path = _path;

} else {

r = sd_bus_call_method(

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"GetDefaultTarget",

&error,

&reply,

NULL);

if (r < 0) {

log_error("Failed to get default target: %s", bus_error_message(&error, -r));

return r;

}

r = sd_bus_message_read(reply, "s", &path);

if (r < 0)

return bus_log_parse_error(r);

}

if (path)

printf("%s\n", path);

return 0;

}

struct job_info {

uint32_t id;

const char *name, *type, *state;

};

static void output_jobs_list(const struct job_info* jobs, unsigned n) {

unsigned id_len, unit_len, type_len, state_len;

const struct job_info *j;

const char *on, *off;

bool shorten = false;

assert(n == 0 || jobs);

if (n == 0) {

on = ansi_highlight_green();

off = ansi_highlight_off();

printf("%sNo jobs running.%s\n", on, off);

return;

}

pager_open_if_enabled();

id_len = unit_len = type_len = state_len = 0;

for (j = jobs; j < jobs + n; j++) {

uint32_t id = j->id;

assert(j->name && j->type && j->state);

id_len = MAX(id_len, DECIMAL_STR_WIDTH(id));

unit_len = MAX(unit_len, strlen(j->name));

type_len = MAX(type_len, strlen(j->type));

state_len = MAX(state_len, strlen(j->state));

}

if (!arg_full && id_len + 1 + unit_len + type_len + 1 + state_len > columns()) {

unit_len = MAX(33u, columns() - id_len - type_len - state_len - 3);

shorten = true;

}

printf("%*s %-*s %-*s %-*s\n",

id_len, "JOB",

unit_len, "UNIT",

type_len, "TYPE",

state_len, "STATE");

for (j = jobs; j < jobs + n; j++) {

_cleanup_free_ char *e = NULL;

if (streq(j->state, "running")) {

on = ansi_highlight();

off = ansi_highlight_off();

} else

on = off = "";

e = shorten ? ellipsize(j->name, unit_len, 33) : NULL;

printf("%*u %s%-*s%s %-*s %s%-*s%s\n",

id_len, j->id,

on, unit_len, e ? e : j->name, off,

type_len, j->type,

on, state_len, j->state, off);

}

on = ansi_highlight();

off = ansi_highlight_off();

printf("\n%s%u jobs listed%s.\n", on, n, off);

}

static int list_jobs(sd_bus *bus, char **args) {

_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;

const char *name, *type, *state, *job_path, *unit_path;

_cleanup_free_ struct job_info *jobs = NULL;

size_t size = 0;

unsigned c = 0;

uint32_t id;

int r;

r = sd_bus_call_method(

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"ListJobs",

&error,

&reply,

NULL);

if (r < 0) {

log_error("Failed to list jobs: %s", bus_error_message(&error, r));

return r;

}

r = sd_bus_message_enter_container(reply, 'a', "(usssoo)");

if (r < 0)

return bus_log_parse_error(r);

while ((r = sd_bus_message_read(reply, "(usssoo)", &id, &name, &type, &state, &job_path, &unit_path)) > 0) {

if (!GREEDY_REALLOC(jobs, size, c + 1))

return log_oom();

jobs[c++] = (struct job_info) {

id,

name,

type,

state

};

}

if (r < 0)

return bus_log_parse_error(r);

r = sd_bus_message_exit_container(reply);

if (r < 0)

return bus_log_parse_error(r);

output_jobs_list(jobs, c);

return r;

}

static int cancel_job(sd_bus *bus, char **args) {

_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

char **name;

assert(args);

if (strv_length(args) <= 1)

return daemon_reload(bus, args);

STRV_FOREACH(name, args+1) {

uint32_t id;

int r;

r = safe_atou32(*name, &id);

if (r < 0) {

log_error("Failed to parse job id \"%s\": %s", *name, strerror(-r));

return r;

}

r = sd_bus_call_method(

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"CancelJob",

&error,

NULL,

"u", id);

if (r < 0) {

log_error("Failed to cancel job %u: %s", (unsigned) id, bus_error_message(&error, r));

return r;

}

}

return 0;

}

static int need_daemon_reload(sd_bus *bus, const char *unit) {

_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;

_cleanup_free_ char *n = NULL;

const char *path;

int b, r;

/* We ignore all errors here, since this is used to show a

n = unit_name_mangle(unit);

if (!n)

return -ENOMEM;

/* We don't use unit_dbus_path_from_name() directly since we