#include <sys/reboot.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 <dbus/dbus.h>

#include <systemd/sd-daemon.h>

#include <systemd/sd-shutdown.h>

#include <systemd/sd-login.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 "dbus-common.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 "bus-errors.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 "path-util.h"

#include "socket-util.h"

#include "fileio.h"

static const char *arg_type = NULL;

static const char *arg_load_state = NULL;

static char **arg_property = NULL;

static bool arg_all = false;

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

static bool arg_dry = false;

static bool arg_quiet = false;

static bool arg_full = false;

static int arg_force = 0;

static bool arg_ask_password = true;

static bool arg_failed = false;

static bool arg_runtime = false;

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 enum transport {

TRANSPORT_NORMAL,

TRANSPORT_SSH,

TRANSPORT_POLKIT

} arg_transport = TRANSPORT_NORMAL;

static const char *arg_host = NULL;

static unsigned arg_lines = 10;

static OutputMode arg_output = OUTPUT_SHORT;

static bool private_bus = false;

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

static void halt_now(enum action a);

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;

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;

polkit_agent_open();

}

#endif

static const char *ansi_highlight(bool b) {

if (!on_tty())

return "";

return b ? ANSI_HIGHLIGHT_ON : ANSI_HIGHLIGHT_OFF;

}

static const char *ansi_highlight_red(bool b) {

if (!on_tty())

return "";

return b ? ANSI_HIGHLIGHT_RED_ON : ANSI_HIGHLIGHT_OFF;

}

static const char *ansi_highlight_green(bool b) {

if (!on_tty())

return "";

return b ? ANSI_HIGHLIGHT_GREEN_ON : ANSI_HIGHLIGHT_OFF;

}

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

assert(error);

if (!dbus_error_is_set(error))

return r;

if (dbus_error_has_name(error, DBUS_ERROR_ACCESS_DENIED) ||

dbus_error_has_name(error, BUS_ERROR_ONLY_BY_DEPENDENCY) ||

dbus_error_has_name(error, BUS_ERROR_NO_ISOLATION) ||

dbus_error_has_name(error, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE))

return EXIT_NOPERMISSION;

if (dbus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT))

return EXIT_NOTINSTALLED;

if (dbus_error_has_name(error, BUS_ERROR_JOB_TYPE_NOT_APPLICABLE) ||

dbus_error_has_name(error, BUS_ERROR_NOT_SUPPORTED))

return EXIT_NOTIMPLEMENTED;

if (dbus_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);

return;

}

}

if (!table[a])

return;

utmp_wall(table[a], 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 char *d1, *d2;

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

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

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

if (d1 && d2) {

int r;

r = strcasecmp(d1, d2);

if (r != 0)

return r;

}

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

}

static bool output_show_unit(const struct unit_info *u) {

const char *dot;

if (arg_failed)

return streq(u->active_state, "failed");

return (!arg_type || ((dot = strrchr(u->id, '.')) &&

streq(dot+1, arg_type))) &&

(!arg_load_state || streq(u->load_state, arg_load_state)) &&

(arg_all || !(streq(u->active_state, "inactive")

|| u->following[0]) || u->job_id > 0);

}

static void output_units_list(const struct unit_info *unit_infos, unsigned c) {

unsigned id_len, max_id_len, active_len, sub_len, job_len, desc_len, n_shown = 0;

const struct unit_info *u;

int job_count = 0;

max_id_len = sizeof("UNIT")-1;

active_len = sizeof("ACTIVE")-1;

sub_len = sizeof("SUB")-1;

job_len = sizeof("JOB")-1;

desc_len = 0;

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

if (!output_show_unit(u))

continue;

max_id_len = MAX(max_id_len, strlen(u->id));

active_len = MAX(active_len, strlen(u->active_state));

sub_len = MAX(sub_len, strlen(u->sub_state));

if (u->job_id != 0) {

job_len = MAX(job_len, strlen(u->job_type));

job_count++;

}

}

if (!arg_full) {

unsigned basic_len;

id_len = MIN(max_id_len, 25);

basic_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, 25);

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

char _cleanup_free_ *e = NULL;

const char *on_loaded, *off_loaded;

const char *on_active, *off_active;

if (!output_show_unit(u))

continue;

if (!n_shown && !arg_no_legend) {

printf("%-*s %-6s %-*s %-*s ", id_len, "UNIT", "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 (streq(u->load_state, "error")) {

on_loaded = ansi_highlight_red(true);

off_loaded = ansi_highlight_red(false);

} else

on_loaded = off_loaded = "";

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

on_active = ansi_highlight_red(true);

off_active = ansi_highlight_red(false);

} else

on_active = off_active = "";

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

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

id_len, e ? e : u->id,

on_loaded, u->load_state, off_loaded,

on_active, active_len, u->active_state,

sub_len, u->sub_state, off_active,

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

if (!arg_full && arg_no_pager)

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

else

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

}

if (!arg_no_legend) {

const char *on, *off;

if (n_shown) {

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

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

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

if (job_count)

printf("JOB = Pending job for the unit.\n");

puts("");

on = ansi_highlight(true);

off = ansi_highlight(false);

} else {

on = ansi_highlight_red(true);

off = ansi_highlight_red(false);

}

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

}

}

static int get_unit_list(DBusConnection *bus, DBusMessage **reply,

struct unit_info **unit_infos, unsigned *c) {

DBusMessageIter iter, sub;

unsigned n_units = 0;

int r;

assert(bus);

assert(unit_infos);

assert(c);

r = bus_method_call_with_reply(

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"ListUnits",

reply,

NULL,

DBUS_TYPE_INVALID);

if (r < 0)

return r;

if (!dbus_message_iter_init(*reply, &iter) ||

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||

dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {

log_error("Failed to parse reply.");

return -EIO;

}

dbus_message_iter_recurse(&iter, &sub);

while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {

struct unit_info *u;

if (*c >= n_units) {

struct unit_info *w;

n_units = MAX(2 * *c, 16);

w = realloc(*unit_infos, sizeof(struct unit_info) * n_units);

if (!w)

return log_oom();

*unit_infos = w;

}

u = *unit_infos + *c;

bus_parse_unit_info(&sub, u);

dbus_message_iter_next(&sub);

(*c)++;

}

if (*c > 0)

qsort(*unit_infos, *c, sizeof(struct unit_info), compare_unit_info);

return 0;

}

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

_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;

_cleanup_free_ struct unit_info *unit_infos = NULL;

unsigned c = 0;

int r;

pager_open_if_enabled();

r = get_unit_list(bus, &reply, &unit_infos, &c);

if (r < 0)

return r;

if (c > 0)

output_units_list(unit_infos, c);

return 0;

}

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

}

static bool output_show_unit_file(const UnitFileList *u) {

const char *dot;

return !arg_type || ((dot = strrchr(u->path, '.')) && streq(dot+1, arg_type));

}

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

unsigned max_id_len, id_cols, state_cols, n_shown = 0;

const UnitFileList *u;

max_id_len = sizeof("UNIT FILE")-1;

state_cols = sizeof("STATE")-1;

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

if (!output_show_unit_file(u))

continue;

max_id_len = MAX(max_id_len, strlen(path_get_file_name(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, 25);

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

char _cleanup_free_ *e = NULL;

const char *on, *off;

const char *id;

if (!output_show_unit_file(u))

continue;

n_shown++;

if (u->state == UNIT_FILE_MASKED ||

u->state == UNIT_FILE_MASKED_RUNTIME ||

u->state == UNIT_FILE_DISABLED ||

u->state == UNIT_FILE_INVALID) {

on = ansi_highlight_red(true);

off = ansi_highlight_red(false);

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

on = ansi_highlight_green(true);

off = ansi_highlight_green(false);

} else

on = off = "";

id = path_get_file_name(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", n_shown);

}

static int list_unit_files(DBusConnection *bus, char **args) {

_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;

_cleanup_free_ UnitFileList *units = NULL;

DBusMessageIter iter, sub, sub2;

unsigned c = 0, n_units = 0;

int r;

pager_open_if_enabled();

if (avoid_bus()) {

Hashmap *h;

UnitFileList *u;

Iterator i;

h = hashmap_new(string_hash_func, string_compare_func);

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("Failed to get unit file list: %s", strerror(-r));

return r;

}

n_units = hashmap_size(h);

units = new(UnitFileList, n_units);

if (!units) {

unit_file_list_free(h);

return log_oom();

}

HASHMAP_FOREACH(u, h, i) {

memcpy(units + c++, u, sizeof(UnitFileList));

free(u);

}

hashmap_free(h);

} else {

r = bus_method_call_with_reply(

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"ListUnitFiles",

&reply,

NULL,

DBUS_TYPE_INVALID);

if (r < 0)

return r;

if (!dbus_message_iter_init(reply, &iter) ||

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||

dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {

log_error("Failed to parse reply.");

return -EIO;

}

dbus_message_iter_recurse(&iter, &sub);

while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {

UnitFileList *u;

const char *state;

assert(dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT);

if (c >= n_units) {

UnitFileList *w;

n_units = MAX(2*c, 16);

w = realloc(units, sizeof(struct UnitFileList) * n_units);

if (!w)

return log_oom();

units = w;

}

u = units + c;

dbus_message_iter_recurse(&sub, &sub2);

if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->path, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &state, false) < 0) {

log_error("Failed to parse reply.");

return -EIO;

}

u->state = unit_file_state_from_string(state);

dbus_message_iter_next(&sub);

c++;

}

}

if (c > 0) {

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

output_unit_file_list(units, c);

}

return 0;

}

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

int i;

_cleanup_free_ char *n = NULL;

size_t len = 0;

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

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(DBusConnection *bus, const char *name, char ***deps) {

static const char dependencies[] =

"Requires\0"

"RequiresOverridable\0"

"Requisite\0"

"RequisiteOverridable\0"

"Wants\0";

_cleanup_free_ char *path;

const char *interface = "org.freedesktop.systemd1.Unit";

_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;

DBusMessageIter iter, sub, sub2, sub3;

int r = 0;

char **ret = NULL;

assert(bus);

assert(name);

assert(deps);

path = unit_dbus_path_from_name(name);

if (path == NULL) {

r = -EINVAL;

goto finish;

}

r = bus_method_call_with_reply(

bus,

"org.freedesktop.systemd1",

path,

"org.freedesktop.DBus.Properties",

"GetAll",

&reply,

NULL,

DBUS_TYPE_STRING, &interface,

DBUS_TYPE_INVALID);

if (r < 0)

goto finish;

if (!dbus_message_iter_init(reply, &iter) ||

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||

dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY) {

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

dbus_message_iter_recurse(&iter, &sub);

while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {

const char *prop;

assert(dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_DICT_ENTRY);

dbus_message_iter_recurse(&sub, &sub2);

if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &prop, true) < 0) {

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_VARIANT) {

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

dbus_message_iter_recurse(&sub2, &sub3);

dbus_message_iter_next(&sub);

if (!nulstr_contains(dependencies, prop))

continue;

if (dbus_message_iter_get_arg_type(&sub3) == DBUS_TYPE_ARRAY) {

if (dbus_message_iter_get_element_type(&sub3) == DBUS_TYPE_STRING) {

DBusMessageIter sub4;

dbus_message_iter_recurse(&sub3, &sub4);

while (dbus_message_iter_get_arg_type(&sub4) != DBUS_TYPE_INVALID) {

const char *s;

assert(dbus_message_iter_get_arg_type(&sub4) == DBUS_TYPE_STRING);

dbus_message_iter_get_basic(&sub4, &s);

r = strv_extend(&ret, s);

if (r < 0) {

log_oom();

goto finish;

}

dbus_message_iter_next(&sub4);

}

}

}

}

finish:

if (r < 0)

strv_free(ret);

else

*deps = ret;

return r;

}

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(DBusConnection *bus, const char *name, int level, char **units, unsigned int branches) {

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

char **c;

int r = 0;

u = strv_append(units, name);

if (!u)

return log_oom();

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

if (r < 0)

return r;

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

STRV_FOREACH(c, deps) {

if (strv_contains(u, *c)) {

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;

}

}

return 0;

}

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

_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, NULL, 0);

}

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

_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;

DBusMessageIter iter, sub, sub2;

unsigned k = 0;

int r;

pager_open_if_enabled();

r = bus_method_call_with_reply(

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"ListJobs",

&reply,

NULL,

DBUS_TYPE_INVALID);

if (r < 0)

return r;

if (!dbus_message_iter_init(reply, &iter) ||

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||

dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {

log_error("Failed to parse reply.");

return -EIO;

}

dbus_message_iter_recurse(&iter, &sub);

if (on_tty())

printf("%4s %-25s %-15s %-7s\n", "JOB", "UNIT", "TYPE", "STATE");

while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {

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

uint32_t id;

char _cleanup_free_ *e = NULL;

if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {

log_error("Failed to parse reply.");

return -EIO;

}

dbus_message_iter_recurse(&sub, &sub2);

if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &id, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &state, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &job_path, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_path, false) < 0) {

log_error("Failed to parse reply.");

return -EIO;

}

e = arg_full ? NULL : ellipsize(name, 25, 33);

printf("%4u %-25s %-15s %-7s\n", id, e ? e : name, type, state);

k++;

dbus_message_iter_next(&sub);

}

if (on_tty())

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

return 0;

}

static int load_unit(DBusConnection *bus, char **args) {

char **name;

assert(args);

STRV_FOREACH(name, args+1) {

_cleanup_free_ char *n = NULL;

int r;

n = unit_name_mangle(*name);

if (!n)

return log_oom();

r = bus_method_call_with_reply(

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"LoadUnit",

NULL,

NULL,

DBUS_TYPE_STRING, &n,

DBUS_TYPE_INVALID);

if (r < 0)

return r;

}

return 0;

}

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

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", strerror(-r));

return r;

}

r = bus_method_call_with_reply(

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"CancelJob",

NULL,

NULL,

DBUS_TYPE_UINT32, &id,

DBUS_TYPE_INVALID);

if (r < 0)

return r;

}

return 0;

}

static bool need_daemon_reload(DBusConnection *bus, const char *unit) {

_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;

dbus_bool_t b = FALSE;

DBusMessageIter iter, sub;

const char

*interface = "org.freedesktop.systemd1.Unit",

*property = "NeedDaemonReload",

*path;

_cleanup_free_ char *n = NULL;

int r;

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

n = unit_name_mangle(unit);

if (!n)

return log_oom();

r = bus_method_call_with_reply(

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"GetUnit",

&reply,

NULL,

DBUS_TYPE_STRING, &n,

DBUS_TYPE_INVALID);

if (r < 0)

return r;

if (!dbus_message_get_args(reply, NULL,

DBUS_TYPE_OBJECT_PATH, &path,

DBUS_TYPE_INVALID))

return -EIO;

dbus_message_unref(reply);

reply = NULL;

r = bus_method_call_with_reply(

bus,

"org.freedesktop.systemd1",

path,

"org.freedesktop.DBus.Properties",

"Get",

&reply,

NULL,

DBUS_TYPE_STRING, &interface,

DBUS_TYPE_STRING, &property,

DBUS_TYPE_INVALID);

if (r < 0)

return r;

if (!dbus_message_iter_init(reply, &iter) ||

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)

return -EIO;

dbus_message_iter_recurse(&iter, &sub);

if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)

return -EIO;

dbus_message_iter_get_basic(&sub, &b);

return b;

}

typedef struct WaitData {

Set *set;

char *name;

char *result;

} WaitData;

static DBusHandlerResult wait_filter(DBusConnection *connection, DBusMessage *message, void *data) {

DBusError _cleanup_dbus_error_free_ error;

WaitData *d = data;

dbus_error_init(&error);

assert(connection);

assert(message);

assert(d);

log_debug("Got D-Bus request: %s.%s() on %s",

dbus_message_get_interface(message),

dbus_message_get_member(message),

dbus_message_get_path(message));

if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) {

log_error("Warning! D-Bus connection terminated.");

dbus_connection_close(connection);

} else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobRemoved")) {

uint32_t id;

const char *path, *result, *unit;

if (dbus_message_get_args(message, &error,

DBUS_TYPE_UINT32, &id,

DBUS_TYPE_OBJECT_PATH, &path,

DBUS_TYPE_STRING, &unit,

DBUS_TYPE_STRING, &result,

DBUS_TYPE_INVALID)) {

free(set_remove(d->set, (char*) path));

if (!isempty(result))

d->result = strdup(result);

if (!isempty(unit))

d->name = strdup(unit);

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

}

#ifndef LEGACY

dbus_error_free(&error);

if (dbus_message_get_args(message, &error,

DBUS_TYPE_UINT32, &id,

DBUS_TYPE_OBJECT_PATH, &path,

DBUS_TYPE_STRING, &result,

DBUS_TYPE_INVALID)) {

/* Compatibility with older systemd versions <

free(set_remove(d->set, (char*) path));

if (*result)

d->result = strdup(result);

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

}

#endif

log_error("Failed to parse message: %s", bus_error_message(&error));

}

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

}

static int enable_wait_for_jobs(DBusConnection *bus) {

DBusError error;

assert(bus);

if (private_bus)

return 0;

dbus_error_init(&error);

dbus_bus_add_match(bus,

"type='signal',"

"sender='org.freedesktop.systemd1',"

"interface='org.freedesktop.systemd1.Manager',"

"member='JobRemoved',"

"path='/org/freedesktop/systemd1'",

&error);

if (dbus_error_is_set(&error)) {

log_error("Failed to add match: %s", bus_error_message(&error));

dbus_error_free(&error);

return -EIO;

}

/* This is slightly dirty, since we don't undo the match registrations. */

return 0;

}

static int wait_for_jobs(DBusConnection *bus, Set *s) {

int r = 0;

WaitData d;

assert(bus);

assert(s);

zero(d);

d.set = s;

if (!dbus_connection_add_filter(bus, wait_filter, &d, NULL))

return log_oom();

while (!set_isempty(s)) {

if (!dbus_connection_read_write_dispatch(bus, -1)) {

log_error("Disconnected from bus.");

return -ECONNREFUSED;

}

if (!d.result)

goto free_name;

if (!arg_quiet) {

if (streq(d.result, "timeout"))

log_error("Job for %s timed out.", strna(d.name));

else if (streq(d.result, "canceled"))

log_error("Job for %s canceled.", strna(d.name));

else if (streq(d.result, "dependency"))

log_error("A dependency job for %s failed. See 'journalctl -xn' for details.", strna(d.name));

else if (!streq(d.result, "done") && !streq(d.result, "skipped"))

log_error("Job for %s failed. See 'systemctl status %s' and 'journalctl -xn' for details.", strna(d.name), strna(d.name));

}

if (streq_ptr(d.result, "timeout"))

r = -ETIME;

else if (streq_ptr(d.result, "canceled"))

r = -ECANCELED;

else if (!streq_ptr(d.result, "done") && !streq_ptr(d.result, "skipped"))

r = -EIO;

free(d.result);

d.result = NULL;

free_name:

free(d.name);

d.name = NULL;

}

dbus_connection_remove_filter(bus, wait_filter, &d);

return r;

}

static int check_one_unit(DBusConnection *bus, const char *name, char **check_states, bool quiet) {

_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;

_cleanup_free_ char *n = NULL;

DBusMessageIter iter, sub;

const char

*interface = "org.freedesktop.systemd1.Unit",

*property = "ActiveState";

const char *state, *path;

DBusError error;

int r;

assert(name);

dbus_error_init(&error);

n = unit_name_mangle(name);

if (!n)

return log_oom();

r = bus_method_call_with_reply (

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"GetUnit",

&reply,

&error,

DBUS_TYPE_STRING, &n,

DBUS_TYPE_INVALID);

if (r < 0) {

dbus_error_free(&error);

if (!quiet)

puts("unknown");

return 0;

}

if (!dbus_message_get_args(reply, NULL,

DBUS_TYPE_OBJECT_PATH, &path,

DBUS_TYPE_INVALID)) {

log_error("Failed to parse reply.");

return -EIO;

}

dbus_message_unref(reply);

reply = NULL;

r = bus_method_call_with_reply(

bus,

"org.freedesktop.systemd1",

path,

"org.freedesktop.DBus.Properties",

"Get",

&reply,

NULL,

DBUS_TYPE_STRING, &interface,

DBUS_TYPE_STRING, &property,

DBUS_TYPE_INVALID);

if (r < 0) {

if (!quiet)

puts("unknown");

return 0;

}

if (!dbus_message_iter_init(reply, &iter) ||

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {

log_error("Failed to parse reply.");

return r;

}

dbus_message_iter_recurse(&iter, &sub);

if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) {

log_error("Failed to parse reply.");

return r;

}

dbus_message_iter_get_basic(&sub, &state);

if (!quiet)

puts(state);

return strv_find(check_states, state) ? 1 : 0;

}

static void check_triggering_units(

DBusConnection *bus,

const char *unit_name) {

_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;

DBusMessageIter iter, sub;

const char *interface = "org.freedesktop.systemd1.Unit",

*load_state_property = "LoadState",

*triggered_by_property = "TriggeredBy",

*state;

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

bool print_warning_label = true;

int r;

n = unit_name_mangle(unit_name);

if (!n) {

log_oom();

return;

}

unit_path = unit_dbus_path_from_name(n);

if (!unit_path) {

log_oom();

return;

}

r = bus_method_call_with_reply(

bus,

"org.freedesktop.systemd1",

unit_path,

"org.freedesktop.DBus.Properties",

"Get",

&reply,

NULL,

DBUS_TYPE_STRING, &interface,

DBUS_TYPE_STRING, &load_state_property,

DBUS_TYPE_INVALID);

if (r < 0)

return;

if (!dbus_message_iter_init(reply, &iter) ||

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {

log_error("Failed to parse reply.");

return;

}

dbus_message_iter_recurse(&iter, &sub);

if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) {

log_error("Failed to parse reply.");

return;

}

dbus_message_iter_get_basic(&sub, &state);

if (streq(state, "masked"))

return;

dbus_message_unref(reply);

reply = NULL;

r = bus_method_call_with_reply(

bus,

"org.freedesktop.systemd1",

unit_path,

"org.freedesktop.DBus.Properties",

"Get",

&reply,

NULL,

DBUS_TYPE_STRING, &interface,

DBUS_TYPE_STRING, &triggered_by_property,

DBUS_TYPE_INVALID);

if (r < 0)

return;

if (!dbus_message_iter_init(reply, &iter) ||

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {

log_error("Failed to parse reply.");

return;

}

dbus_message_iter_recurse(&iter, &sub);

dbus_message_iter_recurse(&sub, &iter);

sub = iter;

while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {

const char * const check_states[] = {

"active",

"reloading",

NULL

};

const char *service_trigger;

if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) {

log_error("Failed to parse reply.");

return;

}

dbus_message_iter_get_basic(&sub, &service_trigger);

r = check_one_unit(bus, service_trigger, (char**) check_states, true);

if (r < 0)

return;

if (r > 0) {

if (print_warning_label) {

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

print_warning_label = false;

}

log_warning(" %s", service_trigger);

}

dbus_message_iter_next(&sub);

}

}

static int start_unit_one(

DBusConnection *bus,

const char *method,

const char *name,

const char *mode,

DBusError *error,

Set *s) {

_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;

_cleanup_free_ char *n;

const char *path;

int r;

assert(method);

assert(name);

assert(mode);

assert(error);

n = unit_name_mangle(name);

if (!n)

return log_oom();

r = bus_method_call_with_reply(

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

method,

&reply,

error,

DBUS_TYPE_STRING, &n,

DBUS_TYPE_STRING, &mode,

DBUS_TYPE_INVALID);

if (r) {

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

/* There's always a fallback possible for

r = -EADDRNOTAVAIL;

else

log_error("Failed to issue method call: %s", bus_error_message(error));

return r;

}

if (!dbus_message_get_args(reply, error,

DBUS_TYPE_OBJECT_PATH, &path,

DBUS_TYPE_INVALID)) {

log_error("Failed to parse reply: %s", bus_error_message(error));

return -EIO;

}

if (need_daemon_reload(bus, n))

log_warning("Warning: Unit file of %s changed on disk, 'systemctl %s daemon-reload' recommended.",

n, arg_scope == UNIT_FILE_SYSTEM ? "--system" : "--user");

if (s) {

char *p;

p = strdup(path);

if (!p)

return log_oom();

r = set_put(s, p);

if (r < 0) {

free(p);

log_error("Failed to add path to set.");

return r;

}

}

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 (action_table[i].verb && streq(verb, action_table[i].verb))

return i;

return ACTION_INVALID;

}

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

int r, ret = 0;

const char *method, *mode, *one_name;

Set _cleanup_set_free_free_ *s = NULL;

DBusError _cleanup_dbus_error_free_ error;

char **name;

dbus_error_init(&error);

assert(bus);

ask_password_agent_open_if_enabled();

if (arg_action == ACTION_SYSTEMCTL) {

enum action action;

method =

streq(args[0], "stop") ||

streq(args[0], "condstop") ? "StopUnit" :

streq(args[0], "reload") ? "ReloadUnit" :

streq(args[0], "restart") ? "RestartUnit" :

streq(args[0], "try-restart") ||

streq(args[0], "condrestart") ? "TryRestartUnit" :

streq(args[0], "reload-or-restart") ? "ReloadOrRestartUnit" :

streq(args[0], "reload-or-try-restart") ||

streq(args[0], "condreload") ||

streq(args[0], "force-reload") ? "ReloadOrTryRestartUnit" :

"StartUnit";

action = verb_to_action(args[0]);

mode = streq(args[0], "isolate") ? "isolate" :

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 (!arg_no_block) {

ret = enable_wait_for_jobs(bus);

if (ret < 0) {

log_error("Could not watch jobs: %s", strerror(-ret));

return ret;

}

s = set_new(string_hash_func, string_compare_func);

if (!s)

return log_oom();

}

if (one_name) {

ret = start_unit_one(bus, method, one_name, mode, &error, s);

if (ret < 0)

ret = translate_bus_error_to_exit_status(ret, &error);

} else {

STRV_FOREACH(name, args+1) {

r = start_unit_one(bus, method, *name, mode, &error, s);

if (r < 0) {

ret = translate_bus_error_to_exit_status(r, &error);

dbus_error_free(&error);

}

}

}

if (!arg_no_block) {

r = wait_for_jobs(bus, s);

if (r < 0)

return r;

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

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

if (one_name)

check_triggering_units(bus, one_name);

else

STRV_FOREACH(name, args+1)

check_triggering_units(bus, *name);

}

}

return ret;

}

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

#ifdef HAVE_LOGIND

const char *method;

dbus_bool_t interactive = true;

if (!bus)

return -EIO;

polkit_agent_open_if_enabled();

switch (a) {

case ACTION_REBOOT:

method = "Reboot";

break;

case ACTION_POWEROFF:

method = "PowerOff";

break;

case ACTION_SUSPEND:

method = "Suspend";

break;

case ACTION_HIBERNATE:

method = "Hibernate";

break;

case ACTION_HYBRID_SLEEP:

method = "HybridSleep";

break;

default:

return -EINVAL;

}

return bus_method_call_with_reply(

bus,

"org.freedesktop.login1",

"/org/freedesktop/login1",

"org.freedesktop.login1.Manager",

method,

NULL,

NULL,

DBUS_TYPE_BOOLEAN, &interactive,

DBUS_TYPE_INVALID);

#else

return -ENOSYS;

#endif

}

static int check_inhibitors(DBusConnection *bus, enum action a) {

#ifdef HAVE_LOGIND

_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;

DBusMessageIter iter, sub, sub2;

int r;

unsigned c = 0;

_cleanup_strv_free_ char **sessions = NULL;

char **s;

if (!bus)

return 0;

if (arg_ignore_inhibitors || arg_force > 0)

return 0;

if (arg_when > 0)

return 0;

if (geteuid() == 0)

return 0;

if (!on_tty())

return 0;

r = bus_method_call_with_reply(

bus,

"org.freedesktop.login1",

"/org/freedesktop/login1",

"org.freedesktop.login1.Manager",

"ListInhibitors",

&reply,

NULL,

DBUS_TYPE_INVALID);

if (r < 0)

/* If logind is not around, then there are no inhibitors... */

return 0;

if (!dbus_message_iter_init(reply, &iter) ||

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||

dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {

log_error("Failed to parse reply.");

return -EIO;

}

dbus_message_iter_recurse(&iter, &sub);

while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {

const char *what, *who, *why, *mode;

uint32_t uid, pid;

_cleanup_strv_free_ char **sv = NULL;

_cleanup_free_ char *comm = NULL, *user = NULL;

if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {

log_error("Failed to parse reply.");

return -EIO;

}

dbus_message_iter_recurse(&sub, &sub2);

if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &what, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &who, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &why, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &mode, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &uid, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &pid, false) < 0) {

log_error("Failed to parse reply.");

return -EIO;

}

if (!streq(mode, "block"))

goto next;

sv = strv_split(what, ":");

if (!sv)

return log_oom();

if (!strv_contains(sv,

a == ACTION_HALT ||

a == ACTION_POWEROFF ||

a == ACTION_REBOOT ||

a == ACTION_KEXEC ? "shutdown" : "sleep"))

goto next;

get_process_comm(pid, &comm);

user = uid_to_name(uid);

log_warning("Operation inhibited by \"%s\" (PID %lu \"%s\", user %s), reason is \"%s\".",

who, (unsigned long) pid, strna(comm), strna(user), why);

c++;

next:

dbus_message_iter_next(&sub);

}

dbus_message_iter_recurse(&iter, &sub);

/* Check for current sessions */

sd_get_sessions(&sessions);

STRV_FOREACH(s, sessions) {

uid_t uid;

_cleanup_free_ char *type = NULL, *tty = NULL, *seat = NULL, *user = NULL, *service = NULL, *class = NULL;

if (sd_session_get_uid(*s, &uid) < 0 || uid == getuid())

continue;

if (sd_session_get_class(*s, &class) < 0 || !streq(class, "user"))

continue;

if (sd_session_get_type(*s, &type) < 0 || (!streq(type, "x11") && !streq(type, "tty")))

continue;

sd_session_get_tty(*s, &tty);

sd_session_get_seat(*s, &seat);

sd_session_get_service(*s, &service);

user = uid_to_name(uid);

log_warning("User %s is logged in on %s.", strna(user), isempty(tty) ? (isempty(seat) ? strna(service) : seat) : tty);

c++;

}

if (c <= 0)

return 0;

log_error("Please retry operation after closing inhibitors and logging out other users.\nAlternatively, ignore inhibitors and users with 'systemctl %s -i'.",

action_table[a].verb);

return -EPERM;

#else

return 0;

#endif

}

static int start_special(DBusConnection *bus, char **args) {

enum action a;

int r;

assert(args);

a = verb_to_action(args[0]);

r = check_inhibitors(bus, a);

if (r < 0)

return r;

if (arg_force >= 2 && geteuid() != 0) {

log_error("Must be root.");

return -EPERM;

}

if (arg_force >= 2 &&

(a == ACTION_HALT ||

a == ACTION_POWEROFF ||

a == ACTION_REBOOT))

halt_now(a);

if (arg_force >= 1 &&

(a == ACTION_HALT ||

a == ACTION_POWEROFF ||

a == ACTION_REBOOT ||

a == ACTION_KEXEC ||

a == ACTION_EXIT))

return daemon_reload(bus, args);

/* first try logind, to allow authentication with polkit */

if (geteuid() != 0 &&

(a == ACTION_POWEROFF ||

a == ACTION_REBOOT ||

a == ACTION_SUSPEND ||

a == ACTION_HIBERNATE ||

a == ACTION_HYBRID_SLEEP)) {

r = reboot_with_logind(bus, a);

if (r >= 0)

return r;

}

r = start_unit(bus, args);

if (r == EXIT_SUCCESS)

warn_wall(a);

return r;

}

static int check_unit_active(DBusConnection *bus, char **args) {

const char * const check_states[] = {

"active",

"reloading",

NULL

};

char **name;

int r = 3; /* According to LSB: "program is not running" */

assert(bus);

assert(args);

STRV_FOREACH(name, args+1) {

int state;

state = check_one_unit(bus, *name, (char**) check_states, arg_quiet);

if (state < 0)

return state;

if (state > 0)

r = 0;

}

return r;

}

static int check_unit_failed(DBusConnection *bus, char **args) {

const char * const check_states[] = {

"failed",

NULL

};

char **name;

int r = 1;

assert(bus);

assert(args);

STRV_FOREACH(name, args+1) {

int state;

state = check_one_unit(bus, *name, (char**) check_states, arg_quiet);

if (state < 0)

return state;

if (state > 0)

r = 0;

}

return r;

}

static int kill_unit(DBusConnection *bus, char **args) {

char **name;

int r = 0;

assert(bus);

assert(args);

if (!arg_kill_who)

arg_kill_who = "all";

STRV_FOREACH(name, args+1) {

_cleanup_free_ char *n = NULL;

n = unit_name_mangle(*name);

if (!n)

return log_oom();

r = bus_method_call_with_reply(

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"KillUnit",

NULL,

NULL,

DBUS_TYPE_STRING, &n,

DBUS_TYPE_STRING, &arg_kill_who,

DBUS_TYPE_INT32, &arg_signal,

DBUS_TYPE_INVALID);

if (r < 0)

return r;

}

return 0;

}

static int set_cgroup(DBusConnection *bus, char **args) {

_cleanup_free_ char *n = NULL;

const char *method, *runtime;

char **argument;

int r;

assert(bus);

assert(args);

method =

streq(args[0], "set-cgroup") ? "SetUnitControlGroup" :

streq(args[0], "unset-cgroup") ? "UnsetUnitControlGroup"

: "UnsetUnitControlGroupAttribute";

runtime = arg_runtime ? "runtime" : "persistent";

n = unit_name_mangle(args[1]);

if (!n)

return log_oom();

STRV_FOREACH(argument, args + 2) {

r = bus_method_call_with_reply(

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

method,

NULL,

NULL,

DBUS_TYPE_STRING, &n,

DBUS_TYPE_STRING, argument,

DBUS_TYPE_STRING, &runtime,

DBUS_TYPE_INVALID);

if (r < 0)

return r;

}

return 0;

}

static int set_cgroup_attr(DBusConnection *bus, char **args) {

_cleanup_dbus_message_unref_ DBusMessage *m = NULL, *reply = NULL;

DBusError error;

DBusMessageIter iter;

_cleanup_free_ char *n = NULL;

const char *runtime;

int r;

assert(bus);

assert(args);

dbus_error_init(&error);

runtime = arg_runtime ? "runtime" : "persistent";

n = unit_name_mangle(args[1]);

if (!n)

return log_oom();

m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"SetUnitControlGroupAttribute");

if (!m)

return log_oom();

dbus_message_iter_init_append(m, &iter);

if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &n) ||

!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &args[2]))

return log_oom();

r = bus_append_strv_iter(&iter, args + 3);

if (r < 0)

return log_oom();

if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &runtime))

return log_oom();

reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);

if (!reply) {

log_error("Failed to issue method call: %s", bus_error_message(&error));

dbus_error_free(&error);

return -EIO;

}

return 0;

}

static int get_cgroup_attr(DBusConnection *bus, char **args) {

_cleanup_dbus_message_unref_ DBusMessage *m = NULL, *reply = NULL;

_cleanup_free_ char *n = NULL;

char **argument;

int r;

assert(bus);

assert(args);

n = unit_name_mangle(args[1]);

if (!n)

return log_oom();

STRV_FOREACH(argument, args + 2) {

_cleanup_strv_free_ char **list = NULL;

DBusMessageIter iter;

char **a;

r = bus_method_call_with_reply(

bus,

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"GetUnitControlGroupAttribute",

&reply,

NULL,

DBUS_TYPE_STRING, &n,

DBUS_TYPE_STRING, argument,

DBUS_TYPE_INVALID);

if (r < 0)

return r;

if (!dbus_message_iter_init(reply, &iter)) {

log_error("Failed to initialize iterator.");

return -EIO;

}

r = bus_parse_strv_iter(&iter, &list);

if (r < 0) {

log_error("Failed to parse value list.");

return r;

}

STRV_FOREACH(a, list) {

if (endswith(*a, "\n"))

fputs(*a, stdout);

else

puts(*a);

}

}

return 0;

}

typedef struct ExecStatusInfo {

char *name;

char *path;

char **argv;

bool ignore;

usec_t start_timestamp;

usec_t exit_timestamp;

pid_t pid;

int code;

int status;

LIST_FIELDS(struct ExecStatusInfo, exec);

} ExecStatusInfo;

static void exec_status_info_free(ExecStatusInfo *i) {

assert(i);

free(i->name);

free(i->path);

strv_free(i->argv);

free(i);

}

static int exec_status_info_deserialize(DBusMessageIter *sub, ExecStatusInfo *i) {

uint64_t start_timestamp, exit_timestamp, start_timestamp_monotonic, exit_timestamp_monotonic;

DBusMessageIter sub2, sub3;

const char*path;

unsigned n;

uint32_t pid;

int32_t code, status;

dbus_bool_t ignore;

assert(i);

assert(i);

if (dbus_message_iter_get_arg_type(sub) != DBUS_TYPE_STRUCT)

return -EIO;

dbus_message_iter_recurse(sub, &sub2);

if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) < 0)

return -EIO;

i->path = strdup(path);

if (!i->path)

return -ENOMEM;

if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_ARRAY ||

dbus_message_iter_get_element_type(&sub2) != DBUS_TYPE_STRING)

return -EIO;

n = 0;

dbus_message_iter_recurse(&sub2, &sub3);

while (dbus_message_iter_get_arg_type(&sub3) != DBUS_TYPE_INVALID) {

assert(dbus_message_iter_get_arg_type(&sub3) == DBUS_TYPE_STRING);

dbus_message_iter_next(&sub3);

n++;

}

i->argv = new0(char*, n+1);

if (!i->argv)

return -ENOMEM;

n = 0;

dbus_message_iter_recurse(&sub2, &sub3);

while (dbus_message_iter_get_arg_type(&sub3) != DBUS_TYPE_INVALID) {

const char *s;

assert(dbus_message_iter_get_arg_type(&sub3) == DBUS_TYPE_STRING);

dbus_message_iter_get_basic(&sub3, &s);

dbus_message_iter_next(&sub3);

i->argv[n] = strdup(s);

if (!i->argv[n])

return -ENOMEM;

n++;

}

if (!dbus_message_iter_next(&sub2) ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_BOOLEAN, &ignore, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &start_timestamp, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &start_timestamp_monotonic, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &exit_timestamp, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &exit_timestamp_monotonic, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &pid, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_INT32, &code, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_INT32, &status, false) < 0)

return -EIO;

i->ignore = ignore;

i->start_timestamp = (usec_t) start_timestamp;

i->exit_timestamp = (usec_t) exit_timestamp;

i->pid = (pid_t) pid;

i->code = code;

i->status = status;

return 0;

}

typedef struct UnitStatusInfo {

const char *id;

const char *load_state;

const char *active_state;

const char *sub_state;

const char *unit_file_state;

const char *description;

const char *following;

char **documentation;

const char *fragment_path;

const char *source_path;

const char *default_control_group;

const char *load_error;

const char *result;

usec_t inactive_exit_timestamp;

usec_t inactive_exit_timestamp_monotonic;

usec_t active_enter_timestamp;

usec_t active_exit_timestamp;

usec_t inactive_enter_timestamp;

bool need_daemon_reload;

/* Service */

pid_t main_pid;

pid_t control_pid;

const char *status_text;

bool running:1;

usec_t start_timestamp;

usec_t exit_timestamp;

int exit_code, exit_status;

usec_t condition_timestamp;

bool condition_result;

/* Socket */

unsigned n_accepted;

unsigned n_connections;

bool accept;

/* Device */

const char *sysfs_path;

/* Mount, Automount */

const char *where;

/* Swap */

const char *what;

LIST_HEAD(ExecStatusInfo, exec);

} UnitStatusInfo;

static void print_status_info(UnitStatusInfo *i) {

ExecStatusInfo *p;

const char *on, *off, *ss;

usec_t timestamp;

char since1[FORMAT_TIMESTAMP_RELATIVE_MAX], *s1;

char since2[FORMAT_TIMESTAMP_MAX], *s2;

const char *path;

int flags =

arg_all * OUTPUT_SHOW_ALL |

(!on_tty() || pager_have()) * OUTPUT_FULL_WIDTH |

on_tty() * OUTPUT_COLOR |

!arg_quiet * OUTPUT_WARN_CUTOFF |

arg_full * OUTPUT_FULL_WIDTH;

assert(i);

/* This shows pretty information about a unit. See

printf("%s", strna(i->id));

if (i->description && !streq_ptr(i->id, i->description))

printf(" - %s", i->description);

printf("\n");

if (i->following)

printf("\t Follow: unit currently follows state of %s\n", i->following);

if (streq_ptr(i->load_state, "error")) {

on = ansi_highlight_red(true);

off = ansi_highlight_red(false);

} else

on = off = "";

path = i->source_path ? i->source_path : i->fragment_path;

if (i->load_error)

printf("\t Loaded: %s%s%s (Reason: %s)\n", on, strna(i->load_state), off, i->load_error);

else if (path && i->unit_file_state)

printf("\t Loaded: %s%s%s (%s; %s)\n", on, strna(i->load_state), off, path, i->unit_file_state);

else if (path)

printf("\t Loaded: %s%s%s (%s)\n", on, strna(i->load_state), off, path);

else

printf("\t Loaded: %s%s%s\n", on, strna(i->load_state), off);

ss = streq_ptr(i->active_state, i->sub_state) ? NULL : i->sub_state;

if (streq_ptr(i->active_state, "failed")) {

on = ansi_highlight_red(true);

off = ansi_highlight_red(false);

} else if (streq_ptr(i->active_state, "active") || streq_ptr(i->active_state, "reloading")) {

on = ansi_highlight_green(true);

off = ansi_highlight_green(false);

} else

on = off = "";

if (ss)

printf("\t Active: %s%s (%s)%s",

on,

strna(i->active_state),

ss,

off);

else

printf("\t Active: %s%s%s",

on,

strna(i->active_state),

off);

if (!isempty(i->result) && !streq(i->result, "success"))

printf(" (Result: %s)", i->result);

timestamp = (streq_ptr(i->active_state, "active") ||

streq_ptr(i->active_state, "reloading")) ? i->active_enter_timestamp :

(streq_ptr(i->active_state, "inactive") ||

streq_ptr(i->active_state, "failed")) ? i->inactive_enter_timestamp :

streq_ptr(i->active_state, "activating") ? i->inactive_exit_timestamp :

i->active_exit_timestamp;

s1 = format_timestamp_relative(since1, sizeof(since1), timestamp);

s2 = format_timestamp(since2, sizeof(since2), timestamp);

if (s1)

printf(" since %s; %s\n", s2, s1);

else if (s2)

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

else

printf("\n");

if (!i->condition_result && i->condition_timestamp > 0) {

s1 = format_timestamp_relative(since1, sizeof(since1), i->condition_timestamp);

s2 = format_timestamp(since2, sizeof(since2), i->condition_timestamp);

if (s1)

printf("\t start condition failed at %s; %s\n", s2, s1);

else if (s2)

printf("\t start condition failed at %s\n", s2);

}

if (i->sysfs_path)

printf("\t Device: %s\n", i->sysfs_path);

if (i->where)

printf("\t Where: %s\n", i->where);

if (i->what)

printf("\t What: %s\n", i->what);

if (!strv_isempty(i->documentation)) {

char **t;

bool first = true;

STRV_FOREACH(t, i->documentation) {

if (first) {

printf("\t Docs: %s\n", *t);

first = false;

} else

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

}

}

if (i->accept)

printf("\tAccepted: %u; Connected: %u\n", i->n_accepted, i->n_connections);

LIST_FOREACH(exec, p, i->exec) {

_cleanup_free_ char *t = NULL;

bool good;

/* Only show exited processes here */

if (p->code == 0)

continue;

t = strv_join(p->argv, " ");

printf("\t Process: %u %s=%s ", p->pid, p->name, strna(t));

good = is_clean_exit_lsb(p->code, p->status, NULL);

if (!good) {

on = ansi_highlight_red(true);

off = ansi_highlight_red(false);

} else

on = off = "";

printf("%s(code=%s, ", on, sigchld_code_to_string(p->code));

if (p->code == CLD_EXITED) {

const char *c;

printf("status=%i", p->status);

c = exit_status_to_string(p->status, EXIT_STATUS_SYSTEMD);

if (c)

printf("/%s", c);

} else

printf("signal=%s", signal_to_string(p->status));

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

if (i->main_pid == p->pid &&

i->start_timestamp == p->start_timestamp &&

i->exit_timestamp == p->start_timestamp)

/* Let's not show this twice */

i->main_pid = 0;

if (p->pid == i->control_pid)

i->control_pid = 0;

}

if (i->main_pid > 0 || i->control_pid > 0) {

printf("\t");

if (i->main_pid > 0) {

printf("Main PID: %u", (unsigned) i->main_pid);

if (i->running) {

_cleanup_free_ char *t = NULL;

get_process_comm(i->main_pid, &t);

if (t)

printf(" (%s)", t);

} else if (i->exit_code > 0) {

printf(" (code=%s, ", sigchld_code_to_string(i->exit_code));

if (i->exit_code == CLD_EXITED) {

const char *c;

printf("status=%i", i->exit_status);

c = exit_status_to_string(i->exit_status, EXIT_STATUS_SYSTEMD);

if (c)

printf("/%s", c);

} else

printf("signal=%s", signal_to_string(i->exit_status));

printf(")");

}

}

if (i->main_pid > 0 && i->control_pid > 0)

printf(";");

if (i->control_pid > 0) {

_cleanup_free_ char *t = NULL;

printf(" Control: %u", (unsigned) i->control_pid);

get_process_comm(i->control_pid, &t);

if (t)

printf(" (%s)", t);

}

printf("\n");

}

if (i->status_text)

printf("\t Status: \"%s\"\n", i->status_text);

if (i->default_control_group &&

(i->main_pid > 0 || i->control_pid > 0 || cg_is_empty_by_spec(i->default_control_group, false) == 0)) {

unsigned c;

printf("\t CGroup: %s\n", i->default_control_group);

if (arg_transport != TRANSPORT_SSH) {

unsigned k = 0;

pid_t extra[2];

c = columns();

if (c > 18)

c -= 18;

else

c = 0;

if (i->main_pid > 0)

extra[k++] = i->main_pid;

if (i->control_pid > 0)

extra[k++] = i->control_pid;

show_cgroup_and_extra_by_spec(i->default_control_group, "\t\t ", c, false, extra, k, flags);

}

}

if (i->id && arg_transport != TRANSPORT_SSH) {

printf("\n");

show_journal_by_unit(stdout,

i->id,

arg_output,

0,

i->inactive_exit_timestamp_monotonic,

arg_lines,

getuid(),

flags,

arg_scope == UNIT_FILE_SYSTEM);

}

if (i->need_daemon_reload)

printf("\n%sWarning:%s Unit file changed on disk, 'systemctl %s daemon-reload' recommended.\n",

ansi_highlight_red(true),

ansi_highlight_red(false),

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

}

static void show_unit_help(UnitStatusInfo *i) {

char **p;

assert(i);

if (!i->documentation) {

log_info("Documentation for %s not known.", i->id);

return;

}

STRV_FOREACH(p, i->documentation) {

if (startswith(*p, "man:")) {

size_t k;

char *e = NULL;

char _cleanup_free_ *page = NULL, *section = NULL;

const char *args[4] = { "man", NULL, NULL, NULL };

pid_t pid;

k = strlen(*p);

if ((*p)[k-1] == ')')

e = strrchr(*p, '(');

if (e) {

page = strndup((*p) + 4, e - *p - 4);

section = strndup(e + 1, *p + k - e - 2);

if (!page || !section) {

log_oom();

return;

}

args[1] = section;

args[2] = page;

} else

args[1] = *p + 4;

pid = fork();

if (pid < 0) {

log_error("Failed to fork: %m");

continue;

}

if (pid == 0) {

/* Child */

execvp(args[0], (char**) args);

log_error("Failed to execute man: %m");

_exit(EXIT_FAILURE);

}

wait_for_terminate(pid, NULL);

} else

log_info("Can't show: %s", *p);

}

}

static int status_property(const char *name, DBusMessageIter *iter, UnitStatusInfo *i) {

assert(name);

assert(iter);

assert(i);

switch (dbus_message_iter_get_arg_type(iter)) {

case DBUS_TYPE_STRING: {

const char *s;

dbus_message_iter_get_basic(iter, &s);

if (!isempty(s)) {

if (streq(name, "Id"))

i->id = s;

else if (streq(name, "LoadState"))

i->load_state = s;

else if (streq(name, "ActiveState"))

i->active_state = s;

else if (streq(name, "SubState"))

i->sub_state = s;

else if (streq(name, "Description"))

i->description = s;

else if (streq(name, "FragmentPath"))

i->fragment_path = s;

else if (streq(name, "SourcePath"))

i->source_path = s;

else if (streq(name, "DefaultControlGroup"))

i->default_control_group = s;

else if (streq(name, "StatusText"))

i->status_text = s;

else if (streq(name, "SysFSPath"))

i->sysfs_path = s;

else if (streq(name, "Where"))

i->where = s;

else if (streq(name, "What"))

i->what = s;

else if (streq(name, "Following"))

i->following = s;

else if (streq(name, "UnitFileState"))

i->unit_file_state = s;

else if (streq(name, "Result"))

i->result = s;

}

break;

}

case DBUS_TYPE_BOOLEAN: {

dbus_bool_t b;

dbus_message_iter_get_basic(iter, &b);

if (streq(name, "Accept"))

i->accept = b;

else if (streq(name, "NeedDaemonReload"))

i->need_daemon_reload = b;

else if (streq(name, "ConditionResult"))

i->condition_result = b;

break;

}

case DBUS_TYPE_UINT32: {

uint32_t u;

dbus_message_iter_get_basic(iter, &u);

if (streq(name, "MainPID")) {

if (u > 0) {

i->main_pid = (pid_t) u;

i->running = true;

}

} else if (streq(name, "ControlPID"))

i->control_pid = (pid_t) u;

else if (streq(name, "ExecMainPID")) {

if (u > 0)

i->main_pid = (pid_t) u;

} else if (streq(name, "NAccepted"))

i->n_accepted = u;

else if (streq(name, "NConnections"))

i->n_connections = u;

break;

}

case DBUS_TYPE_INT32: {

int32_t j;

dbus_message_iter_get_basic(iter, &j);

if (streq(name, "ExecMainCode"))

i->exit_code = (int) j;

else if (streq(name, "ExecMainStatus"))

i->exit_status = (int) j;

break;

}

case DBUS_TYPE_UINT64: {

uint64_t u;

dbus_message_iter_get_basic(iter, &u);

if (streq(name, "ExecMainStartTimestamp"))

i->start_timestamp = (usec_t) u;

else if (streq(name, "ExecMainExitTimestamp"))

i->exit_timestamp = (usec_t) u;

else if (streq(name, "ActiveEnterTimestamp"))

i->active_enter_timestamp = (usec_t) u;

else if (streq(name, "InactiveEnterTimestamp"))

i->inactive_enter_timestamp = (usec_t) u;

else if (streq(name, "InactiveExitTimestamp"))

i->inactive_exit_timestamp = (usec_t) u;

else if (streq(name, "InactiveExitTimestampMonotonic"))

i->inactive_exit_timestamp_monotonic = (usec_t) u;

else if (streq(name, "ActiveExitTimestamp"))

i->active_exit_timestamp = (usec_t) u;

else if (streq(name, "ConditionTimestamp"))

i->condition_timestamp = (usec_t) u;

break;

}

case DBUS_TYPE_ARRAY: {

if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT &&

startswith(name, "Exec")) {

DBusMessageIter sub;

dbus_message_iter_recurse(iter, &sub);

while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {

ExecStatusInfo *info;

int r;

if (!(info = new0(ExecStatusInfo, 1)))

return -ENOMEM;

if (!(info->name = strdup(name))) {

free(info);

return -ENOMEM;

}

if ((r = exec_status_info_deserialize(&sub, info)) < 0) {

free(info);

return r;

}

LIST_PREPEND(ExecStatusInfo, exec, i->exec, info);

dbus_message_iter_next(&sub);

}

} else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRING &&

streq(name, "Documentation")) {

DBusMessageIter sub;

dbus_message_iter_recurse(iter, &sub);

while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING) {

const char *s;

char **l;

dbus_message_iter_get_basic(&sub, &s);

l = strv_append(i->documentation, s);

if (!l)

return -ENOMEM;

strv_free(i->documentation);

i->documentation = l;

dbus_message_iter_next(&sub);

}

}

break;

}

case DBUS_TYPE_STRUCT: {

if (streq(name, "LoadError")) {

DBusMessageIter sub;

const char *n, *message;

int r;

dbus_message_iter_recurse(iter, &sub);

r = bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &n, true);

if (r < 0)

return r;

r = bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &message, false);

if (r < 0)

return r;

if (!isempty(message))

i->load_error = message;

}

break;

}

}

return 0;

}

static int print_property(const char *name, DBusMessageIter *iter) {

assert(name);

assert(iter);

/* This is a low-level property printer, see

if (arg_property && !strv_find(arg_property, name))

return 0;

switch (dbus_message_iter_get_arg_type(iter)) {

case DBUS_TYPE_STRUCT: {

DBusMessageIter sub;

dbus_message_iter_recurse(iter, &sub);

if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_UINT32 && streq(name, "Job")) {