/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <sys/mount.h>

#include "af-list.h"

#include "bus-error.h"

#include "bus-locator.h"

#include "bus-map-properties.h"

#include "bus-print-properties.h"

#include "bus-unit-procs.h"

#include "cgroup-show.h"

#include "cpu-set-util.h"

#include "errno-util.h"

#include "exec-util.h"

#include "exit-status.h"

#include "format-util.h"

#include "hexdecoct.h"

#include "hostname-util.h"

#include "in-addr-util.h"

#include "ip-protocol-list.h"

#include "journal-file.h"

#include "list.h"

#include "locale-util.h"

#include "memory-util.h"

#include "numa-util.h"

#include "parse-util.h"

#include "path-util.h"

#include "pretty-print.h"

#include "process-util.h"

#include "signal-util.h"

#include "sort-util.h"

#include "special.h"

#include "string-table.h"

#include "systemctl-list-machines.h"

#include "systemctl-list-units.h"

#include "systemctl-show.h"

#include "systemctl-sysv-compat.h"

#include "systemctl-util.h"

#include "systemctl.h"

#include "terminal-util.h"

#include "utf8.h"

static OutputFlags get_output_flags(void) {

        return

                FLAGS_SET(arg_print_flags, BUS_PRINT_PROPERTY_SHOW_EMPTY) * OUTPUT_SHOW_ALL |

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

                colors_enabled() * OUTPUT_COLOR |

                !arg_quiet * OUTPUT_WARN_CUTOFF;

}

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;

        ExecCommandFlags flags;

        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(sd_bus_message *m, ExecStatusInfo *i, bool is_ex_prop) {

        _cleanup_strv_free_ char **ex_opts = NULL;

        uint64_t start_timestamp, exit_timestamp, start_timestamp_monotonic, exit_timestamp_monotonic;

        const char *path;

        uint32_t pid;

        int32_t code, status;

        int ignore, r;

        assert(m);

        assert(i);

        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_STRUCT, is_ex_prop ? "sasasttttuii" : "sasbttttuii");

        if (r < 0)

                return bus_log_parse_error(r);

        if (r == 0)

                return 0;

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

        if (r < 0)

                return bus_log_parse_error(r);

        i->path = strdup(path);

        if (!i->path)

                return log_oom();

        r = sd_bus_message_read_strv(m, &i->argv);

        if (r < 0)

                return bus_log_parse_error(r);

        r = is_ex_prop ? sd_bus_message_read_strv(m, &ex_opts) : sd_bus_message_read(m, "b", &ignore);

        if (r < 0)

                return bus_log_parse_error(r);

        r = sd_bus_message_read(m,

                                "ttttuii",

                                &start_timestamp, &start_timestamp_monotonic,

                                &exit_timestamp, &exit_timestamp_monotonic,

                                &pid,

                                &code, &status);

        if (r < 0)

                return bus_log_parse_error(r);

        if (is_ex_prop) {

                r = exec_command_flags_from_strv(ex_opts, &i->flags);

                if (r < 0)

                        return log_error_errno(r, "Failed to convert strv to ExecCommandFlags: %m");

                i->ignore = FLAGS_SET(i->flags, EXEC_COMMAND_IGNORE_FAILURE);

        } else

                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;

        r = sd_bus_message_exit_container(m);

        if (r < 0)

                return bus_log_parse_error(r);

        return 1;

}

typedef struct UnitCondition {

        char *name;

        char *param;

        bool trigger;

        bool negate;

        int tristate;

        LIST_FIELDS(struct UnitCondition, conditions);

} UnitCondition;

static UnitCondition* unit_condition_free(UnitCondition *c) {

        if (!c)

                return NULL;

        free(c->name);

        free(c->param);

        return mfree(c);

}

DEFINE_TRIVIAL_CLEANUP_FUNC(UnitCondition*, unit_condition_free);

typedef struct UnitStatusInfo {

        const char *id;

        const char *load_state;

        const char *active_state;

        const char *freezer_state;

        const char *sub_state;

        const char *unit_file_state;

        const char *unit_file_preset;

        const char *description;

        const char *following;

        char **documentation;

        const char *fragment_path;

        const char *source_path;

        const char *control_group;

        char **dropin_paths;

        char **triggered_by;

        char **triggers;

        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;

        uint64_t runtime_max_sec;

        bool need_daemon_reload;

        bool transient;

        /* Service */

        pid_t main_pid;

        pid_t control_pid;

        const char *status_text;

        const char *pid_file;

        bool running:1;

        int status_errno;

        usec_t start_timestamp;

        usec_t exit_timestamp;

        int exit_code, exit_status;

        const char *log_namespace;

        usec_t condition_timestamp;

        bool condition_result;

        LIST_HEAD(UnitCondition, conditions);

        usec_t assert_timestamp;

        bool assert_result;

        bool failed_assert_trigger;

        bool failed_assert_negate;

        const char *failed_assert;

        const char *failed_assert_parameter;

        usec_t next_elapse_real;

        usec_t next_elapse_monotonic;

        /* Socket */

        unsigned n_accepted;

        unsigned n_connections;

        unsigned n_refused;

        bool accept;

        /* Pairs of type, path */

        char **listen;

        /* Device */

        const char *sysfs_path;

        /* Mount, Automount */

        const char *where;

        /* Swap */

        const char *what;

        /* CGroup */

        uint64_t memory_current;

        uint64_t memory_min;

        uint64_t memory_low;

        uint64_t memory_high;

        uint64_t memory_max;

        uint64_t memory_swap_max;

        uint64_t memory_limit;

        uint64_t memory_available;

        uint64_t cpu_usage_nsec;

        uint64_t tasks_current;

        uint64_t tasks_max;

        uint64_t ip_ingress_bytes;

        uint64_t ip_egress_bytes;

        uint64_t io_read_bytes;

        uint64_t io_write_bytes;

        uint64_t default_memory_min;

        uint64_t default_memory_low;

        LIST_HEAD(ExecStatusInfo, exec);

} UnitStatusInfo;

static void unit_status_info_free(UnitStatusInfo *info) {

        ExecStatusInfo *p;

        UnitCondition *c;

        strv_free(info->documentation);

        strv_free(info->dropin_paths);

        strv_free(info->triggered_by);

        strv_free(info->triggers);

        strv_free(info->listen);

        while ((c = info->conditions)) {

                LIST_REMOVE(conditions, info->conditions, c);

                unit_condition_free(c);

        }

        while ((p = info->exec)) {

                LIST_REMOVE(exec, info->exec, p);

                exec_status_info_free(p);

        }

}

static void format_active_state(const char *active_state, const char **active_on, const char **active_off) {

        if (streq_ptr(active_state, "failed")) {

                *active_on = ansi_highlight_red();

                *active_off = ansi_normal();

        } else if (STRPTR_IN_SET(active_state, "active", "reloading")) {

                *active_on = ansi_highlight_green();

                *active_off = ansi_normal();

        } else

                *active_on = *active_off = "";

}

static void format_enable_state(const char *enable_state, const char **enable_on, const char **enable_off) {

        assert(enable_on);

        assert(enable_off);

        if (streq_ptr(enable_state, "disabled")) {

                *enable_on = ansi_highlight_yellow();

                *enable_off = ansi_normal();

        } else if (streq_ptr(enable_state, "enabled")) {

                *enable_on = ansi_highlight_green();

                *enable_off = ansi_normal();

        } else

                *enable_on = *enable_off = "";

}

static void print_status_info(

                sd_bus *bus,

                UnitStatusInfo *i,

                bool *ellipsized) {

        const char *active_on, *active_off, *on, *off, *ss, *fs;

        const char *enable_on, *enable_off, *enable_vendor_on, *enable_vendor_off;

        _cleanup_free_ char *formatted_path = NULL;

        usec_t timestamp;

        const char *path;

        int r;

        assert(i);

        /* This shows pretty information about a unit. See print_property() for a low-level property

         * printer */

        format_active_state(i->active_state, &active_on, &active_off);

        format_enable_state(i->unit_file_state, &enable_on, &enable_off);

        format_enable_state(i->unit_file_preset, &enable_vendor_on, &enable_vendor_off);

        const SpecialGlyph glyph = unit_active_state_to_glyph(unit_active_state_from_string(i->active_state));

        printf("%s%s%s %s", active_on, special_glyph(glyph), active_off, strna(i->id));

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

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

        printf("\n");

        if (i->following)

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

        if (STRPTR_IN_SET(i->load_state, "error", "not-found", "bad-setting")) {

                on = ansi_highlight_red();

                off = ansi_normal();

        } else

                on = off = "";

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

        if (path && terminal_urlify_path(path, NULL, &formatted_path) >= 0)

                path = formatted_path;

        if (!isempty(i->load_error))

                printf("     Loaded: %s%s%s (Reason: %s)\n",

                       on, strna(i->load_state), off, i->load_error);

        else if (path && !isempty(i->unit_file_state)) {

                bool show_preset = !isempty(i->unit_file_preset) &&

                        show_preset_for_state(unit_file_state_from_string(i->unit_file_state));

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

                       on, strna(i->load_state), off,

                       path,

                       enable_on, i->unit_file_state, enable_off,

                       show_preset ? "; vendor preset: " : "",

                       enable_vendor_on, show_preset ? i->unit_file_preset : "", enable_vendor_off);

        } else if (path)

                printf("     Loaded: %s%s%s (%s)\n",

                       on, strna(i->load_state), off, path);

        else

                printf("     Loaded: %s%s%s\n",

                       on, strna(i->load_state), off);

        if (i->transient)

                printf("  Transient: yes\n");

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

                _cleanup_free_ char *dir = NULL;

                bool last = false;

                STRV_FOREACH(dropin, i->dropin_paths) {

                        _cleanup_free_ char *dropin_formatted = NULL;

                        const char *df;

                        if (!dir || last) {

                                printf(dir ? "             " :

                                             "    Drop-In: ");

                                dir = mfree(dir);

                                dir = dirname_malloc(*dropin);

                                if (!dir) {

                                        log_oom();

                                        return;

                                }

                                printf("%s\n"

                                       "             %s", dir,

                                       special_glyph(SPECIAL_GLYPH_TREE_RIGHT));

                        }

                        last = ! (*(dropin + 1) && startswith(*(dropin + 1), dir));

                        if (terminal_urlify_path(*dropin, basename(*dropin), &dropin_formatted) >= 0)

                                df = dropin_formatted;

                        else

                                df = *dropin;

                        printf("%s%s", df, last ? "\n" : ", ");

                }

        }

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

        if (ss)

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

                       active_on, strna(i->active_state), ss, active_off);

        else

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

                       active_on, strna(i->active_state), active_off);

        fs = !isempty(i->freezer_state) && !streq(i->freezer_state, "running") ? i->freezer_state : NULL;

        if (fs)

                printf(" %s(%s)%s", ansi_highlight_yellow(), fs, ansi_normal());

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

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

        timestamp = STRPTR_IN_SET(i->active_state, "active", "reloading") ? i->active_enter_timestamp :

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

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

                                                                            i->active_exit_timestamp;

        if (timestamp_is_set(timestamp)) {

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

                       FORMAT_TIMESTAMP_STYLE(timestamp, arg_timestamp_style),

                       FORMAT_TIMESTAMP_RELATIVE(timestamp));

                if (streq_ptr(i->active_state, "active") && i->runtime_max_sec < USEC_INFINITY) {

                        usec_t until_timestamp;

                        until_timestamp = usec_add(timestamp, i->runtime_max_sec);

                        printf("      Until: %s; %s\n",

                               FORMAT_TIMESTAMP_STYLE(until_timestamp, arg_timestamp_style),

                               FORMAT_TIMESTAMP_RELATIVE(until_timestamp));

                }

                if (!endswith(i->id, ".target") &&

                        STRPTR_IN_SET(i->active_state, "inactive", "failed") &&

                        timestamp_is_set(i->active_enter_timestamp) &&

                        timestamp_is_set(i->active_exit_timestamp) &&

                        i->active_exit_timestamp >= i->active_enter_timestamp) {

                        usec_t duration;

                        duration = i->active_exit_timestamp - i->active_enter_timestamp;

                        printf("   Duration: %s\n", FORMAT_TIMESPAN(duration, MSEC_PER_SEC));

                }

        } else

                printf("\n");

        STRV_FOREACH(t, i->triggered_by) {

                UnitActiveState state = _UNIT_ACTIVE_STATE_INVALID;

                (void) get_state_one_unit(bus, *t, &state);

                format_active_state(unit_active_state_to_string(state), &on, &off);

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

                       t == i->triggered_by ? "TriggeredBy:" : "            ",

                       on, special_glyph(unit_active_state_to_glyph(state)), off,

                       *t);

        }

        if (endswith(i->id, ".timer")) {

                dual_timestamp nw, next = {i->next_elapse_real, i->next_elapse_monotonic};

                usec_t next_elapse;

                dual_timestamp_get(&nw);

                next_elapse = calc_next_elapse(&nw, &next);

                if (timestamp_is_set(next_elapse))

                        printf("    Trigger: %s; %s\n",

                               FORMAT_TIMESTAMP_STYLE(next_elapse, arg_timestamp_style),

                               FORMAT_TIMESTAMP_RELATIVE(next_elapse));

                else

                        printf("    Trigger: n/a\n");

        }

        STRV_FOREACH(t, i->triggers) {

                UnitActiveState state = _UNIT_ACTIVE_STATE_INVALID;

                (void) get_state_one_unit(bus, *t, &state);

                format_active_state(unit_active_state_to_string(state), &on, &off);

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

                       t == i->triggers ? "   Triggers:" : "            ",

                       on, special_glyph(SPECIAL_GLYPH_BLACK_CIRCLE), off,

                       *t);

        }

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

                int n = 0;

                printf("  Condition: start %scondition failed%s at %s; %s\n",

                       ansi_highlight_yellow(), ansi_normal(),

                       FORMAT_TIMESTAMP_STYLE(i->condition_timestamp, arg_timestamp_style),

                       FORMAT_TIMESTAMP_RELATIVE(i->condition_timestamp));

                LIST_FOREACH(conditions, c, i->conditions)

                        if (c->tristate < 0)

                                n++;

                LIST_FOREACH(conditions, c, i->conditions)

                        if (c->tristate < 0)

                                printf("             %s %s=%s%s%s was not met\n",

                                       --n ? special_glyph(SPECIAL_GLYPH_TREE_BRANCH) : special_glyph(SPECIAL_GLYPH_TREE_RIGHT),

                                       c->name,

                                       c->trigger ? "|" : "",

                                       c->negate ? "!" : "",

                                       c->param);

        }

        if (!i->assert_result && i->assert_timestamp > 0) {

                printf("     Assert: start %sassertion failed%s at %s; %s\n",

                       ansi_highlight_red(), ansi_normal(),

                       FORMAT_TIMESTAMP_STYLE(i->assert_timestamp, arg_timestamp_style),

                       FORMAT_TIMESTAMP_RELATIVE(i->assert_timestamp));

                if (i->failed_assert_trigger)

                        printf("             none of the trigger assertions were met\n");

                else if (i->failed_assert)

                        printf("             %s=%s%s was not met\n",

                               i->failed_assert,

                               i->failed_assert_negate ? "!" : "",

                               i->failed_assert_parameter);

        }

        if (i->sysfs_path)

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

        if (i->where)

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

        if (i->what)

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

        STRV_FOREACH(t, i->documentation) {

                _cleanup_free_ char *formatted = NULL;

                const char *q;

                if (terminal_urlify(*t, NULL, &formatted) >= 0)

                        q = formatted;

                else

                        q = *t;

                printf("   %*s %s\n", 9, t == i->documentation ? "Docs:" : "", q);

        }

        STRV_FOREACH_PAIR(t, t2, i->listen)

                printf("   %*s %s (%s)\n", 9, t == i->listen ? "Listen:" : "", *t2, *t);

        if (i->accept) {

                printf("   Accepted: %u; Connected: %u;", i->n_accepted, i->n_connections);

                if (i->n_refused)

                        printf("   Refused: %u", i->n_refused);

                printf("\n");

        }

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

                _cleanup_free_ char *argv = NULL;

                bool good;

                /* Only show exited processes here */

                if (p->code == 0)

                        continue;

                /* Don't print ExecXYZEx= properties here since it will appear as a

                 * duplicate of the non-Ex= variant. */

                if (endswith(p->name, "Ex"))

                        continue;

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

                printf("    Process: "PID_FMT" %s=%s ", p->pid, p->name, strna(argv));

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

                if (!good) {

                        on = ansi_highlight_red();

                        off = ansi_normal();

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

                if (i->main_pid > 0) {

                        printf("   Main PID: "PID_FMT, i->main_pid);

                        if (i->running) {

                                if (arg_transport == BUS_TRANSPORT_LOCAL) {

                                        _cleanup_free_ char *comm = NULL;

                                        (void) get_process_comm(i->main_pid, &comm);

                                        if (comm)

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

                                }

                        } 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_LIBC | EXIT_STATUS_SYSTEMD);

                                        if (c)

                                                printf("/%s", c);

                                } else

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

                                printf(")");

                        }

                }

                if (i->control_pid > 0) {

                        _cleanup_free_ char *c = NULL;

                        if (i->main_pid > 0)

                                fputs("; Control PID: ", stdout);

                        else

                                fputs("Cntrl PID: ", stdout); /* if first in column, abbreviated so it fits alignment */

                        printf(PID_FMT, i->control_pid);

                        if (arg_transport == BUS_TRANSPORT_LOCAL) {

                                (void) get_process_comm(i->control_pid, &c);

                                if (c)

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

                        }

                }

                printf("\n");

        }

        if (i->status_text)

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

        if (i->status_errno > 0)

                printf("      Error: %i (%s)\n", i->status_errno, strerror_safe(i->status_errno));

        if (i->ip_ingress_bytes != UINT64_MAX && i->ip_egress_bytes != UINT64_MAX)

                printf("         IP: %s in, %s out\n",

                       FORMAT_BYTES(i->ip_ingress_bytes),

                       FORMAT_BYTES(i->ip_egress_bytes));

        if (i->io_read_bytes != UINT64_MAX && i->io_write_bytes != UINT64_MAX)

                printf("         IO: %s read, %s written\n",

                        FORMAT_BYTES(i->io_read_bytes),

                        FORMAT_BYTES(i->io_write_bytes));

        if (i->tasks_current != UINT64_MAX) {

                printf("      Tasks: %" PRIu64, i->tasks_current);

                if (i->tasks_max != UINT64_MAX)

                        printf(" (limit: %" PRIu64 ")\n", i->tasks_max);

                else

                        printf("\n");

        }

        if (i->memory_current != UINT64_MAX) {

                printf("     Memory: %s", FORMAT_BYTES(i->memory_current));

                if (i->memory_min > 0 || i->memory_low > 0 ||

                    i->memory_high != CGROUP_LIMIT_MAX || i->memory_max != CGROUP_LIMIT_MAX ||

                    i->memory_swap_max != CGROUP_LIMIT_MAX ||

                    i->memory_available != CGROUP_LIMIT_MAX ||

                    i->memory_limit != CGROUP_LIMIT_MAX) {

                        const char *prefix = "";

                        printf(" (");

                        if (i->memory_min > 0) {

                                printf("%smin: %s", prefix, FORMAT_BYTES_CGROUP_PROTECTION(i->memory_min));

                                prefix = " ";

                        }

                        if (i->memory_low > 0) {

                                printf("%slow: %s", prefix, FORMAT_BYTES_CGROUP_PROTECTION(i->memory_low));

                                prefix = " ";

                        }

                        if (i->memory_high != CGROUP_LIMIT_MAX) {

                                printf("%shigh: %s", prefix, FORMAT_BYTES(i->memory_high));

                                prefix = " ";

                        }

                        if (i->memory_max != CGROUP_LIMIT_MAX) {

                                printf("%smax: %s", prefix, FORMAT_BYTES(i->memory_max));

                                prefix = " ";

                        }

                        if (i->memory_swap_max != CGROUP_LIMIT_MAX) {

                                printf("%sswap max: %s", prefix, FORMAT_BYTES(i->memory_swap_max));

                                prefix = " ";

                        }

                        if (i->memory_limit != CGROUP_LIMIT_MAX) {

                                printf("%slimit: %s", prefix, FORMAT_BYTES(i->memory_limit));

                                prefix = " ";

                        }

                        if (i->memory_available != CGROUP_LIMIT_MAX) {

                                printf("%savailable: %s", prefix, FORMAT_BYTES(i->memory_available));

                                prefix = " ";

                        }

                        printf(")");

                }

                printf("\n");

        }

        if (i->cpu_usage_nsec != UINT64_MAX)

                printf("        CPU: %s\n", FORMAT_TIMESPAN(i->cpu_usage_nsec / NSEC_PER_USEC, USEC_PER_MSEC));

        if (i->control_group) {

                _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;

                static const char prefix[] = "             ";

                unsigned c;

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

                c = LESS_BY(columns(), strlen(prefix));

                r = unit_show_processes(bus, i->id, i->control_group, prefix, c, get_output_flags(), &error);

                if (r == -EBADR && arg_transport == BUS_TRANSPORT_LOCAL) {

                        unsigned k = 0;

                        pid_t extra[2];

                        /* Fallback for older systemd versions where the GetUnitProcesses() call is not yet available */

                        if (i->main_pid > 0)

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

                        if (i->control_pid > 0)

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

                        show_cgroup_and_extra(SYSTEMD_CGROUP_CONTROLLER, i->control_group, prefix, c, extra, k, get_output_flags());

                } else if (r < 0)

                        log_warning_errno(r, "Failed to dump process list for '%s', ignoring: %s",

                                          i->id, bus_error_message(&error, r));

        }

        if (i->id && arg_transport == BUS_TRANSPORT_LOCAL)

                show_journal_by_unit(

                                stdout,

                                i->id,

                                i->log_namespace,

                                arg_output,

                                0,

                                i->inactive_exit_timestamp_monotonic,

                                arg_lines,

                                getuid(),

                                get_output_flags() | OUTPUT_BEGIN_NEWLINE,

                                SD_JOURNAL_LOCAL_ONLY,

                                arg_scope == LOOKUP_SCOPE_SYSTEM,

                                ellipsized);

        if (i->need_daemon_reload)

                warn_unit_file_changed(i->id);

}

static void show_unit_help(UnitStatusInfo *i) {

        assert(i);

        if (!i->documentation) {

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

                return;

        }

        STRV_FOREACH(p, i->documentation)

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

                        show_man_page(*p + 4, false);

                else

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

}

static int map_main_pid(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {

        UnitStatusInfo *i = userdata;

        uint32_t u;

        int r;

        r = sd_bus_message_read(m, "u", &u);

        if (r < 0)

                return r;

        i->main_pid = (pid_t) u;

        i->running = u > 0;

        return 0;

}

static int map_load_error(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {

        const char *message, **p = userdata;

        int r;

        r = sd_bus_message_read(m, "(ss)", NULL, &message);

        if (r < 0)

                return r;

        if (!isempty(message))

                *p = message;

        return 0;

}

static int map_listen(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {

        const char *type, *path;

        char ***p = userdata;

        int r;

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

        if (r < 0)

                return r;

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

                r = strv_extend(p, type);

                if (r < 0)

                        return r;

                r = strv_extend(p, path);

                if (r < 0)

                        return r;

        }

        if (r < 0)

                return r;

        r = sd_bus_message_exit_container(m);

        if (r < 0)

                return r;

        return 0;

}

static int map_conditions(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {

        UnitStatusInfo *i = userdata;

        const char *cond, *param;

        int trigger, negate;

        int32_t state;

        int r;