#include <sys/reboot.h>

#include <stdio.h>

#include <getopt.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 "log.h"

#include "util.h"

#include "macro.h"

#include "set.h"

#include "utmp-wtmp.h"

#include "special.h"

#include "initreq.h"

#include "strv.h"

#include "dbus-common.h"

#include "cgroup-show.h"

#include "cgroup-util.h"

#include "list.h"

#include "path-lookup.h"

#include "conf-parser.h"

#include "sd-daemon.h"

#include "shutdownd.h"

#include "exit-status.h"

#include "bus-errors.h"

#include "build.h"

#include "unit-name.h"

static const char *arg_type = NULL;

static char **arg_property = NULL;

static bool arg_all = false;

static bool arg_fail = false;

static bool arg_session = false;

static bool arg_global = false;

static bool arg_immediate = false;

static bool arg_no_block = false;

static bool arg_no_wtmp = false;

static bool arg_no_sync = false;

static bool arg_no_wall = false;

static bool arg_no_reload = false;

static bool arg_dry = false;

static bool arg_quiet = false;

static bool arg_full = false;

static bool arg_force = false;

static bool arg_defaults = false;

static bool arg_ask_password = false;

static char **arg_wall = NULL;

static const char *arg_kill_who = NULL;

static const char *arg_kill_mode = NULL;

static int arg_signal = SIGTERM;

static usec_t arg_when = 0;

static enum action {

ACTION_INVALID,

ACTION_SYSTEMCTL,

ACTION_HALT,

ACTION_POWEROFF,

ACTION_REBOOT,

ACTION_KEXEC,

ACTION_EXIT,

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

DOT_ALL,

DOT_ORDER,

DOT_REQUIRE

} arg_dot = DOT_ALL;

static bool private_bus = false;

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

static bool on_tty(void) {

static int t = -1;

if (_unlikely_(t < 0))

t = isatty(STDOUT_FILENO) > 0;

return t;

}

static void spawn_ask_password_agent(void) {

pid_t parent, child;

/* We check STDIN here, not STDOUT, since this is about input,

if (!isatty(STDIN_FILENO))

return;

if (!arg_ask_password)

return;

parent = getpid();

/* Spawns a temporary TTY agent, making sure it goes away when

if ((child = fork()) < 0)

return;

if (child == 0) {

/* In the child */

const char * const args[] = {

SYSTEMD_TTY_ASK_PASSWORD_AGENT_BINARY_PATH,

"--watch",

NULL

};

if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)

_exit(EXIT_FAILURE);

/* Check whether our parent died before we were able

if (getppid() != parent)

_exit(EXIT_SUCCESS);

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

_exit(EXIT_FAILURE);

}

}

static const char *ansi_highlight(bool b) {

if (!on_tty())

return "";

return b ? ANSI_HIGHLIGHT_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 bool error_is_no_service(const DBusError *error) {

assert(error);

if (!dbus_error_is_set(error))

return false;

if (dbus_error_has_name(error, DBUS_ERROR_NAME_HAS_NO_OWNER))

return true;

if (dbus_error_has_name(error, DBUS_ERROR_SERVICE_UNKNOWN))

return true;

return startswith(error->name, "org.freedesktop.DBus.Error.Spawn.");

}

static int 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 int bus_iter_get_basic_and_next(DBusMessageIter *iter, int type, void *data, bool next) {

assert(iter);

assert(data);

if (dbus_message_iter_get_arg_type(iter) != type)

return -EIO;

dbus_message_iter_get_basic(iter, data);

if (!dbus_message_iter_next(iter) != !next)

return -EIO;

return 0;

}

static void warn_wall(enum action action) {

static const char *table[_ACTION_MAX] = {

[ACTION_HALT] = "The system is going down for system halt NOW!",

[ACTION_REBOOT] = "The system is going down for reboot NOW!",

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

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

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

[ACTION_EMERGENCY] = "The system is going down to emergency mode NOW!"

};

if (arg_no_wall)

return;

if (arg_wall) {

char *p;

if (!(p = strv_join(arg_wall, " "))) {

log_error("Failed to join strings.");

return;

}

if (*p) {

utmp_wall(p);

free(p);

return;

}

free(p);

}

if (!table[action])

return;

utmp_wall(table[action]);

}

struct unit_info {

const char *id;

const char *description;

const char *load_state;

const char *active_state;

const char *sub_state;

const char *following;

const char *unit_path;

uint32_t job_id;

const char *job_type;

const char *job_path;

};

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;

if ((r = strcasecmp(d1, d2)) != 0)

return r;

}

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

}

static bool output_show_job(const struct unit_info *u) {

const char *dot;

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

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

(arg_all || !(streq(u->active_state, "inactive") || u->following[0]) || u->job_id > 0);

}

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

unsigned active_len, sub_len, job_len, n_shown = 0;

const struct unit_info *u;

active_len = sizeof("ACTIVE")-1;

sub_len = sizeof("SUB")-1;

job_len = sizeof("JOB")-1;

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

if (!output_show_job(u))

continue;

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

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

if (u->job_id != 0)

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

}

if (on_tty()) {

printf("%-25s %-6s %-*s %-*s %-*s", "UNIT", "LOAD",

active_len, "ACTIVE", sub_len, "SUB", job_len, "JOB");

if (columns() >= 80+12 || arg_full)

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

else

printf("\n");

}

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

char *e;

int a = 0, b = 0;

const char *on_loaded, *off_loaded;

const char *on_active, *off_active;

if (!output_show_job(u))

continue;

n_shown++;

if (!streq(u->load_state, "loaded") &&

!streq(u->load_state, "banned")) {

on_loaded = ansi_highlight(true);

off_loaded = ansi_highlight(false);

} else

on_loaded = off_loaded = "";

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

on_active = ansi_highlight(true);

off_active = ansi_highlight(false);

} else

on_active = off_active = "";

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

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

e ? e : u->id,

on_loaded, u->load_state, off_loaded,

on_active, active_len, u->active_state,

sub_len, u->sub_state, off_active,

&a);

free(e);

a -= strlen(on_loaded) + strlen(off_loaded);

a -= strlen(on_active) + strlen(off_active);

if (u->job_id != 0)

printf(" %-*s", job_len, u->job_type);

else

b = 1 + job_len;

if (a + b + 1 < columns()) {

if (u->job_id == 0)

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

if (arg_full)

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

else

printf(" %.*s", columns() - a - b - 1, u->description);

}

fputs("\n", stdout);

}

if (on_tty()) {

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

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

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

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

if (arg_all)

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

else

printf("\n%u units listed. Pass --all to see inactive units, too.\n", n_shown);

}

}

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

DBusMessage *m = NULL, *reply = NULL;

DBusError error;

int r;

DBusMessageIter iter, sub, sub2;

unsigned c = 0, n_units = 0;

struct unit_info *unit_infos = NULL;

dbus_error_init(&error);

assert(bus);

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"ListUnits"))) {

log_error("Could not allocate message.");

return -ENOMEM;

}

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {

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

r = -EIO;

goto finish;

}

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

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||

dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

dbus_message_iter_recurse(&iter, &sub);

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

struct unit_info *u;

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

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

if (c >= n_units) {

struct unit_info *w;

n_units = MAX(2*c, 16);

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

if (!w) {

log_error("Failed to allocate unit array.");

r = -ENOMEM;

goto finish;

}

unit_infos = w;

}

u = unit_infos+c;

dbus_message_iter_recurse(&sub, &sub2);

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

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

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

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

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

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

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &u->unit_path, true) < 0 ||

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &u->job_id, true) < 0 ||

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

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &u->job_path, false) < 0) {

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

dbus_message_iter_next(&sub);

c++;

}

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

output_units_list(unit_infos, c);

r = 0;

finish:

if (m)

dbus_message_unref(m);

if (reply)

dbus_message_unref(reply);

free(unit_infos);

dbus_error_free(&error);

return r;

}

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

static const char * const colors[] = {

"Requires", "[color=\"black\"]",

"RequiresOverridable", "[color=\"black\"]",

"Requisite", "[color=\"darkblue\"]",

"RequisiteOverridable", "[color=\"darkblue\"]",

"Wants", "[color=\"darkgrey\"]",

"Conflicts", "[color=\"red\"]",

"ConflictedBy", "[color=\"red\"]",

"After", "[color=\"green\"]"

};

const char *c = NULL;

unsigned i;

assert(name);

assert(prop);

assert(iter);

for (i = 0; i < ELEMENTSOF(colors); i += 2)

if (streq(colors[i], prop)) {

c = colors[i+1];

break;

}

if (!c)

return 0;

if (arg_dot != DOT_ALL)

if ((arg_dot == DOT_ORDER) != streq(prop, "After"))

return 0;

switch (dbus_message_iter_get_arg_type(iter)) {

case DBUS_TYPE_ARRAY:

if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRING) {

DBusMessageIter sub;

dbus_message_iter_recurse(iter, &sub);

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

const char *s;

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

dbus_message_iter_get_basic(&sub, &s);

printf("\t\"%s\"->\"%s\" %s;\n", name, s, c);

dbus_message_iter_next(&sub);

}

return 0;

}

}

return 0;

}

static int dot_one(DBusConnection *bus, const char *name, const char *path) {

DBusMessage *m = NULL, *reply = NULL;

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

int r;

DBusError error;

DBusMessageIter iter, sub, sub2, sub3;

assert(bus);

assert(path);

dbus_error_init(&error);

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

path,

"org.freedesktop.DBus.Properties",

"GetAll"))) {

log_error("Could not allocate message.");

r = -ENOMEM;

goto finish;

}

if (!dbus_message_append_args(m,

DBUS_TYPE_STRING, &interface,

DBUS_TYPE_INVALID)) {

log_error("Could not append arguments to message.");

r = -ENOMEM;

goto finish;

}

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {

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

r = -EIO;

goto finish;

}

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

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||

dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_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;

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

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

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

if (dot_one_property(name, prop, &sub3)) {

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

dbus_message_iter_next(&sub);

}

r = 0;

finish:

if (m)

dbus_message_unref(m);

if (reply)

dbus_message_unref(reply);

dbus_error_free(&error);

return r;

}

static int dot(DBusConnection *bus, char **args, unsigned n) {

DBusMessage *m = NULL, *reply = NULL;

DBusError error;

int r;

DBusMessageIter iter, sub, sub2;

dbus_error_init(&error);

assert(bus);

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"ListUnits"))) {

log_error("Could not allocate message.");

return -ENOMEM;

}

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {

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

r = -EIO;

goto finish;

}

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

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||

dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

printf("digraph systemd {\n");

dbus_message_iter_recurse(&iter, &sub);

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

const char *id, *description, *load_state, *active_state, *sub_state, *following, *unit_path;

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

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

dbus_message_iter_recurse(&sub, &sub2);

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

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

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

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

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

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

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

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

if ((r = dot_one(bus, id, unit_path)) < 0)

goto finish;

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

dbus_message_iter_next(&sub);

}

printf("}\n");

log_info(" Color legend: black = Requires\n"

" dark blue = Requisite\n"

" dark grey = Wants\n"

" red = Conflicts\n"

" green = After\n");

if (isatty(fileno(stdout)))

log_notice("-- You probably want to process this output with graphviz' dot tool.\n"

"-- Try a shell pipeline like 'systemctl dot | dot -Tsvg > systemd.svg'!\n");

r = 0;

finish:

if (m)

dbus_message_unref(m);

if (reply)

dbus_message_unref(reply);

dbus_error_free(&error);

return r;

}

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

DBusMessage *m = NULL, *reply = NULL;

DBusError error;

int r;

DBusMessageIter iter, sub, sub2;

unsigned k = 0;

dbus_error_init(&error);

assert(bus);

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"ListJobs"))) {

log_error("Could not allocate message.");

return -ENOMEM;

}

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {

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

r = -EIO;

goto finish;

}

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

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||

dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

dbus_message_iter_recurse(&iter, &sub);

if (isatty(STDOUT_FILENO))

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 *e;

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

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

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

r = -EIO;

goto finish;

}

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

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

free(e);

k++;

dbus_message_iter_next(&sub);

}

if (isatty(STDOUT_FILENO))

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

r = 0;

finish:

if (m)

dbus_message_unref(m);

if (reply)

dbus_message_unref(reply);

dbus_error_free(&error);

return r;

}

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

DBusMessage *m = NULL, *reply = NULL;

DBusError error;

int r;

unsigned i;

dbus_error_init(&error);

assert(bus);

assert(args);

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

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"LoadUnit"))) {

log_error("Could not allocate message.");

r = -ENOMEM;

goto finish;

}

if (!dbus_message_append_args(m,

DBUS_TYPE_STRING, &args[i],

DBUS_TYPE_INVALID)) {

log_error("Could not append arguments to message.");

r = -ENOMEM;

goto finish;

}

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {

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

r = -EIO;

goto finish;

}

dbus_message_unref(m);

dbus_message_unref(reply);

m = reply = NULL;

}

r = 0;

finish:

if (m)

dbus_message_unref(m);

if (reply)

dbus_message_unref(reply);

dbus_error_free(&error);

return r;

}

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

DBusMessage *m = NULL, *reply = NULL;

DBusError error;

int r;

unsigned i;

dbus_error_init(&error);

assert(bus);

assert(args);

if (n <= 1)

return daemon_reload(bus, args, n);

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

unsigned id;

const char *path;

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"GetJob"))) {

log_error("Could not allocate message.");

r = -ENOMEM;

goto finish;

}

if ((r = safe_atou(args[i], &id)) < 0) {

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

goto finish;

}

assert_cc(sizeof(uint32_t) == sizeof(id));

if (!dbus_message_append_args(m,

DBUS_TYPE_UINT32, &id,

DBUS_TYPE_INVALID)) {

log_error("Could not append arguments to message.");

r = -ENOMEM;

goto finish;

}

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {

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

r = -EIO;

goto finish;

}

if (!dbus_message_get_args(reply, &error,

DBUS_TYPE_OBJECT_PATH, &path,

DBUS_TYPE_INVALID)) {

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

r = -EIO;

goto finish;

}

dbus_message_unref(m);

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

path,

"org.freedesktop.systemd1.Job",

"Cancel"))) {

log_error("Could not allocate message.");

r = -ENOMEM;

goto finish;

}

dbus_message_unref(reply);

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {

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

r = -EIO;

goto finish;

}

dbus_message_unref(m);

dbus_message_unref(reply);

m = reply = NULL;

}

r = 0;

finish:

if (m)

dbus_message_unref(m);

if (reply)

dbus_message_unref(reply);

dbus_error_free(&error);

return r;

}

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

DBusMessage *m = NULL, *reply = NULL;

dbus_bool_t b = FALSE;

DBusMessageIter iter, sub;

const char

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

*property = "NeedDaemonReload",

*path;

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

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"GetUnit")))

goto finish;

if (!dbus_message_append_args(m,

DBUS_TYPE_STRING, &unit,

DBUS_TYPE_INVALID))

goto finish;

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, NULL)))

goto finish;

if (!dbus_message_get_args(reply, NULL,

DBUS_TYPE_OBJECT_PATH, &path,

DBUS_TYPE_INVALID))

goto finish;

dbus_message_unref(m);

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

path,

"org.freedesktop.DBus.Properties",

"Get")))

goto finish;

if (!dbus_message_append_args(m,

DBUS_TYPE_STRING, &interface,

DBUS_TYPE_STRING, &property,

DBUS_TYPE_INVALID)) {

goto finish;

}

dbus_message_unref(reply);

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, NULL)))

goto finish;

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

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)

goto finish;

dbus_message_iter_recurse(&iter, &sub);

if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)

goto finish;

dbus_message_iter_get_basic(&sub, &b);

finish:

if (m)

dbus_message_unref(m);

if (reply)

dbus_message_unref(reply);

return b;

}

typedef struct WaitData {

Set *set;

bool failed;

} WaitData;

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

DBusError error;

WaitData *d = data;

assert(connection);

assert(message);

assert(d);

dbus_error_init(&error);

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

dbus_message_get_interface(message),

dbus_message_get_member(message),

dbus_message_get_path(message));

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;

dbus_bool_t success = true;

if (!dbus_message_get_args(message, &error,

DBUS_TYPE_UINT32, &id,

DBUS_TYPE_OBJECT_PATH, &path,

DBUS_TYPE_BOOLEAN, &success,

DBUS_TYPE_INVALID))

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

else {

char *p;

if ((p = set_remove(d->set, (char*) path)))

free(p);

if (!success)

d->failed = true;

}

}

dbus_error_free(&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;

WaitData d;

assert(bus);

assert(s);

zero(d);

d.set = s;

d.failed = false;

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

log_error("Failed to add filter.");

r = -ENOMEM;

goto finish;

}

while (!set_isempty(s) &&

dbus_connection_read_write_dispatch(bus, -1))

;

if (!arg_quiet && d.failed)

log_error("Job failed, see system logs for details.");

r = d.failed ? -EIO : 0;

finish:

/* This is slightly dirty, since we don't undo the filter registration. */

return r;

}

static int start_unit_one(

DBusConnection *bus,

const char *method,

const char *name,

const char *mode,

DBusError *error,

Set *s) {

DBusMessage *m = NULL, *reply = NULL;

const char *path;

int r;

assert(bus);

assert(method);

assert(name);

assert(mode);

assert(error);

assert(arg_no_block || s);

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

method))) {

log_error("Could not allocate message.");

r = -ENOMEM;

goto finish;

}

if (!dbus_message_append_args(m,

DBUS_TYPE_STRING, &name,

DBUS_TYPE_STRING, &mode,

DBUS_TYPE_INVALID)) {

log_error("Could not append arguments to message.");

r = -ENOMEM;

goto finish;

}

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, error))) {

if (arg_action != ACTION_SYSTEMCTL && error_is_no_service(error)) {

/* There's always a fallback possible for

r = -EADDRNOTAVAIL;

goto finish;

}

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

r = -EIO;

goto finish;

}

if (!dbus_message_get_args(reply, error,

DBUS_TYPE_OBJECT_PATH, &path,

DBUS_TYPE_INVALID)) {

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

r = -EIO;

goto finish;

}

if (need_daemon_reload(bus, name))

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

arg_session ? "--session" : "--system");

if (!arg_no_block) {

char *p;

if (!(p = strdup(path))) {

log_error("Failed to duplicate path.");

r = -ENOMEM;

goto finish;

}

if ((r = set_put(s, p)) < 0) {

free(p);

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

goto finish;

}

}

r = 0;

finish:

if (m)

dbus_message_unref(m);

if (reply)

dbus_message_unref(reply);

return r;

}

static enum action verb_to_action(const char *verb) {

if (streq(verb, "halt"))

return ACTION_HALT;

else if (streq(verb, "poweroff"))

return ACTION_POWEROFF;

else if (streq(verb, "reboot"))

return ACTION_REBOOT;

else if (streq(verb, "kexec"))

return ACTION_KEXEC;

else if (streq(verb, "rescue"))

return ACTION_RESCUE;

else if (streq(verb, "emergency"))

return ACTION_EMERGENCY;

else if (streq(verb, "default"))

return ACTION_DEFAULT;

else if (streq(verb, "exit"))

return ACTION_EXIT;

else

return ACTION_INVALID;

}

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

static const char * const table[_ACTION_MAX] = {

[ACTION_HALT] = SPECIAL_HALT_TARGET,

[ACTION_POWEROFF] = SPECIAL_POWEROFF_TARGET,

[ACTION_REBOOT] = SPECIAL_REBOOT_TARGET,

[ACTION_KEXEC] = SPECIAL_KEXEC_TARGET,

[ACTION_RUNLEVEL2] = SPECIAL_RUNLEVEL2_TARGET,

[ACTION_RUNLEVEL3] = SPECIAL_RUNLEVEL3_TARGET,

[ACTION_RUNLEVEL4] = SPECIAL_RUNLEVEL4_TARGET,

[ACTION_RUNLEVEL5] = SPECIAL_RUNLEVEL5_TARGET,

[ACTION_RESCUE] = SPECIAL_RESCUE_TARGET,

[ACTION_EMERGENCY] = SPECIAL_EMERGENCY_TARGET,

[ACTION_DEFAULT] = SPECIAL_DEFAULT_TARGET,

[ACTION_EXIT] = SPECIAL_EXIT_TARGET

};

int r, ret = 0;

unsigned i;

const char *method, *mode, *one_name;

Set *s = NULL;

DBusError error;

dbus_error_init(&error);

assert(bus);

spawn_ask_password_agent();

if (arg_action == ACTION_SYSTEMCTL) {

method =

streq(args[0], "stop") ? "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], "force-reload") ? "ReloadOrTryRestartUnit" :

"StartUnit";

mode =

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

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

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

arg_fail ? "fail" :

"replace";

one_name = table[verb_to_action(args[0])];

} else {

assert(arg_action < ELEMENTSOF(table));

assert(table[arg_action]);

method = "StartUnit";

mode = (arg_action == ACTION_EMERGENCY ||

arg_action == ACTION_RESCUE ||

arg_action == ACTION_RUNLEVEL2 ||

arg_action == ACTION_RUNLEVEL3 ||

arg_action == ACTION_RUNLEVEL4 ||

arg_action == ACTION_RUNLEVEL5) ? "isolate" : "replace";

one_name = table[arg_action];

}

if (!arg_no_block) {

if ((ret = enable_wait_for_jobs(bus)) < 0) {

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

goto finish;

}

if (!(s = set_new(string_hash_func, string_compare_func))) {

log_error("Failed to allocate set.");

ret = -ENOMEM;

goto finish;

}

}

if (one_name) {

if ((ret = start_unit_one(bus, method, one_name, mode, &error, s)) <= 0)

goto finish;

} else {

for (i = 1; i < n; i++)

if ((r = start_unit_one(bus, method, args[i], mode, &error, s)) != 0) {

ret = translate_bus_error_to_exit_status(r, &error);

dbus_error_free(&error);

}

}

if (!arg_no_block)

if ((r = wait_for_jobs(bus, s)) < 0) {

ret = r;

goto finish;

}

finish:

if (s)

set_free_free(s);

dbus_error_free(&error);

return ret;

}

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

int r;

assert(bus);

assert(args);

if (arg_force &&

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

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

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

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

streq(args[0], "exit")))

return daemon_reload(bus, args, n);

r = start_unit(bus, args, n);

if (r >= 0)

warn_wall(verb_to_action(args[0]));

return r;

}

static int check_unit(DBusConnection *bus, char **args, unsigned n) {

DBusMessage *m = NULL, *reply = NULL;

const char

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

*property = "ActiveState";

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

DBusError error;

unsigned i;

assert(bus);

assert(args);

dbus_error_init(&error);

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

const char *path = NULL;

const char *state;

DBusMessageIter iter, sub;

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"GetUnit"))) {

log_error("Could not allocate message.");

r = -ENOMEM;

goto finish;

}

if (!dbus_message_append_args(m,

DBUS_TYPE_STRING, &args[i],

DBUS_TYPE_INVALID)) {

log_error("Could not append arguments to message.");

r = -ENOMEM;

goto finish;

}

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {

/* Hmm, cannot figure out anything about this unit... */

if (!arg_quiet)

puts("unknown");

dbus_error_free(&error);

dbus_message_unref(m);

continue;

}

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

r = -EIO;

goto finish;

}

dbus_message_unref(m);

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

path,

"org.freedesktop.DBus.Properties",

"Get"))) {

log_error("Could not allocate message.");

r = -ENOMEM;

goto finish;

}

if (!dbus_message_append_args(m,

DBUS_TYPE_STRING, &interface,

DBUS_TYPE_STRING, &property,

DBUS_TYPE_INVALID)) {

log_error("Could not append arguments to message.");

r = -ENOMEM;

goto finish;

}

dbus_message_unref(reply);

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {

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

r = -EIO;

goto finish;

}

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

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

dbus_message_iter_recurse(&iter, &sub);

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

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

dbus_message_iter_get_basic(&sub, &state);

if (!arg_quiet)

puts(state);

if (streq(state, "active") || streq(state, "reloading"))

r = 0;

dbus_message_unref(m);

dbus_message_unref(reply);

m = reply = NULL;

}

finish:

if (m)

dbus_message_unref(m);

if (reply)

dbus_message_unref(reply);

dbus_error_free(&error);

return r;

}

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

DBusMessage *m = NULL, *reply = NULL;

int r = 0;

DBusError error;

unsigned i;

assert(bus);

assert(args);

dbus_error_init(&error);

if (!arg_kill_who)

arg_kill_who = "all";

if (!arg_kill_mode)

arg_kill_mode = streq(arg_kill_who, "all") ? "control-group" : "process";

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

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"KillUnit"))) {

log_error("Could not allocate message.");

r = -ENOMEM;

goto finish;

}

if (!dbus_message_append_args(m,

DBUS_TYPE_STRING, &args[i],

DBUS_TYPE_STRING, &arg_kill_who,

DBUS_TYPE_STRING, &arg_kill_mode,

DBUS_TYPE_INT32, &arg_signal,

DBUS_TYPE_INVALID)) {

log_error("Could not append arguments to message.");

r = -ENOMEM;

goto finish;

}

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {

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

dbus_error_free(&error);

r = -EIO;

}

dbus_message_unref(m);

if (reply)

dbus_message_unref(reply);

m = reply = NULL;

}

finish:

if (m)

dbus_message_unref(m);

if (reply)

dbus_message_unref(reply);

dbus_error_free(&error);

return r;

}

typedef struct ExecStatusInfo {

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

strv_free(i->argv);

free(i);

}

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

uint64_t start_timestamp, exit_timestamp;

DBusMessageIter sub2, sub3;

const char*path;

unsigned n;

uint32_t pid;

int32_t code, status;

dbus_bool_t ignore;

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;

if (!(i->path = strdup(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++;

}

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

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

if (!(i->argv[n++] = strdup(s)))

return -ENOMEM;

}

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, &exit_timestamp, 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 *description;

const char *following;

const char *path;

const char *default_control_group;

usec_t inactive_exit_timestamp;

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;

#ifdef HAVE_SYSV_COMPAT

bool is_sysv:1;

#endif

usec_t start_timestamp;

usec_t exit_timestamp;

int exit_code, exit_status;

/* 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_PRETTY_MAX], *s1;

char since2[FORMAT_TIMESTAMP_MAX], *s2;

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, "failed") ||

streq_ptr(i->load_state, "banned")) {

on = ansi_highlight(true);

off = ansi_highlight(false);

} else

on = off = "";

if (i->path)

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

else

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

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

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

on = ansi_highlight(true);

off = ansi_highlight(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);

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_pretty(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->sysfs_path)

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

else if (i->where)

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

else if (i->what)

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

if (i->accept)

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

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

char *t;

/* Only show exited processes here */

if (p->code == 0)

continue;

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

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

free(t);

if (p->code == CLD_EXITED) {

const char *c;

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

#ifdef HAVE_SYSV_COMPAT

if ((c = exit_status_to_string(p->status, i->is_sysv ? EXIT_STATUS_LSB : EXIT_STATUS_SYSTEMD)))

#else

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

#endif

printf("/%s", c);

} else

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

printf(")\n");

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

char *t = NULL;

get_process_name(i->main_pid, &t);

if (t) {

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

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

#ifdef HAVE_SYSV_COMPAT

if ((c = exit_status_to_string(i->exit_status, i->is_sysv ? EXIT_STATUS_LSB : EXIT_STATUS_SYSTEMD)))

#else

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

#endif

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

char *t = NULL;

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

get_process_name(i->control_pid, &t);

if (t) {

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

free(t);

}

}

printf("\n");

}

if (i->status_text)

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

if (i->default_control_group) {

unsigned c;

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

if ((c = columns()) > 18)

c -= 18;

else

c = 0;

show_cgroup_by_path(i->default_control_group, "\t\t ", c);

}

if (i->need_daemon_reload)

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

ansi_highlight(true),

ansi_highlight(false),

arg_session ? "--session" : "--system");

}

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

switch (dbus_message_iter_get_arg_type(iter)) {

case DBUS_TYPE_STRING: {

const char *s;

dbus_message_iter_get_basic(iter, &s);

if (s[0]) {

if (streq(name, "Id"))

i->id = s;

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

i->load_state = s;

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

i->active_state = s;

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

i->sub_state = s;

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

i->description = s;

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

i->path = s;

#ifdef HAVE_SYSV_COMPAT

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

i->is_sysv = true;

i->path = s;

}

#endif

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;

}

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;

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, "ActiveExitTimestamp"))

i->active_exit_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 ((r = exec_status_info_deserialize(&sub, info)) < 0) {

free(info);

return r;

}

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

dbus_message_iter_next(&sub);

}

}

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_STRING: {

const char *s;

dbus_message_iter_get_basic(iter, &s);

if (arg_all || s[0])

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

return 0;

}

case DBUS_TYPE_BOOLEAN: {

dbus_bool_t b;

dbus_message_iter_get_basic(iter, &b);

printf("%s=%s\n", name, yes_no(b));

return 0;

}

case DBUS_TYPE_UINT64: {

uint64_t u;

dbus_message_iter_get_basic(iter, &u);

/* Yes, heuristics! But we can change this check

if (strstr(name, "Timestamp")) {

char timestamp[FORMAT_TIMESTAMP_MAX], *t;

if ((t = format_timestamp(timestamp, sizeof(timestamp), u)) || arg_all)

printf("%s=%s\n", name, strempty(t));

} else if (strstr(name, "USec")) {

char timespan[FORMAT_TIMESPAN_MAX];

printf("%s=%s\n", name, format_timespan(timespan, sizeof(timespan), u));

} else

printf("%s=%llu\n", name, (unsigned long long) u);

return 0;

}

case DBUS_TYPE_UINT32: {

uint32_t u;

dbus_message_iter_get_basic(iter, &u);

if (strstr(name, "UMask") || strstr(name, "Mode"))

printf("%s=%04o\n", name, u);

else

printf("%s=%u\n", name, (unsigned) u);

return 0;

}

case DBUS_TYPE_INT32: {

int32_t i;

dbus_message_iter_get_basic(iter, &i);

printf("%s=%i\n", name, (int) i);

return 0;

}

case DBUS_TYPE_DOUBLE: {

double d;

dbus_message_iter_get_basic(iter, &d);

printf("%s=%g\n", name, d);

return 0;

}

case DBUS_TYPE_STRUCT: {

DBusMessageIter sub;

dbus_message_iter_recurse(iter, &sub);

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

uint32_t u;

dbus_message_iter_get_basic(&sub, &u);

if (u)

printf("%s=%u\n", name, (unsigned) u);

else if (arg_all)

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

return 0;

} else if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "Unit")) {

const char *s;

dbus_message_iter_get_basic(&sub, &s);

if (arg_all || s[0])

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

return 0;

}

break;

}

case DBUS_TYPE_ARRAY:

if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRING) {

DBusMessageIter sub;

bool space = false;

dbus_message_iter_recurse(iter, &sub);

if (arg_all ||

dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {

printf("%s=", name);

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

const char *s;

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

dbus_message_iter_get_basic(&sub, &s);

printf("%s%s", space ? " " : "", s);

space = true;

dbus_message_iter_next(&sub);

}

puts("");

}

return 0;

} else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_BYTE) {

DBusMessageIter sub;

dbus_message_iter_recurse(iter, &sub);

if (arg_all ||

dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {

printf("%s=", name);

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

uint8_t u;

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

dbus_message_iter_get_basic(&sub, &u);

printf("%02x", u);

dbus_message_iter_next(&sub);

}

puts("");

}

return 0;

} else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Paths")) {

DBusMessageIter sub, sub2;

dbus_message_iter_recurse(iter, &sub);

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

const char *type, *path;

dbus_message_iter_recurse(&sub, &sub2);

if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) >= 0 &&

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, false) >= 0)

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

dbus_message_iter_next(&sub);

}

return 0;

} else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Timers")) {

DBusMessageIter sub, sub2;

dbus_message_iter_recurse(iter, &sub);

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

const char *base;

uint64_t value, next_elapse;

dbus_message_iter_recurse(&sub, &sub2);

if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &base, true) >= 0 &&

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &value, true) >= 0 &&

bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &next_elapse, false) >= 0) {

char timespan1[FORMAT_TIMESPAN_MAX], timespan2[FORMAT_TIMESPAN_MAX];

printf("%s={ value=%s ; next_elapse=%s }\n",

base,

format_timespan(timespan1, sizeof(timespan1), value),

format_timespan(timespan2, sizeof(timespan2), next_elapse));

}

dbus_message_iter_next(&sub);

}

return 0;

} else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && startswith(name, "Exec")) {

DBusMessageIter sub;

dbus_message_iter_recurse(iter, &sub);

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

ExecStatusInfo info;

zero(info);

if (exec_status_info_deserialize(&sub, &info) >= 0) {

char timestamp1[FORMAT_TIMESTAMP_MAX], timestamp2[FORMAT_TIMESTAMP_MAX];

char *t;

t = strv_join(info.argv, " ");

printf("%s={ path=%s ; argv[]=%s ; ignore=%s ; start_time=[%s] ; stop_time=[%s] ; pid=%u ; code=%s ; status=%i%s%s }\n",

name,

strna(info.path),

strna(t),

yes_no(info.ignore),

strna(format_timestamp(timestamp1, sizeof(timestamp1), info.start_timestamp)),

strna(format_timestamp(timestamp2, sizeof(timestamp2), info.exit_timestamp)),

(unsigned) info. pid,

sigchld_code_to_string(info.code),

info.status,

info.code == CLD_EXITED ? "" : "/",

strempty(info.code == CLD_EXITED ? NULL : signal_to_string(info.status)));

free(t);

}

free(info.path);

strv_free(info.argv);

dbus_message_iter_next(&sub);

}

return 0;

}

break;

}

if (arg_all)

printf("%s=[unprintable]\n", name);

return 0;

}

static int show_one(DBusConnection *bus, const char *path, bool show_properties, bool *new_line) {

DBusMessage *m = NULL, *reply = NULL;

const char *interface = "";

int r;

DBusError error;

DBusMessageIter iter, sub, sub2, sub3;

UnitStatusInfo info;

ExecStatusInfo *p;

assert(bus);

assert(path);

assert(new_line);

zero(info);

dbus_error_init(&error);

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

path,

"org.freedesktop.DBus.Properties",

"GetAll"))) {

log_error("Could not allocate message.");

r = -ENOMEM;

goto finish;

}

if (!dbus_message_append_args(m,

DBUS_TYPE_STRING, &interface,

DBUS_TYPE_INVALID)) {

log_error("Could not append arguments to message.");

r = -ENOMEM;

goto finish;

}

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {

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

r = -EIO;

goto finish;

}

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

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||

dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY) {

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

dbus_message_iter_recurse(&iter, &sub);

if (*new_line)

printf("\n");

*new_line = true;

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

const char *name;

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

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

dbus_message_iter_recurse(&sub, &sub2);

if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, 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);

if (show_properties)

r = print_property(name, &sub3);

else

r = status_property(name, &sub3, &info);

if (r < 0) {

log_error("Failed to parse reply.");

r = -EIO;

goto finish;

}

dbus_message_iter_next(&sub);

}

r = 0;

if (!show_properties)

print_status_info(&info);

if (!streq_ptr(info.active_state, "active") &&

!streq_ptr(info.active_state, "reloading"))

/* According to LSB: "program not running" */

r = 3;

while ((p = info.exec)) {

LIST_REMOVE(ExecStatusInfo, exec, info.exec, p);

exec_status_info_free(p);

}

finish:

if (m)

dbus_message_unref(m);

if (reply)

dbus_message_unref(reply);

dbus_error_free(&error);

return r;

}

static int show(DBusConnection *bus, char **args, unsigned n) {

DBusMessage *m = NULL, *reply = NULL;

int r, ret = 0;

DBusError error;

unsigned i;

bool show_properties, new_line = false;

assert(bus);

assert(args);

dbus_error_init(&error);

show_properties = !streq(args[0], "status");

if (show_properties && n <= 1) {

/* If not argument is specified inspect the manager

ret = show_one(bus, "/org/freedesktop/systemd1", show_properties, &new_line);

goto finish;

}

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

const char *path = NULL;

uint32_t id;

if (safe_atou32(args[i], &id) < 0) {

/* Interpret as unit name */

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"LoadUnit"))) {

log_error("Could not allocate message.");

ret = -ENOMEM;

goto finish;

}

if (!dbus_message_append_args(m,

DBUS_TYPE_STRING, &args[i],

DBUS_TYPE_INVALID)) {

log_error("Could not append arguments to message.");

ret = -ENOMEM;

goto finish;

}

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {

if (!dbus_error_has_name(&error, DBUS_ERROR_ACCESS_DENIED)) {

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

ret = -EIO;

goto finish;

}

dbus_error_free(&error);

dbus_message_unref(m);

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"GetUnit"))) {

log_error("Could not allocate message.");

ret = -ENOMEM;

goto finish;

}

if (!dbus_message_append_args(m,

DBUS_TYPE_STRING, &args[i],

DBUS_TYPE_INVALID)) {

log_error("Could not append arguments to message.");

ret = -ENOMEM;

goto finish;

}

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {

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

if (dbus_error_has_name(&error, BUS_ERROR_NO_SUCH_UNIT))

ret = 4; /* According to LSB: "program or service status is unknown" */

else

ret = -EIO;

goto finish;

}

}

} else if (show_properties) {

/* Interpret as job id */

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"GetJob"))) {

log_error("Could not allocate message.");

ret = -ENOMEM;

goto finish;

}

if (!dbus_message_append_args(m,

DBUS_TYPE_UINT32, &id,

DBUS_TYPE_INVALID)) {

log_error("Could not append arguments to message.");

ret = -ENOMEM;

goto finish;

}

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {

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

ret = -EIO;

goto finish;

}

} else {

/* Interpret as PID */

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"GetUnitByPID"))) {

log_error("Could not allocate message.");

ret = -ENOMEM;

goto finish;

}

if (!dbus_message_append_args(m,

DBUS_TYPE_UINT32, &id,

DBUS_TYPE_INVALID)) {

log_error("Could not append arguments to message.");

ret = -ENOMEM;

goto finish;

}

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {

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

ret = -EIO;

goto finish;

}

}

if (!dbus_message_get_args(reply, &error,

DBUS_TYPE_OBJECT_PATH, &path,

DBUS_TYPE_INVALID)) {

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

ret = -EIO;

goto finish;

}

if ((r = show_one(bus, path, show_properties, &new_line)) != 0)

ret = r;

dbus_message_unref(m);

dbus_message_unref(reply);

m = reply = NULL;

}

finish:

if (m)

dbus_message_unref(m);

if (reply)

dbus_message_unref(reply);

dbus_error_free(&error);

return ret;

}

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

DBusError error;

DBusMessage *m = NULL, *reply = NULL;

assert(connection);

assert(message);

dbus_error_init(&error);

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

dbus_message_get_interface(message),

dbus_message_get_member(message),

dbus_message_get_path(message));

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

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

dbus_connection_close(connection);

} else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "UnitNew") ||

dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "UnitRemoved")) {

const char *id, *path;

if (!dbus_message_get_args(message, &error,

DBUS_TYPE_STRING, &id,

DBUS_TYPE_OBJECT_PATH, &path,

DBUS_TYPE_INVALID))

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

else if (streq(dbus_message_get_member(message), "UnitNew"))

printf("Unit %s added.\n", id);

else

printf("Unit %s removed.\n", id);

} else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobNew") ||

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

uint32_t id;

const char *path;

if (!dbus_message_get_args(message, &error,

DBUS_TYPE_UINT32, &id,

DBUS_TYPE_OBJECT_PATH, &path,

DBUS_TYPE_INVALID))

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

else if (streq(dbus_message_get_member(message), "JobNew"))

printf("Job %u added.\n", id);

else

printf("Job %u removed.\n", id);

} else if (dbus_message_is_signal(message, "org.freedesktop.DBus.Properties", "PropertiesChanged")) {

const char *path, *interface, *property = "Id";

DBusMessageIter iter, sub;

path = dbus_message_get_path(message);

if (!dbus_message_get_args(message, &error,

DBUS_TYPE_STRING, &interface,

DBUS_TYPE_INVALID)) {

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

goto finish;

}

if (!streq(interface, "org.freedesktop.systemd1.Job") &&

!streq(interface, "org.freedesktop.systemd1.Unit"))

goto finish;

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

path,

"org.freedesktop.DBus.Properties",

"Get"))) {

log_error("Could not allocate message.");

goto oom;

}

if (!dbus_message_append_args(m,

DBUS_TYPE_STRING, &interface,

DBUS_TYPE_STRING, &property,

DBUS_TYPE_INVALID)) {

log_error("Could not append arguments to message.");

goto finish;

}

if (!(reply = dbus_connection_send_with_reply_and_block(connection, m, -1, &error))) {

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

goto finish;

}

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

dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {

log_error("Failed to parse reply.");

goto finish;

}

dbus_message_iter_recurse(&iter, &sub);

if (streq(interface, "org.freedesktop.systemd1.Unit")) {

const char *id;

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

log_error("Failed to parse reply.");

goto finish;

}

dbus_message_iter_get_basic(&sub, &id);

printf("Unit %s changed.\n", id);

} else {

uint32_t id;

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

log_error("Failed to parse reply.");

goto finish;

}

dbus_message_iter_get_basic(&sub, &id);

printf("Job %u changed.\n", id);

}

}

finish:

if (m)

dbus_message_unref(m);

if (reply)

dbus_message_unref(reply);

dbus_error_free(&error);

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

oom:

if (m)

dbus_message_unref(m);

if (reply)

dbus_message_unref(reply);

dbus_error_free(&error);

return DBUS_HANDLER_RESULT_NEED_MEMORY;

}

static int monitor(DBusConnection *bus, char **args, unsigned n) {

DBusMessage *m = NULL, *reply = NULL;

DBusError error;

int r;

dbus_error_init(&error);

if (!private_bus) {

dbus_bus_add_match(bus,

"type='signal',"

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

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

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

&error);

if (dbus_error_is_set(&error)) {

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

r = -EIO;

goto finish;

}

dbus_bus_add_match(bus,

"type='signal',"

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

"interface='org.freedesktop.DBus.Properties',"

"member='PropertiesChanged'",

&error);

if (dbus_error_is_set(&error)) {

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

r = -EIO;

goto finish;

}

}

if (!dbus_connection_add_filter(bus, monitor_filter, NULL, NULL)) {

log_error("Failed to add filter.");

r = -ENOMEM;

goto finish;

}

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",

"/org/freedesktop/systemd1",

"org.freedesktop.systemd1.Manager",

"Subscribe"))) {

log_error("Could not allocate message.");

r = -ENOMEM;

goto finish;

}

if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {

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

r = -EIO;

goto finish;

}

while (dbus_connection_read_write_dispatch(bus, -1))

;

r = 0;

finish:

/* This is slightly dirty, since we don't undo the filter or the matches. */

if (m)

dbus_message_unref(m);

if (reply)

dbus_message_unref(reply);

dbus_error_free(&error);

return r;

}

static int dump(DBusConnection *bus, char **args, unsigned n) {

DBusMessage *m = NULL, *reply = NULL;

DBusError error;

int r;

const char *text;

dbus_error_init(&error);

if (!(m = dbus_message_new_method_call(

"org.freedesktop.systemd1",