#include <sys/reboot.h>

#include <linux/reboot.h>

#include <sys/syscall.h>

#include <stdio.h>

#include <getopt.h>

#include <locale.h>

#include <stdbool.h>

#include <string.h>

#include <errno.h>

#include <sys/ioctl.h>

#include <termios.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/socket.h>

#include <sys/stat.h>

#include <stddef.h>

#include <sys/prctl.h>

#include <fnmatch.h>

#include "sd-daemon.h"

#include "sd-shutdown.h"

#include "sd-login.h"

#include "sd-bus.h"

#include "log.h"

#include "util.h"

#include "macro.h"

#include "set.h"

#include "utmp-wtmp.h"

#include "special.h"

#include "initreq.h"

#include "path-util.h"

#include "strv.h"

#include "cgroup-show.h"

#include "cgroup-util.h"

#include "list.h"

#include "path-lookup.h"

#include "conf-parser.h"

#include "exit-status.h"

#include "build.h"

#include "unit-name.h"

#include "pager.h"

#include "spawn-ask-password-agent.h"

#include "spawn-polkit-agent.h"

#include "install.h"

#include "logs-show.h"

#include "socket-util.h"

#include "fileio.h"

#include "copy.h"

#include "env-util.h"

#include "bus-util.h"

#include "bus-message.h"

#include "bus-error.h"

#include "bus-common-errors.h"

#include "mkdir.h"

#include "dropin.h"

static char **arg_types = NULL;

static char **arg_states = NULL;

static char **arg_properties = NULL;

static bool arg_all = false;

static enum dependency {

DEPENDENCY_FORWARD,

DEPENDENCY_REVERSE,

DEPENDENCY_AFTER,

DEPENDENCY_BEFORE,

_DEPENDENCY_MAX

} arg_dependency = DEPENDENCY_FORWARD;

static const char *arg_job_mode = "replace";

static UnitFileScope arg_scope = UNIT_FILE_SYSTEM;

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_wall = false;

static bool arg_no_reload = false;

static bool arg_show_types = false;

static bool arg_ignore_inhibitors = false;

static bool arg_dry = false;

static bool arg_quiet = false;

static bool arg_full = false;

static bool arg_recursive = false;

static int arg_force = 0;

static bool arg_ask_password = true;

static bool arg_runtime = false;

static UnitFilePresetMode arg_preset_mode = UNIT_FILE_PRESET_FULL;

static char **arg_wall = NULL;

static const char *arg_kill_who = NULL;

static int arg_signal = SIGTERM;

static const char *arg_root = NULL;

static usec_t arg_when = 0;

static enum action {

_ACTION_INVALID,

ACTION_SYSTEMCTL,

ACTION_HALT,

ACTION_POWEROFF,

ACTION_REBOOT,

ACTION_KEXEC,

ACTION_EXIT,

ACTION_SUSPEND,

ACTION_HIBERNATE,

ACTION_HYBRID_SLEEP,

ACTION_RUNLEVEL2,

ACTION_RUNLEVEL3,

ACTION_RUNLEVEL4,

ACTION_RUNLEVEL5,

ACTION_RESCUE,

ACTION_EMERGENCY,

ACTION_DEFAULT,

ACTION_RELOAD,

ACTION_REEXEC,

ACTION_RUNLEVEL,

ACTION_CANCEL_SHUTDOWN,

_ACTION_MAX

} arg_action = ACTION_SYSTEMCTL;

static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;

static char *arg_host = NULL;

static unsigned arg_lines = 10;

static OutputMode arg_output = OUTPUT_SHORT;

static bool arg_plain = false;

static bool original_stdout_is_tty;

static int daemon_reload(sd_bus *bus, char **args);

static int halt_now(enum action a);

static int check_one_unit(sd_bus *bus, const char *name, const char *good_states, bool quiet);

static char** strv_skip_first(char **strv) {

if (strv_length(strv) > 0)

return strv + 1;

return NULL;

}

static void pager_open_if_enabled(void) {

if (arg_no_pager)

return;

pager_open(false);

}

static void ask_password_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;

if (arg_transport != BUS_TRANSPORT_LOCAL)

return;

ask_password_agent_open();

}

#ifdef HAVE_LOGIND

static void polkit_agent_open_if_enabled(void) {

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

if (!arg_ask_password)

return;

if (arg_scope != UNIT_FILE_SYSTEM)

return;

if (arg_transport != BUS_TRANSPORT_LOCAL)

return;

polkit_agent_open();

}

#endif

static int translate_bus_error_to_exit_status(int r, const sd_bus_error *error) {

assert(error);

if (!sd_bus_error_is_set(error))

return r;

if (sd_bus_error_has_name(error, SD_BUS_ERROR_ACCESS_DENIED) ||

sd_bus_error_has_name(error, BUS_ERROR_ONLY_BY_DEPENDENCY) ||

sd_bus_error_has_name(error, BUS_ERROR_NO_ISOLATION) ||

sd_bus_error_has_name(error, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE))

return EXIT_NOPERMISSION;

if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT))

return EXIT_NOTINSTALLED;

if (sd_bus_error_has_name(error, BUS_ERROR_JOB_TYPE_NOT_APPLICABLE) ||

sd_bus_error_has_name(error, SD_BUS_ERROR_NOT_SUPPORTED))

return EXIT_NOTIMPLEMENTED;

if (sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED))

return EXIT_NOTCONFIGURED;

if (r != 0)

return r;

return EXIT_FAILURE;

}

static void warn_wall(enum action a) {

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!",

[ACTION_CANCEL_SHUTDOWN] = "The system shutdown has been cancelled NOW!"

};

if (arg_no_wall)

return;

if (arg_wall) {

_cleanup_free_ char *p;

p = strv_join(arg_wall, " ");

if (!p) {

log_oom();

return;

}

if (*p) {

utmp_wall(p, NULL, NULL);

return;

}

}

if (!table[a])

return;

utmp_wall(table[a], NULL, 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;

}

static int compare_unit_info(const void *a, const void *b) {

const UnitInfo *u = a, *v = b;

const char *d1, *d2;

int r;

/* First, order by machine */

if (!u->machine && v->machine)

return -1;

if (u->machine && !v->machine)

return 1;

if (u->machine && v->machine) {

r = strcasecmp(u->machine, v->machine);

if (r != 0)

return r;

}

/* Second, order by unit type */

d1 = strrchr(u->id, '.');

d2 = strrchr(v->id, '.');

if (d1 && d2) {

r = strcasecmp(d1, d2);

if (r != 0)

return r;

}

/* Third, order by name */

return strcasecmp(u->id, v->id);

}

static bool output_show_unit(const UnitInfo *u, char **patterns) {

if (!strv_isempty(patterns)) {

char **pattern;

STRV_FOREACH(pattern, patterns)

if (fnmatch(*pattern, u->id, FNM_NOESCAPE) == 0)

goto next;

return false;

}

next:

if (arg_types) {

const char *dot;

dot = strrchr(u->id, '.');

if (!dot)

return false;

if (!strv_find(arg_types, dot+1))

return false;

}

if (arg_all)

return true;

if (u->job_id > 0)

return true;

if (streq(u->active_state, "inactive") || u->following[0])

return false;

return true;

}

static int output_units_list(const UnitInfo *unit_infos, unsigned c) {

unsigned circle_len = 0, id_len, max_id_len, load_len, active_len, sub_len, job_len, desc_len;

const UnitInfo *u;

unsigned n_shown = 0;

int job_count = 0;

max_id_len = strlen("UNIT");

load_len = strlen("LOAD");

active_len = strlen("ACTIVE");

sub_len = strlen("SUB");

job_len = strlen("JOB");

desc_len = 0;

for (u = unit_infos; u < unit_infos + c; u++) {

max_id_len = MAX(max_id_len, strlen(u->id) + (u->machine ? strlen(u->machine)+1 : 0));

load_len = MAX(load_len, strlen(u->load_state));

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));

job_count++;

}

if (!arg_no_legend &&

(streq(u->active_state, "failed") ||

STR_IN_SET(u->load_state, "error", "not-found", "masked")))

circle_len = 2;

}

if (!arg_full && original_stdout_is_tty) {

unsigned basic_len;

id_len = MIN(max_id_len, 25u);

basic_len = circle_len + 5 + id_len + 5 + active_len + sub_len;

if (job_count)

basic_len += job_len + 1;

if (basic_len < (unsigned) columns()) {

unsigned extra_len, incr;

extra_len = columns() - basic_len;

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

incr = MIN(extra_len, 25u);

desc_len += incr;

extra_len -= incr;

/* split the remaining space between UNIT and DESC,

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;

for (u = unit_infos; u < unit_infos + c; u++) {

_cleanup_free_ char *e = NULL, *j = NULL;

const char *on_loaded = "", *off_loaded = "";

const char *on_active = "", *off_active = "";

const char *on_circle = "", *off_circle = "";

const char *id;

bool circle = false;

if (!n_shown && !arg_no_legend) {

if (circle_len > 0)

fputs(" ", stdout);

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

id_len, "UNIT",

load_len, "LOAD",

active_len, "ACTIVE",

sub_len, "SUB");

if (job_count)

printf("%-*s ", job_len, "JOB");

if (!arg_full && arg_no_pager)

printf("%.*s\n", desc_len, "DESCRIPTION");

else

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

}

n_shown++;

if (STR_IN_SET(u->load_state, "error", "not-found", "masked")) {

on_loaded = ansi_highlight_red();

on_circle = ansi_highlight_yellow();

off_loaded = off_circle = ansi_highlight_off();

circle = true;

}

if (streq(u->active_state, "failed")) {

on_circle = on_active = ansi_highlight_red();

off_circle = off_active = ansi_highlight_off();

circle = true;

}

if (u->machine) {

j = strjoin(u->machine, ":", u->id, NULL);

if (!j)

return log_oom();

id = j;

} else

id = u->id;

if (arg_full) {

e = ellipsize(id, id_len, 33);

if (!e)

return log_oom();

id = e;

}

if (circle_len > 0)

printf("%s%s%s ", on_circle, circle ? draw_special_char(DRAW_BLACK_CIRCLE) : " ", off_circle);

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

on_active, id_len, id, off_active,

on_loaded, load_len, u->load_state, off_loaded,

on_active, active_len, u->active_state,

sub_len, u->sub_state, off_active,

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

if (desc_len > 0)

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

else

printf("%s\n", u->description);

}

if (!arg_no_legend) {

const char *on, *off;

if (n_shown) {

puts("\n"

"LOAD = 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.");

puts(job_count ? "JOB = Pending job for the unit.\n" : "");

on = ansi_highlight();

off = ansi_highlight_off();

} else {

on = ansi_highlight_red();

off = ansi_highlight_off();

}

if (arg_all)

printf("%s%u loaded units listed.%s\n"

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

on, n_shown, off);

else

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

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

on, n_shown, off);

}

return 0;

}

static int get_unit_list(

sd_bus *bus,

const char *machine,

char **patterns,

UnitInfo **unit_infos,

int c,

sd_bus_message **_reply) {

_cleanup_bus_message_unref_ sd_bus_message *m = NULL;

_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;

size_t size = c;

int r;

UnitInfo u;

assert(bus);

assert(unit_infos);

assert(_reply);

r = sd_bus_message_new_method_call(

bus,

&m,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"ListUnitsFiltered");

if (r < 0)

return bus_log_create_error(r);

r = sd_bus_message_append_strv(m, arg_states);

if (r < 0)

return bus_log_create_error(r);

r = sd_bus_call(bus, m, 0, &error, &reply);

if (r < 0) {

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

return r;

}

r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssssouso)");

if (r < 0)

return bus_log_parse_error(r);

while ((r = bus_parse_unit_info(reply, &u)) > 0) {

u.machine = machine;

if (!output_show_unit(&u, patterns))

continue;

if (!GREEDY_REALLOC(*unit_infos, size, c+1))

return log_oom();

(*unit_infos)[c++] = u;

}

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);

*_reply = reply;

reply = NULL;

return c;

}

static void message_set_freep(Set **set) {

sd_bus_message *m;

while ((m = set_steal_first(*set)))

sd_bus_message_unref(m);

set_free(*set);

}

static int get_unit_list_recursive(

sd_bus *bus,

char **patterns,

UnitInfo **_unit_infos,

Set **_replies,

char ***_machines) {

_cleanup_free_ UnitInfo *unit_infos = NULL;

_cleanup_(message_set_freep) Set *replies;

sd_bus_message *reply;

int c, r;

assert(bus);

assert(_replies);

assert(_unit_infos);

assert(_machines);

replies = set_new(NULL);

if (!replies)

return log_oom();

c = get_unit_list(bus, NULL, patterns, &unit_infos, 0, &reply);

if (c < 0)

return c;

r = set_put(replies, reply);

if (r < 0) {

sd_bus_message_unref(reply);

return r;

}

if (arg_recursive) {

_cleanup_strv_free_ char **machines = NULL;

char **i;

r = sd_get_machine_names(&machines);

if (r < 0)

return r;

STRV_FOREACH(i, machines) {

_cleanup_bus_close_unref_ sd_bus *container = NULL;

int k;

r = sd_bus_open_system_machine(&container, *i);

if (r < 0) {

log_error_errno(r, "Failed to connect to container %s: %m", *i);

continue;

}

k = get_unit_list(container, *i, patterns, &unit_infos, c, &reply);

if (k < 0)

return k;

c = k;

r = set_put(replies, reply);

if (r < 0) {

sd_bus_message_unref(reply);

return r;

}

}

*_machines = machines;

machines = NULL;

} else

*_machines = NULL;

*_unit_infos = unit_infos;

unit_infos = NULL;

*_replies = replies;

replies = NULL;

return c;

}

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

_cleanup_free_ UnitInfo *unit_infos = NULL;

_cleanup_(message_set_freep) Set *replies = NULL;

_cleanup_strv_free_ char **machines = NULL;

int r;

pager_open_if_enabled();

r = get_unit_list_recursive(bus, strv_skip_first(args), &unit_infos, &replies, &machines);

if (r < 0)

return r;

qsort_safe(unit_infos, r, sizeof(UnitInfo), compare_unit_info);

return output_units_list(unit_infos, r);

}

static int get_triggered_units(

sd_bus *bus,

const char* path,

char*** ret) {

_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

int r;

r = sd_bus_get_property_strv(

bus,

"org.freedesktop.systemd1",

path,

"org.freedesktop.systemd1.Unit",

"Triggers",

&error,

ret);

if (r < 0)

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

return 0;

}

static int get_listening(

sd_bus *bus,

const char* unit_path,

char*** listening) {

_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;

const char *type, *path;

int r, n = 0;

r = sd_bus_get_property(

bus,

"org.freedesktop.systemd1",

unit_path,

"org.freedesktop.systemd1.Socket",

"Listen",

&error,

&reply,

"a(ss)");

if (r < 0) {

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

return r;

}

r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ss)");

if (r < 0)

return bus_log_parse_error(r);

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

r = strv_extend(listening, type);

if (r < 0)

return log_oom();

r = strv_extend(listening, path);

if (r < 0)

return log_oom();

n++;

}

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);

return n;

}

struct socket_info {

const char *machine;

const char* id;

char* type;

char* path;

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

char** triggered;

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

bool own_triggered;

};

static int socket_info_compare(const struct socket_info *a, const struct socket_info *b) {

int o;

assert(a);

assert(b);

if (!a->machine && b->machine)

return -1;

if (a->machine && !b->machine)

return 1;

if (a->machine && b->machine) {

o = strcasecmp(a->machine, b->machine);

if (o != 0)

return o;

}

o = strcmp(a->path, b->path);

if (o == 0)

o = strcmp(a->type, b->type);

return o;

}

static int output_sockets_list(struct socket_info *socket_infos, unsigned cs) {

struct socket_info *s;

unsigned pathlen = strlen("LISTEN"),

typelen = strlen("TYPE") * arg_show_types,

socklen = strlen("UNIT"),

servlen = strlen("ACTIVATES");

const char *on, *off;

for (s = socket_infos; s < socket_infos + cs; s++) {

unsigned tmp = 0;

char **a;

socklen = MAX(socklen, strlen(s->id));

if (arg_show_types)

typelen = MAX(typelen, strlen(s->type));

pathlen = MAX(pathlen, strlen(s->path) + (s->machine ? strlen(s->machine)+1 : 0));

STRV_FOREACH(a, s->triggered)

tmp += strlen(*a) + 2*(a != s->triggered);

servlen = MAX(servlen, tmp);

}

if (cs) {

if (!arg_no_legend)

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

pathlen, "LISTEN",

typelen + arg_show_types, typelen + arg_show_types, "TYPE ",

socklen, "UNIT",

"ACTIVATES");

for (s = socket_infos; s < socket_infos + cs; s++) {

_cleanup_free_ char *j = NULL;

const char *path;

char **a;

if (s->machine) {

j = strjoin(s->machine, ":", s->path, NULL);

if (!j)

return log_oom();

path = j;

} else

path = s->path;

if (arg_show_types)

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

pathlen, path, typelen, s->type, socklen, s->id);

else

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

pathlen, path, socklen, s->id);

STRV_FOREACH(a, s->triggered)

printf("%s %s",

a == s->triggered ? "" : ",", *a);

printf("\n");

}

on = ansi_highlight();

off = ansi_highlight_off();

if (!arg_no_legend)

printf("\n");

} else {

on = ansi_highlight_red();

off = ansi_highlight_off();

}

if (!arg_no_legend) {

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

if (!arg_all)

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

}

return 0;

}

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

_cleanup_(message_set_freep) Set *replies = NULL;

_cleanup_strv_free_ char **machines = NULL;

_cleanup_free_ UnitInfo *unit_infos = NULL;

_cleanup_free_ struct socket_info *socket_infos = NULL;

const UnitInfo *u;

struct socket_info *s;

unsigned cs = 0;

size_t size = 0;

int r = 0, n;

pager_open_if_enabled();

n = get_unit_list_recursive(bus, strv_skip_first(args), &unit_infos, &replies, &machines);

if (n < 0)

return n;

for (u = unit_infos; u < unit_infos + n; u++) {

_cleanup_strv_free_ char **listening = NULL, **triggered = NULL;

int i, c;

if (!endswith(u->id, ".socket"))

continue;

r = get_triggered_units(bus, u->unit_path, &triggered);

if (r < 0)

goto cleanup;

c = get_listening(bus, u->unit_path, &listening);

if (c < 0) {

r = c;

goto cleanup;

}

if (!GREEDY_REALLOC(socket_infos, size, cs + c)) {

r = log_oom();

goto cleanup;

}

for (i = 0; i < c; i++)

socket_infos[cs + i] = (struct socket_info) {

.machine = u->machine,

.id = u->id,

.type = listening[i*2],

.path = listening[i*2 + 1],

.triggered = triggered,

.own_triggered = i==0,

};

/* from this point on we will cleanup those socket_infos */

cs += c;

free(listening);

listening = triggered = NULL; /* avoid cleanup */

}

qsort_safe(socket_infos, cs, sizeof(struct socket_info),

(__compar_fn_t) socket_info_compare);

output_sockets_list(socket_infos, cs);

cleanup:

assert(cs == 0 || socket_infos);

for (s = socket_infos; s < socket_infos + cs; s++) {

free(s->type);

free(s->path);

if (s->own_triggered)

strv_free(s->triggered);

}

return r;

}

static int get_next_elapse(

sd_bus *bus,

const char *path,

dual_timestamp *next) {

_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

dual_timestamp t;

int r;

assert(bus);

assert(path);

assert(next);

r = sd_bus_get_property_trivial(

bus,

"org.freedesktop.systemd1",

path,

"org.freedesktop.systemd1.Timer",

"NextElapseUSecMonotonic",

&error,

't',

&t.monotonic);

if (r < 0) {

log_error("Failed to get next elapsation time: %s", bus_error_message(&error, r));

return r;

}

r = sd_bus_get_property_trivial(

bus,

"org.freedesktop.systemd1",

path,

"org.freedesktop.systemd1.Timer",

"NextElapseUSecRealtime",

&error,

't',

&t.realtime);

if (r < 0) {

log_error("Failed to get next elapsation time: %s", bus_error_message(&error, r));

return r;

}

*next = t;

return 0;

}

static int get_last_trigger(

sd_bus *bus,

const char *path,

usec_t *last) {

_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

int r;

assert(bus);

assert(path);

assert(last);

r = sd_bus_get_property_trivial(

bus,

"org.freedesktop.systemd1",

path,

"org.freedesktop.systemd1.Timer",

"LastTriggerUSec",

&error,

't',

last);

if (r < 0) {

log_error("Failed to get last trigger time: %s", bus_error_message(&error, r));

return r;

}

return 0;

}

struct timer_info {

const char* machine;

const char* id;

usec_t next_elapse;

usec_t last_trigger;

char** triggered;

};

static int timer_info_compare(const struct timer_info *a, const struct timer_info *b) {

int o;

assert(a);

assert(b);

if (!a->machine && b->machine)

return -1;

if (a->machine && !b->machine)

return 1;

if (a->machine && b->machine) {

o = strcasecmp(a->machine, b->machine);

if (o != 0)

return o;

}

if (a->next_elapse < b->next_elapse)

return -1;

if (a->next_elapse > b->next_elapse)

return 1;

return strcmp(a->id, b->id);

}

static int output_timers_list(struct timer_info *timer_infos, unsigned n) {

struct timer_info *t;

unsigned

nextlen = strlen("NEXT"),

leftlen = strlen("LEFT"),

lastlen = strlen("LAST"),

passedlen = strlen("PASSED"),

unitlen = strlen("UNIT"),

activatelen = strlen("ACTIVATES");

const char *on, *off;

assert(timer_infos || n == 0);

for (t = timer_infos; t < timer_infos + n; t++) {

unsigned ul = 0;

char **a;

if (t->next_elapse > 0) {

char tstamp[FORMAT_TIMESTAMP_MAX] = "", trel[FORMAT_TIMESTAMP_RELATIVE_MAX] = "";

format_timestamp(tstamp, sizeof(tstamp), t->next_elapse);

nextlen = MAX(nextlen, strlen(tstamp) + 1);

format_timestamp_relative(trel, sizeof(trel), t->next_elapse);

leftlen = MAX(leftlen, strlen(trel));

}

if (t->last_trigger > 0) {

char tstamp[FORMAT_TIMESTAMP_MAX] = "", trel[FORMAT_TIMESTAMP_RELATIVE_MAX] = "";

format_timestamp(tstamp, sizeof(tstamp), t->last_trigger);

lastlen = MAX(lastlen, strlen(tstamp) + 1);

format_timestamp_relative(trel, sizeof(trel), t->last_trigger);

passedlen = MAX(passedlen, strlen(trel));

}

unitlen = MAX(unitlen, strlen(t->id) + (t->machine ? strlen(t->machine)+1 : 0));

STRV_FOREACH(a, t->triggered)

ul += strlen(*a) + 2*(a != t->triggered);

activatelen = MAX(activatelen, ul);

}

if (n > 0) {

if (!arg_no_legend)

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

nextlen, "NEXT",

leftlen, "LEFT",

lastlen, "LAST",

passedlen, "PASSED",

unitlen, "UNIT",

"ACTIVATES");

for (t = timer_infos; t < timer_infos + n; t++) {

_cleanup_free_ char *j = NULL;

const char *unit;

char tstamp1[FORMAT_TIMESTAMP_MAX] = "n/a", trel1[FORMAT_TIMESTAMP_RELATIVE_MAX] = "n/a";

char tstamp2[FORMAT_TIMESTAMP_MAX] = "n/a", trel2[FORMAT_TIMESTAMP_RELATIVE_MAX] = "n/a";

char **a;

format_timestamp(tstamp1, sizeof(tstamp1), t->next_elapse);

format_timestamp_relative(trel1, sizeof(trel1), t->next_elapse);

format_timestamp(tstamp2, sizeof(tstamp2), t->last_trigger);

format_timestamp_relative(trel2, sizeof(trel2), t->last_trigger);

if (t->machine) {

j = strjoin(t->machine, ":", t->id, NULL);

if (!j)

return log_oom();

unit = j;

} else

unit = t->id;

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

nextlen, tstamp1, leftlen, trel1, lastlen, tstamp2, passedlen, trel2, unitlen, unit);

STRV_FOREACH(a, t->triggered)

printf("%s %s",

a == t->triggered ? "" : ",", *a);

printf("\n");

}

on = ansi_highlight();

off = ansi_highlight_off();

if (!arg_no_legend)

printf("\n");

} else {

on = ansi_highlight_red();

off = ansi_highlight_off();

}

if (!arg_no_legend) {

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

if (!arg_all)

printf("Pass --all to see loaded but inactive timers, too.\n");

}

return 0;

}

static usec_t calc_next_elapse(dual_timestamp *nw, dual_timestamp *next) {

usec_t next_elapse;

assert(nw);

assert(next);

if (next->monotonic != USEC_INFINITY && next->monotonic > 0) {

usec_t converted;

if (next->monotonic > nw->monotonic)

converted = nw->realtime + (next->monotonic - nw->monotonic);

else

converted = nw->realtime - (nw->monotonic - next->monotonic);

if (next->realtime != USEC_INFINITY && next->realtime > 0)

next_elapse = MIN(converted, next->realtime);

else

next_elapse = converted;

} else

next_elapse = next->realtime;

return next_elapse;

}

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

_cleanup_(message_set_freep) Set *replies = NULL;

_cleanup_strv_free_ char **machines = NULL;

_cleanup_free_ struct timer_info *timer_infos = NULL;

_cleanup_free_ UnitInfo *unit_infos = NULL;

struct timer_info *t;

const UnitInfo *u;

size_t size = 0;

int n, c = 0;

dual_timestamp nw;

int r = 0;

pager_open_if_enabled();

n = get_unit_list_recursive(bus, strv_skip_first(args), &unit_infos, &replies, &machines);

if (n < 0)

return n;

dual_timestamp_get(&nw);

for (u = unit_infos; u < unit_infos + n; u++) {

_cleanup_strv_free_ char **triggered = NULL;

dual_timestamp next = {};

usec_t m, last = 0;

if (!endswith(u->id, ".timer"))

continue;

r = get_triggered_units(bus, u->unit_path, &triggered);

if (r < 0)

goto cleanup;

r = get_next_elapse(bus, u->unit_path, &next);

if (r < 0)

goto cleanup;

get_last_trigger(bus, u->unit_path, &last);

if (!GREEDY_REALLOC(timer_infos, size, c+1)) {

r = log_oom();

goto cleanup;

}

m = calc_next_elapse(&nw, &next);

timer_infos[c++] = (struct timer_info) {

.machine = u->machine,

.id = u->id,

.next_elapse = m,

.last_trigger = last,

.triggered = triggered,

};

triggered = NULL; /* avoid cleanup */

}

qsort_safe(timer_infos, c, sizeof(struct timer_info),

(__compar_fn_t) timer_info_compare);

output_timers_list(timer_infos, c);

cleanup:

for (t = timer_infos; t < timer_infos + c; t++)

strv_free(t->triggered);

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(basename(u->path), basename(v->path));

}

static bool output_show_unit_file(const UnitFileList *u, char **patterns) {

if (!strv_isempty(patterns)) {

char **pattern;

STRV_FOREACH(pattern, patterns)

if (fnmatch(*pattern, basename(u->path), FNM_NOESCAPE) == 0)

goto next;

return false;

}

next:

if (!strv_isempty(arg_types)) {

const char *dot;

dot = strrchr(u->path, '.');

if (!dot)

return false;

if (!strv_find(arg_types, dot+1))

return false;

}

if (!strv_isempty(arg_states)) {

if (!strv_find(arg_states, unit_file_state_to_string(u->state)))

return false;

}

return true;

}

static void output_unit_file_list(const UnitFileList *units, unsigned c) {

unsigned max_id_len, id_cols, state_cols;

const UnitFileList *u;

max_id_len = strlen("UNIT FILE");

state_cols = strlen("STATE");

for (u = units; u < units + c; u++) {

max_id_len = MAX(max_id_len, strlen(basename(u->path)));

state_cols = MAX(state_cols, strlen(unit_file_state_to_string(u->state)));

}

if (!arg_full) {

unsigned basic_cols;

id_cols = MIN(max_id_len, 25u);

basic_cols = 1 + id_cols + state_cols;

if (basic_cols < (unsigned) columns())

id_cols += MIN(columns() - basic_cols, max_id_len - id_cols);

} else

id_cols = max_id_len;

if (!arg_no_legend)

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

id_cols, "UNIT FILE",

state_cols, "STATE");

for (u = units; u < units + c; u++) {

_cleanup_free_ char *e = NULL;

const char *on, *off;

const char *id;

if (u->state == UNIT_FILE_MASKED ||

u->state == UNIT_FILE_MASKED_RUNTIME ||

u->state == UNIT_FILE_DISABLED ||

u->state == UNIT_FILE_INVALID) {

on = ansi_highlight_red();

off = ansi_highlight_off();

} else if (u->state == UNIT_FILE_ENABLED) {

on = ansi_highlight_green();

off = ansi_highlight_off();

} else

on = off = "";

id = basename(u->path);

e = arg_full ? NULL : ellipsize(id, id_cols, 33);

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

id_cols, e ? e : id,

on, state_cols, unit_file_state_to_string(u->state), off);

}

if (!arg_no_legend)

printf("\n%u unit files listed.\n", c);

}

static int list_unit_files(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_ UnitFileList *units = NULL;

UnitFileList *unit;

size_t size = 0;

unsigned c = 0;

const char *state;

char *path;

int r;

pager_open_if_enabled();

if (avoid_bus()) {

Hashmap *h;

UnitFileList *u;

Iterator i;

unsigned n_units;

h = hashmap_new(&string_hash_ops);

if (!h)

return log_oom();

r = unit_file_get_list(arg_scope, arg_root, h);

if (r < 0) {

unit_file_list_free(h);

log_error_errno(r, "Failed to get unit file list: %m");

return r;

}

n_units = hashmap_size(h);

units = new(UnitFileList, n_units);

if (!units && n_units > 0) {

unit_file_list_free(h);

return log_oom();

}

HASHMAP_FOREACH(u, h, i) {

if (!output_show_unit_file(u, strv_skip_first(args)))

continue;

units[c++] = *u;

free(u);

}

assert(c <= n_units);

hashmap_free(h);

} else {

r = sd_bus_call_method(

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"ListUnitFiles",

&error,

&reply,

NULL);

if (r < 0) {

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

return r;

}

r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ss)");

if (r < 0)

return bus_log_parse_error(r);

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

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

return log_oom();

units[c] = (struct UnitFileList) {

path,

unit_file_state_from_string(state)

};

if (output_show_unit_file(&units[c], strv_skip_first(args)))

c ++;

}

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);

}

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

output_unit_file_list(units, c);

if (avoid_bus()) {

for (unit = units; unit < units + c; unit++)

free(unit->path);

}

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_VERTICAL : 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_MAX] = {

[DEPENDENCY_FORWARD] = "Requires\0"

"RequiresOverridable\0"

"Requisite\0"

"RequisiteOverridable\0"

"Wants\0"

"BindsTo\0",

[DEPENDENCY_REVERSE] = "RequiredBy\0"

"RequiredByOverridable\0"

"WantedBy\0"

"PartOf\0"

"BoundBy\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_cc(ELEMENTSOF(dependencies) == _DEPENDENCY_MAX);

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;

char **c;

int r = 0;

assert(bus);

assert(name);

assert(units);

r = strv_extend(units, name);

if (r < 0)

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) {

int state;

if (strv_contains(*units, *c)) {

if (!arg_plain) {

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

if (r < 0)

return r;

}

continue;

}

state = check_one_unit(bus, *c, "activating\0active\0reloading\0", true);

if (state > 0)

printf("%s%s%s ", ansi_highlight_green(), draw_special_char(DRAW_BLACK_CIRCLE), ansi_highlight_off());

else

printf("%s%s%s ", ansi_highlight_red(), draw_special_char(DRAW_BLACK_CIRCLE), ansi_highlight_off());

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, units, (branches << 1) | (c[1] == NULL ? 0 : 1));

if (r < 0)

return r;

}

}

if (!arg_plain)

strv_remove(*units, name);

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], MANGLE_NOGLOB);

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);

}

struct machine_info {

bool is_host;

char *name;

char *state;

char *control_group;

uint32_t n_failed_units;

uint32_t n_jobs;

usec_t timestamp;

};

static const struct bus_properties_map machine_info_property_map[] = {

{ "SystemState", "s", NULL, offsetof(struct machine_info, state) },

{ "NJobs", "u", NULL, offsetof(struct machine_info, n_jobs) },

{ "NFailedUnits", "u", NULL, offsetof(struct machine_info, n_failed_units) },

{ "ControlGroup", "s", NULL, offsetof(struct machine_info, control_group) },

{ "UserspaceTimestamp", "t", NULL, offsetof(struct machine_info, timestamp) },

{}

};

static void free_machines_list(struct machine_info *machine_infos, int n) {

int i;

if (!machine_infos)

return;

for (i = 0; i < n; i++) {

free(machine_infos[i].name);

free(machine_infos[i].state);

free(machine_infos[i].control_group);

}

free(machine_infos);

}

static int compare_machine_info(const void *a, const void *b) {

const struct machine_info *u = a, *v = b;

if (u->is_host != v->is_host)

return u->is_host > v->is_host ? -1 : 1;

return strcasecmp(u->name, v->name);

}

static int get_machine_properties(sd_bus *bus, struct machine_info *mi) {

_cleanup_bus_close_unref_ sd_bus *container = NULL;

int r;

assert(mi);

if (!bus) {

r = sd_bus_open_system_machine(&container, mi->name);

if (r < 0)

return r;

bus = container;

}

r = bus_map_all_properties(bus, "org.freedesktop.systemd1", "/org/freedesktop/systemd1", machine_info_property_map, mi);

if (r < 0)

return r;

return 0;

}

static bool output_show_machine(const char *name, char **patterns) {

char **i;

assert(name);

if (strv_isempty(patterns))

return true;

STRV_FOREACH(i, patterns)

if (fnmatch(*i, name, FNM_NOESCAPE) == 0)

return true;

return false;

}

static int get_machine_list(

sd_bus *bus,

struct machine_info **_machine_infos,

char **patterns) {

struct machine_info *machine_infos = NULL;

_cleanup_strv_free_ char **m = NULL;

_cleanup_free_ char *hn = NULL;

size_t sz = 0;

char **i;

int c = 0;

hn = gethostname_malloc();

if (!hn)

return log_oom();

if (output_show_machine(hn, patterns)) {

if (!GREEDY_REALLOC0(machine_infos, sz, c+1))

return log_oom();

machine_infos[c].is_host = true;

machine_infos[c].name = hn;

hn = NULL;

get_machine_properties(bus, &machine_infos[c]);

c++;

}

sd_get_machine_names(&m);

STRV_FOREACH(i, m) {

_cleanup_free_ char *class = NULL;

if (!output_show_machine(*i, patterns))

continue;

sd_machine_get_class(*i, &class);

if (!streq_ptr(class, "container"))

continue;

if (!GREEDY_REALLOC0(machine_infos, sz, c+1)) {

free_machines_list(machine_infos, c);

return log_oom();

}

machine_infos[c].is_host = false;

machine_infos[c].name = strdup(*i);

if (!machine_infos[c].name) {

free_machines_list(machine_infos, c);

return log_oom();

}

get_machine_properties(NULL, &machine_infos[c]);

c++;

}

*_machine_infos = machine_infos;

return c;

}

static void output_machines_list(struct machine_info *machine_infos, unsigned n) {

struct machine_info *m;

unsigned

circle_len = 0,

namelen = sizeof("NAME") - 1,

statelen = sizeof("STATE") - 1,

failedlen = sizeof("FAILED") - 1,

jobslen = sizeof("JOBS") - 1;

assert(machine_infos || n == 0);

for (m = machine_infos; m < machine_infos + n; m++) {

namelen = MAX(namelen, strlen(m->name) + (m->is_host ? sizeof(" (host)") - 1 : 0));

statelen = MAX(statelen, m->state ? strlen(m->state) : 0);

failedlen = MAX(failedlen, DECIMAL_STR_WIDTH(m->n_failed_units));

jobslen = MAX(jobslen, DECIMAL_STR_WIDTH(m->n_jobs));

if (!arg_no_legend && !streq_ptr(m->state, "running"))

circle_len = 2;

}

if (!arg_no_legend) {

if (circle_len > 0)

fputs(" ", stdout);

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

namelen, "NAME",

statelen, "STATE",

failedlen, "FAILED",

jobslen, "JOBS");

}

for (m = machine_infos; m < machine_infos + n; m++) {

const char *on_state = "", *off_state = "";

const char *on_failed = "", *off_failed = "";

bool circle = false;

if (streq_ptr(m->state, "degraded")) {

on_state = ansi_highlight_red();

off_state = ansi_highlight_off();

circle = true;

} else if (!streq_ptr(m->state, "running")) {

on_state = ansi_highlight_yellow();

off_state = ansi_highlight_off();

circle = true;

}

if (m->n_failed_units > 0) {

on_failed = ansi_highlight_red();

off_failed = ansi_highlight_off();

} else

on_failed = off_failed = "";

if (circle_len > 0)

printf("%s%s%s ", on_state, circle ? draw_special_char(DRAW_BLACK_CIRCLE) : " ", off_state);

if (m->is_host)

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

(int) (namelen - (sizeof(" (host)")-1)), strna(m->name),

on_state, statelen, strna(m->state), off_state,

on_failed, failedlen, m->n_failed_units, off_failed,

jobslen, m->n_jobs);

else

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

namelen, strna(m->name),

on_state, statelen, strna(m->state), off_state,

on_failed, failedlen, m->n_failed_units, off_failed,

jobslen, m->n_jobs);

}

if (!arg_no_legend)

printf("\n%u machines listed.\n", n);

}

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

struct machine_info *machine_infos = NULL;

int r;

assert(bus);

if (geteuid() != 0) {

log_error("Must be root.");

return -EPERM;

}

pager_open_if_enabled();

r = get_machine_list(bus, &machine_infos, strv_skip_first(args));

if (r < 0)

return r;

qsort_safe(machine_infos, r, sizeof(struct machine_info), compare_machine_info);

output_machines_list(machine_infos, r);

free_machines_list(machine_infos, r);

return 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)

return log_error_errno(r, "Failed to get default target: %m");

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;

}

static void dump_unit_file_changes(const UnitFileChange *changes, unsigned n_changes) {

unsigned i;

assert(changes || n_changes == 0);

for (i = 0; i < n_changes; i++) {

if (changes[i].type == UNIT_FILE_SYMLINK)

log_info("Created symlink from %s to %s.", changes[i].path, changes[i].source);

else

log_info("Removed symlink %s.", changes[i].path);

}

}

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

_cleanup_free_ char *unit = NULL;

UnitFileChange *changes = NULL;

unsigned n_changes = 0;

int r;

unit = unit_name_mangle_with_suffix(args[1], MANGLE_NOGLOB, ".target");

if (!unit)

return log_oom();

if (!bus || avoid_bus()) {

r = unit_file_set_default(arg_scope, arg_root, unit, true, &changes, &n_changes);

if (r < 0)

return log_error_errno(r, "Failed to set default target: %m");

if (!arg_quiet)

dump_unit_file_changes(changes, n_changes);

r = 0;

} else {

_cleanup_bus_message_unref_ sd_bus_message *reply = NULL, *m = NULL;

_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

r = sd_bus_message_new_method_call(

bus,

&m,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"SetDefaultTarget");

if (r < 0)

return bus_log_create_error(r);

r = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);

if (r < 0)

return bus_log_create_error(r);

r = sd_bus_message_append(m, "sb", unit, 1);

if (r < 0)

return bus_log_create_error(r);

r = sd_bus_call(bus, m, 0, &error, &reply);

if (r < 0) {

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

return r;

}

r = bus_deserialize_and_dump_unit_file_changes(reply, arg_quiet);

if (r < 0)

return r;

/* Try to reload if enabled */

if (!arg_no_reload)

r = daemon_reload(bus, args);

else

r = 0;

}

unit_file_changes_free(changes, n_changes);

return r;

}

struct job_info {

uint32_t id;

const char *name, *type, *state;

};

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

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 %s.%s\n", on, skipped ? "listed" : "running", off);

return;

}

pager_open_if_enabled();

id_len = strlen("JOB");

unit_len = strlen("UNIT");

type_len = strlen("TYPE");

state_len = strlen("STATE");

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;

}

if (!arg_no_legend)

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);

}

if (!arg_no_legend) {

on = ansi_highlight();

off = ansi_highlight_off();

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

}

}

static bool output_show_job(struct job_info *job, char **patterns) {

char **pattern;

assert(job);

if (strv_isempty(patterns))

return true;

STRV_FOREACH(pattern, patterns)

if (fnmatch(*pattern, job->name, FNM_NOESCAPE) == 0)

return true;

return false;

}

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;

bool skipped = false;

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) {

struct job_info job = { id, name, type, state };

if (!output_show_job(&job, strv_skip_first(args))) {

skipped = true;

continue;

}

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

return log_oom();

jobs[c++] = job;

}

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, skipped);

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;

int r = 0;

assert(args);

if (strv_length(args) <= 1)

return daemon_reload(bus, args);

STRV_FOREACH(name, args+1) {

_cleanup_bus_message_unref_ sd_bus_message *m = NULL;

uint32_t id;

int q;

q = safe_atou32(*name, &id);

if (q < 0)

return log_error_errno(q, "Failed to parse job id \"%s\": %m", *name);

q = sd_bus_message_new_method_call(

bus,

&m,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"CancelJob");

if (q < 0)

return bus_log_create_error(q);

q = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);

if (q < 0)

return bus_log_create_error(1);

q = sd_bus_message_append(m, "u", id);

if (q < 0)

return bus_log_create_error(q);

q = sd_bus_call(bus, m, 0, &error, NULL);

if (q < 0) {

log_error("Failed to cancel job %"PRIu32": %s", id, bus_error_message(&error, q));

if (r == 0)

r = q;

}

}

return r;

}

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

_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;

const char *path;

int b, r;

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

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

r = sd_bus_call_method(

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"GetUnit",

NULL,

&reply,

"s", unit);

if (r < 0)

return r;

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

if (r < 0)

return r;

r = sd_bus_get_property_trivial(

bus,

"org.freedesktop.systemd1",

path,

"org.freedesktop.systemd1.Unit",

"NeedDaemonReload",

NULL,

'b', &b);

if (r < 0)

return r;

return b;

}

static void warn_unit_file_changed(const char *name) {

log_warning("%sWarning:%s %s changed on disk. Run 'systemctl%s daemon-reload' to reload units.",

ansi_highlight_red(),

ansi_highlight_off(),

name,

arg_scope == UNIT_FILE_SYSTEM ? "" : " --user");

}

static int unit_file_find_path(LookupPaths *lp, const char *unit_name, char **unit_path) {

char **p;

assert(lp);

assert(unit_name);

assert(unit_path);

STRV_FOREACH(p, lp->unit_path) {

_cleanup_free_ char *path;

path = path_join(arg_root, *p, unit_name);

if (!path)

return log_oom();

if (access(path, F_OK) == 0) {

*unit_path = path;

path = NULL;

return 1;

}

}

return 0;

}

static int unit_find_paths(sd_bus *bus,

const char *unit_name,

bool avoid_bus_cache,

LookupPaths *lp,

char **fragment_path,

char ***dropin_paths) {

int r;

/**

assert(unit_name);

assert(fragment_path);

assert(lp);

if (!avoid_bus_cache && !unit_name_is_template(unit_name)) {

_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_free_ char *unit = NULL;

_cleanup_free_ char *path = NULL;

_cleanup_strv_free_ char **dropins = NULL;

unit = unit_dbus_path_from_name(unit_name);

if (!unit)

return log_oom();

if (need_daemon_reload(bus, unit_name) > 0)

warn_unit_file_changed(unit_name);

r = sd_bus_get_property_string(

bus,

"org.freedesktop.systemd1",

unit,

"org.freedesktop.systemd1.Unit",

"FragmentPath",

&error,

&path);

if (r < 0)

return log_error_errno(r, "Failed to get FragmentPath: %s", bus_error_message(&error, r));

r = sd_bus_get_property_strv(

bus,

"org.freedesktop.systemd1",

unit,

"org.freedesktop.systemd1.Unit",

"DropInPaths",

&error,

&dropins);

if (r < 0)

return log_error_errno(r, "Failed to get DropInPaths: %s", bus_error_message(&error, r));

r = 0;

if (!isempty(path)) {

*fragment_path = path;

path = NULL;

r = 1;

}

if (dropin_paths && !strv_isempty(dropins)) {

*dropin_paths = dropins;

dropins = NULL;

r = 1;

}

} else {

_cleanup_set_free_ Set *names;

names = set_new(NULL);

if (!names)

return -ENOMEM;

r = set_put(names, unit_name);

if (r < 0)

return r;

r = unit_file_find_path(lp, unit_name, fragment_path);

if (r < 0)

return r;

if (r == 0) {

_cleanup_free_ char *template;

template = unit_name_template(unit_name);

if (!template)

return log_oom();

if (!streq(template, unit_name)) {

r = unit_file_find_path(lp, template, fragment_path);

if (r < 0)

return r;

}

}

if (dropin_paths)

r = unit_file_find_dropin_paths(lp->unit_path, NULL, names, dropin_paths);

}

return r;

}

static int check_one_unit(sd_bus *bus, const char *name, const char *good_states, bool quiet) {

_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;

_cleanup_free_ char *n = NULL, *state = NULL;

const char *path;

int r;

assert(name);

n = unit_name_mangle(name, MANGLE_NOGLOB);

if (!n)

return log_oom();

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

r = sd_bus_call_method(

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"GetUnit",

NULL,

&reply,

"s", n);

if (r < 0) {

if (!quiet)

puts("unknown");

return 0;

}

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

if (r < 0)

return bus_log_parse_error(r);

r = sd_bus_get_property_string(

bus,

"org.freedesktop.systemd1",

path,

"org.freedesktop.systemd1.Unit",

"ActiveState",

NULL,

&state);

if (r < 0) {

if (!quiet)

puts("unknown");

return 0;

}

if (!quiet)

puts(state);

return nulstr_contains(good_states, state);

}

static int check_triggering_units(

sd_bus *bus,

const char *name) {

_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_free_ char *path = NULL, *n = NULL, *state = NULL;

_cleanup_strv_free_ char **triggered_by = NULL;

bool print_warning_label = true;

char **i;

int r;

n = unit_name_mangle(name, MANGLE_NOGLOB);

if (!n)

return log_oom();

path = unit_dbus_path_from_name(n);

if (!path)

return log_oom();

r = sd_bus_get_property_string(

bus,

"org.freedesktop.systemd1",

path,

"org.freedesktop.systemd1.Unit",

"LoadState",

&error,

&state);

if (r < 0) {

log_error("Failed to get load state of %s: %s", n, bus_error_message(&error, r));

return r;

}

if (streq(state, "masked"))

return 0;

r = sd_bus_get_property_strv(

bus,

"org.freedesktop.systemd1",

path,

"org.freedesktop.systemd1.Unit",

"TriggeredBy",

&error,

&triggered_by);

if (r < 0) {

log_error("Failed to get triggered by array of %s: %s", n, bus_error_message(&error, r));

return r;

}

STRV_FOREACH(i, triggered_by) {

r = check_one_unit(bus, *i, "active\0reloading\0", true);

if (r < 0)

return log_error_errno(r, "Failed to check unit: %m");

if (r == 0)

continue;

if (print_warning_label) {

log_warning("Warning: Stopping %s, but it can still be activated by:", n);

print_warning_label = false;

}

log_warning(" %s", *i);

}

return 0;

}

static const struct {

const char *verb;

const char *method;

} unit_actions[] = {

{ "start", "StartUnit" },

{ "stop", "StopUnit" },

{ "condstop", "StopUnit" },

{ "reload", "ReloadUnit" },

{ "restart", "RestartUnit" },

{ "try-restart", "TryRestartUnit" },

{ "condrestart", "TryRestartUnit" },

{ "reload-or-restart", "ReloadOrRestartUnit" },

{ "reload-or-try-restart", "ReloadOrTryRestartUnit" },

{ "condreload", "ReloadOrTryRestartUnit" },

{ "force-reload", "ReloadOrTryRestartUnit" }

};

static const char *verb_to_method(const char *verb) {

uint i;

for (i = 0; i < ELEMENTSOF(unit_actions); i++)

if (streq_ptr(unit_actions[i].verb, verb))

return unit_actions[i].method;

return "StartUnit";

}

static const char *method_to_verb(const char *method) {

uint i;

for (i = 0; i < ELEMENTSOF(unit_actions); i++)

if (streq_ptr(unit_actions[i].method, method))

return unit_actions[i].verb;

return "n/a";

}

static int start_unit_one(

sd_bus *bus,

const char *method,

const char *name,

const char *mode,

sd_bus_error *error,

BusWaitForJobs *w) {

_cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;

const char *path;

int r;

assert(method);

assert(name);

assert(mode);

assert(error);

log_debug("Calling manager for %s on %s, %s", method, name, mode);

r = sd_bus_message_new_method_call(

bus,

&m,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

method);

if (r < 0)

return bus_log_create_error(r);

r = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);

if (r < 0)

return bus_log_create_error(r);

r = sd_bus_message_append(m, "ss", name, mode);

if (r < 0)

return bus_log_create_error(r);

r = sd_bus_call(bus, m, 0, error, &reply);

if (r < 0) {

const char *verb;

if (r == -ENOENT && arg_action != ACTION_SYSTEMCTL)

/* There's always a fallback possible for

return -EADDRNOTAVAIL;

verb = method_to_verb(method);

log_error("Failed to %s %s: %s", verb, name, bus_error_message(error, r));

return r;

}

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

if (r < 0)

return bus_log_parse_error(r);

if (need_daemon_reload(bus, name) > 0)

warn_unit_file_changed(name);

if (w) {

log_debug("Adding %s to the set", path);

r = bus_wait_for_jobs_add(w, path);

if (r < 0)

return log_oom();

}

return 0;

}

static int expand_names(sd_bus *bus, char **names, const char* suffix, char ***ret) {

_cleanup_strv_free_ char **mangled = NULL, **globs = NULL;

char **name;

int r = 0, i;

STRV_FOREACH(name, names) {

char *t;

if (suffix)

t = unit_name_mangle_with_suffix(*name, MANGLE_GLOB, suffix);

else

t = unit_name_mangle(*name, MANGLE_GLOB);

if (!t)

return log_oom();

if (string_is_glob(t))

r = strv_consume(&globs, t);

else

r = strv_consume(&mangled, t);

if (r < 0)

return log_oom();

}

/* Query the manager only if any of the names are a glob, since

if (!strv_isempty(globs)) {

_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;

_cleanup_free_ UnitInfo *unit_infos = NULL;

if (!bus)

return log_error_errno(ENOTSUP, "Unit name globbing without bus is not implemented.");

r = get_unit_list(bus, NULL, globs, &unit_infos, 0, &reply);

if (r < 0)

return r;

for (i = 0; i < r; i++)

if (strv_extend(&mangled, unit_infos[i].id) < 0)

return log_oom();

}

*ret = mangled;

mangled = NULL; /* do not free */

return 0;

}

static const struct {

const char *target;

const char *verb;

const char *mode;

} action_table[_ACTION_MAX] = {

[ACTION_HALT] = { SPECIAL_HALT_TARGET, "halt", "replace-irreversibly" },

[ACTION_POWEROFF] = { SPECIAL_POWEROFF_TARGET, "poweroff", "replace-irreversibly" },

[ACTION_REBOOT] = { SPECIAL_REBOOT_TARGET, "reboot", "replace-irreversibly" },

[ACTION_KEXEC] = { SPECIAL_KEXEC_TARGET, "kexec", "replace-irreversibly" },

[ACTION_RUNLEVEL2] = { SPECIAL_RUNLEVEL2_TARGET, NULL, "isolate" },

[ACTION_RUNLEVEL3] = { SPECIAL_RUNLEVEL3_TARGET, NULL, "isolate" },

[ACTION_RUNLEVEL4] = { SPECIAL_RUNLEVEL4_TARGET, NULL, "isolate" },

[ACTION_RUNLEVEL5] = { SPECIAL_RUNLEVEL5_TARGET, NULL, "isolate" },

[ACTION_RESCUE] = { SPECIAL_RESCUE_TARGET, "rescue", "isolate" },

[ACTION_EMERGENCY] = { SPECIAL_EMERGENCY_TARGET, "emergency", "isolate" },

[ACTION_DEFAULT] = { SPECIAL_DEFAULT_TARGET, "default", "isolate" },

[ACTION_EXIT] = { SPECIAL_EXIT_TARGET, "exit", "replace-irreversibly" },

[ACTION_SUSPEND] = { SPECIAL_SUSPEND_TARGET, "suspend", "replace-irreversibly" },

[ACTION_HIBERNATE] = { SPECIAL_HIBERNATE_TARGET, "hibernate", "replace-irreversibly" },

[ACTION_HYBRID_SLEEP] = { SPECIAL_HYBRID_SLEEP_TARGET, "hybrid-sleep", "replace-irreversibly" },

};

static enum action verb_to_action(const char *verb) {

enum action i;

for (i = _ACTION_INVALID; i < _ACTION_MAX; i++)

if (streq_ptr(action_table[i].verb, verb))

return i;

return _ACTION_INVALID;

}

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

_cleanup_(bus_wait_for_jobs_freep) BusWaitForJobs *w = NULL;

const char *method, *mode, *one_name, *suffix = NULL;

_cleanup_strv_free_ char **names = NULL;

char **name;

int r = 0;

assert(bus);

ask_password_agent_open_if_enabled();

if (arg_action == ACTION_SYSTEMCTL) {

enum action action;

method = verb_to_method(args[0]);

action = verb_to_action(args[0]);

if (streq(args[0], "isolate")) {

mode = "isolate";

suffix = ".target";

} else

mode = action_table[action].mode ?: arg_job_mode;

one_name = action_table[action].target;

} else {

assert(arg_action < ELEMENTSOF(action_table));

assert(action_table[arg_action].target);

method = "StartUnit";

mode = action_table[arg_action].mode;

one_name = action_table[arg_action].target;

}

if (one_name)

names = strv_new(one_name, NULL);

else {

r = expand_names(bus, args + 1, suffix, &names);

if (r < 0)

log_error_errno(r, "Failed to expand names: %m");

}

if (!arg_no_block) {

r = bus_wait_for_jobs_new(bus, &w);

if (r < 0)

return log_error_errno(r, "Could not watch jobs: %m");

}

STRV_FOREACH(name, names) {

_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;

int q;

q = start_unit_one(bus, method, *name, mode, &error, w);

if (r >= 0 && q < 0)

r = translate_bus_error_to_exit_status(q, &error);

}

if (!arg_no_block) {

int q;

q = bus_wait_for_jobs(w, arg_quiet);

if (q < 0)

return q;

/* When stopping units, warn if they can still be triggered by

if (!arg_quiet && streq(method, "StopUnit"))

STRV_FOREACH(name, names)

check_triggering_units(bus, *name);

}

return r;

}

static int reboot_with_logind(sd_bus *bus, enum action a) {

#ifdef HAVE_LOGIND

_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;