HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/systemctl/systemctl-show.c

121,554 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 9ef3bbf51f8389fb7cac470db0bab366dffd29ad

Lines 1001–2000 of 2,637

 
        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_many(p, type, 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;
 
        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sbbsi)");
        if (r < 0)
                return r;
 
        while ((r = sd_bus_message_read(m, "(sbbsi)", &cond, &trigger, &negate, &param, &state)) > 0) {
                _cleanup_(unit_condition_freep) UnitCondition *c = NULL;
 
                c = new(UnitCondition, 1);
                if (!c)
                        return -ENOMEM;
 
                *c = (UnitCondition) {
                        .name = strdup(cond),
                        .param = strdup(param),
                        .trigger = trigger,
                        .negate = negate,
                        .tristate = state,
                };
 
                if (!c->name || !c->param)
                        return -ENOMEM;
 
                LIST_PREPEND(conditions, i->conditions, TAKE_PTR(c));
        }
        if (r < 0)
                return r;
 
        r = sd_bus_message_exit_container(m);
        if (r < 0)
                return r;
 
        return 0;
}
 
static int map_asserts(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;
 
        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sbbsi)");
        if (r < 0)
                return r;
 
        while ((r = sd_bus_message_read(m, "(sbbsi)", &cond, &trigger, &negate, &param, &state)) > 0) {
                if (state < 0 && (!trigger || !i->failed_assert)) {
                        i->failed_assert = cond;
                        i->failed_assert_trigger = trigger;
                        i->failed_assert_negate = negate;
                        i->failed_assert_parameter = param;
                }
        }
        if (r < 0)
                return r;
 
        r = sd_bus_message_exit_container(m);
        if (r < 0)
                return r;
 
        return 0;
}
 
static int map_exec(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
        _cleanup_free_ ExecStatusInfo *info = NULL;
        ExecStatusInfo *last;
        UnitStatusInfo *i = userdata;
        bool is_ex_prop = endswith(member, "Ex");
        int r;
 
        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, is_ex_prop ? "(sasasttttuii)" : "(sasbttttuii)");
        if (r < 0)
                return r;
 
        info = new0(ExecStatusInfo, 1);
        if (!info)
                return -ENOMEM;
 
        last = LIST_FIND_TAIL(exec_status_info_list, i->exec_status_info_list);
 
        while ((r = exec_status_info_deserialize(m, info, is_ex_prop)) > 0) {
 
                info->name = strdup(member);
                if (!info->name)
                        return -ENOMEM;
 
                LIST_INSERT_AFTER(exec_status_info_list, i->exec_status_info_list, last, info);
                last = info;
 
                info = new0(ExecStatusInfo, 1);
                if (!info)
                        return -ENOMEM;
        }
        if (r < 0)
                return r;
 
        r = sd_bus_message_exit_container(m);
        if (r < 0)
                return r;
 
        return 0;
}
 
static int map_quota(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
        int r;
        QuotaInfo *qi = ASSERT_PTR(userdata);
        uint64_t quota_usage, quota_limit;
 
        r = sd_bus_message_read(m, "(tt)", &quota_usage, &quota_limit);
        if (r < 0)
                return r;
 
        *qi = (QuotaInfo) {
                .quota_enforce = quota_limit != UINT64_MAX,
                .quota_accounting = quota_usage != UINT64_MAX,
                .quota_usage = quota_usage,
                .quota_limit = quota_limit
        };
 
        return 0;
}
 
static int print_property(
                const char *name,
                const char *expected_value,
                char type,
                const char *contents,
                sd_bus_message *m,
                BusPrintPropertyFlags flags) {
 
        int r;
 
        assert(name);
        assert(m);
 
        /* This is a low-level property printer, see print_status_info() for the nicer output */
 
        switch (type) {
 
        case SD_BUS_TYPE_INT32:
                if (endswith(name, "ActionExitStatus")) {
                        int32_t i;
 
                        r = sd_bus_message_read_basic(m, type, &i);
                        if (r < 0)
                                return r;
 
                        if (i >= 0 && i <= 255)
                                bus_print_property_valuef(name, expected_value, flags, "%"PRIi32, i);
                        else if (FLAGS_SET(flags, BUS_PRINT_PROPERTY_SHOW_EMPTY))
                                bus_print_property_value(name, expected_value, flags, "[not set]");
 
                        return 1;
                } else if (streq(name, "NUMAPolicy")) {
                        int32_t i;
 
                        r = sd_bus_message_read_basic(m, type, &i);
                        if (r < 0)
                                return r;
 
                        bus_print_property_valuef(name, expected_value, flags, "%s", strna(mpol_to_string(i)));
 
                        return 1;
                }
                break;
 
        case SD_BUS_TYPE_UINT64:
                if (bus_property_is_timestamp(name)) {
                        uint64_t timestamp;
 
                        r = sd_bus_message_read_basic(m, type, &timestamp);
                        if (r < 0)
                                return r;
 
                        bus_print_property_value(name, expected_value, flags, FORMAT_TIMESTAMP_STYLE(timestamp, arg_timestamp_style));
 
                        return 1;
                }
                break;
 
        case SD_BUS_TYPE_STRUCT:
 
                if (contents[0] == SD_BUS_TYPE_UINT32 && streq(name, "Job")) {
                        uint32_t u;
 
                        r = sd_bus_message_read(m, "(uo)", &u, NULL);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        if (u > 0)
                                bus_print_property_valuef(name, expected_value, flags, "%"PRIu32, u);
                        else
                                bus_print_property_value(name, expected_value, flags, NULL);
 
                        return 1;
 
                } else if (contents[0] == SD_BUS_TYPE_STRING && streq(name, "Unit")) {
                        const char *s;
 
                        r = sd_bus_message_read(m, "(so)", &s, NULL);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        bus_print_property_value(name, expected_value, flags, s);
 
                        return 1;
 
                } else if (contents[0] == SD_BUS_TYPE_STRING && streq(name, "LoadError")) {
                        const char *a = NULL, *b = NULL;
 
                        r = sd_bus_message_read(m, "(ss)", &a, &b);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        if (!isempty(a) || !isempty(b))
                                bus_print_property_valuef(name, expected_value, flags, "%s \"%s\"", strempty(a), strempty(b));
                        else
                                bus_print_property_value(name, expected_value, flags, NULL);
 
                        return 1;
 
                } else if (STR_IN_SET(name, "SystemCallFilter", "SystemCallLog", "RestrictAddressFamilies", "RestrictNetworkInterfaces", "RestrictFileSystems")) {
                        _cleanup_strv_free_ char **l = NULL;
                        int allow_list;
 
                        r = sd_bus_message_enter_container(m, 'r', "bas");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_read(m, "b", &allow_list);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_read_strv(m, &l);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        if (FLAGS_SET(flags, BUS_PRINT_PROPERTY_SHOW_EMPTY) || allow_list || !strv_isempty(l)) {
                                bool first = true;
 
                                if (!FLAGS_SET(flags, BUS_PRINT_PROPERTY_ONLY_VALUE)) {
                                        fputs(name, stdout);
                                        fputc('=', stdout);
                                }
 
                                if (!allow_list)
                                        fputc('~', stdout);
 
                                STRV_FOREACH(i, l) {
                                        if (first)
                                                first = false;
                                        else
                                                fputc(' ', stdout);
 
                                        fputs(*i, stdout);
                                }
                                fputc('\n', stdout);
                        }
 
                        return 1;
 
                } else if (STR_IN_SET(name, "SELinuxContext", "AppArmorProfile", "SmackProcessLabel")) {
                        int ignore;
                        const char *s;
 
                        r = sd_bus_message_read(m, "(bs)", &ignore, &s);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        if (!isempty(s))
                                bus_print_property_valuef(name, expected_value, flags, "%s%s", ignore ? "-" : "", s);
                        else
                                bus_print_property_value(name, expected_value, flags, NULL);
 
                        return 1;
 
                } else if (endswith(name, "ExitStatus") && streq(contents, "aiai")) {
                        const int32_t *status, *signal;
                        size_t n_status, n_signal;
 
                        r = sd_bus_message_enter_container(m, 'r', "aiai");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_read_array(m, 'i', (const void **) &status, &n_status);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_read_array(m, 'i', (const void **) &signal, &n_signal);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        n_status /= sizeof(int32_t);
                        n_signal /= sizeof(int32_t);
 
                        if (FLAGS_SET(flags, BUS_PRINT_PROPERTY_SHOW_EMPTY) || n_status > 0 || n_signal > 0) {
                                bool first = true;
 
                                if (!FLAGS_SET(flags, BUS_PRINT_PROPERTY_ONLY_VALUE)) {
                                        fputs(name, stdout);
                                        fputc('=', stdout);
                                }
 
                                for (size_t i = 0; i < n_status; i++) {
                                        if (first)
                                                first = false;
                                        else
                                                fputc(' ', stdout);
 
                                        printf("%"PRIi32, status[i]);
                                }
 
                                for (size_t i = 0; i < n_signal; i++) {
                                        const char *str;
 
                                        str = signal_to_string((int) signal[i]);
 
                                        if (first)
                                                first = false;
                                        else
                                                fputc(' ', stdout);
 
                                        if (str)
                                                fputs(str, stdout);
                                        else
                                                printf("%"PRIi32, status[i]);
                                }
 
                                fputc('\n', stdout);
                        }
                        return 1;
                } else if (STR_IN_SET(name, "StateDirectoryQuota", "CacheDirectoryQuota", "LogsDirectoryQuota")) {
                        uint64_t quota_absolute;
                        uint32_t quota_scale;
                        const char *quota_enforce;
 
                        r = sd_bus_message_read(m, "(tus)", &quota_absolute, &quota_scale, &quota_enforce);
                        if (r < 0)
                                return r;
 
                        r = parse_boolean(quota_enforce);
                        if (r < 0)
                                return r;
 
                        if (!r)
                                bus_print_property_value(name, expected_value, flags, "[not set]");
                        else if (quota_absolute != UINT64_MAX)
                                bus_print_property_valuef(name, expected_value, flags, "%" PRIu64, quota_absolute);
                        else
                                bus_print_property_valuef(name, expected_value, flags, "%d%%", UINT32_SCALE_TO_PERCENT(quota_scale));
 
                        return 1;
                }
 
                break;
 
        case SD_BUS_TYPE_ARRAY:
 
                if (contents[0] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "EnvironmentFiles")) {
                        const char *path;
                        int ignore;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sb)");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        while ((r = sd_bus_message_read(m, "(sb)", &path, &ignore)) > 0)
                                bus_print_property_valuef(name, expected_value, flags, "%s (ignore_errors=%s)", path, yes_no(ignore));
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        return 1;
 
                } else if (contents[0] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Paths")) {
                        const char *entry_type, *path;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        while ((r = sd_bus_message_read(m, "(ss)", &entry_type, &path)) > 0)
                                bus_print_property_valuef(name, expected_value, flags, "%s (%s)", path, entry_type);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        return 1;
 
                } else if (contents[0] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Listen")) {
                        const char *entry_type, *path;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        while ((r = sd_bus_message_read(m, "(ss)", &entry_type, &path)) > 0)
                                bus_print_property_valuef(name, expected_value, flags, "%s (%s)", path, entry_type);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        return 1;
 
                } else if (contents[0] == SD_BUS_TYPE_STRUCT_BEGIN &&
                           STR_IN_SET(name, "XAttrEntryPoint", "XAttrListen", "XAttrAccept")) {
                        const char *xname, *xvalue;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        while ((r = sd_bus_message_read(m, "(ss)", &xname, &xvalue)) > 0)
                                bus_print_property_valuef(name, expected_value, flags, "%s=%s", xname, xvalue);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        return 1;
 
                } else if (contents[0] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "TimersMonotonic")) {
                        const char *base;
                        uint64_t v, next_elapse;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(stt)");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        while ((r = sd_bus_message_read(m, "(stt)", &base, &v, &next_elapse)) > 0)
                                bus_print_property_valuef(name, expected_value, flags,
                                                          "{ %s=%s ; next_elapse=%s }",
                                                          base,
                                                          strna(FORMAT_TIMESPAN(v, 0)),
                                                          strna(FORMAT_TIMESPAN(next_elapse, 0)));
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        return 1;
 
                } else if (contents[0] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "TimersCalendar")) {
                        const char *base, *spec;
                        uint64_t next_elapse;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sst)");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        while ((r = sd_bus_message_read(m, "(sst)", &base, &spec, &next_elapse)) > 0)
                                bus_print_property_valuef(name, expected_value, flags,
                                                          "{ %s=%s ; next_elapse=%s }", base, spec,
                                                          FORMAT_TIMESTAMP_STYLE(next_elapse, arg_timestamp_style));
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        return 1;
 
                } else if (contents[0] == SD_BUS_TYPE_STRUCT_BEGIN && startswith(name, "Exec")) {
                        ExecStatusInfo info = {};
                        bool is_ex_prop = endswith(name, "Ex");
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, is_ex_prop ? "(sasasttttuii)" : "(sasbttttuii)");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        while ((r = exec_status_info_deserialize(m, &info, is_ex_prop)) > 0) {
                                _cleanup_strv_free_ char **optv = NULL;
                                _cleanup_free_ char *tt = NULL, *o = NULL;
 
                                tt = strv_join(info.argv, " ");
 
                                if (is_ex_prop) {
                                        r = exec_command_flags_to_strv(info.flags, &optv);
                                        if (r < 0)
                                                return log_error_errno(r, "Failed to convert ExecCommandFlags to strv: %m");
 
                                        o = strv_join(optv, " ");
 
                                        bus_print_property_valuef(name, expected_value, flags,
                                                                  "{ path=%s ; argv[]=%s ; flags=%s ; start_time=[%s] ; stop_time=[%s] ; pid="PID_FMT" ; code=%s ; status=%i%s%s }",
                                                                  strna(info.path),
                                                                  strna(tt),
                                                                  strna(o),
                                                                  strna(FORMAT_TIMESTAMP_STYLE(info.start_timestamp, arg_timestamp_style)),
                                                                  strna(FORMAT_TIMESTAMP_STYLE(info.exit_timestamp, arg_timestamp_style)),
                                                                  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)));
                                } else
                                        bus_print_property_valuef(name, expected_value, flags,
                                                                  "{ path=%s ; argv[]=%s ; ignore_errors=%s ; start_time=[%s] ; stop_time=[%s] ; pid="PID_FMT" ; code=%s ; status=%i%s%s }",
                                                                  strna(info.path),
                                                                  strna(tt),
                                                                  yes_no(info.ignore),
                                                                  strna(FORMAT_TIMESTAMP_STYLE(info.start_timestamp, arg_timestamp_style)),
                                                                  strna(FORMAT_TIMESTAMP_STYLE(info.exit_timestamp, arg_timestamp_style)),
                                                                  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(info.path);
                                strv_free(info.argv);
                                zero(info);
                        }
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        return 1;
 
                } else if (contents[0] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "DeviceAllow")) {
                        const char *path, *rwm;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        while ((r = sd_bus_message_read(m, "(ss)", &path, &rwm)) > 0)
                                bus_print_property_valuef(name, expected_value, flags, "%s %s", strna(path), strna(rwm));
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        return 1;
 
                } else if (contents[0] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "IODeviceWeight")) {
                        const char *path;
                        uint64_t weight;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(st)");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        while ((r = sd_bus_message_read(m, "(st)", &path, &weight)) > 0)
                                bus_print_property_valuef(name, expected_value, flags, "%s %"PRIu64, strna(path), weight);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        return 1;
 
                } else if (contents[0] == SD_BUS_TYPE_STRUCT_BEGIN &&
                           cgroup_io_limit_type_from_string(name) >= 0) {
                        const char *path;
                        uint64_t bandwidth;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(st)");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        while ((r = sd_bus_message_read(m, "(st)", &path, &bandwidth)) > 0)
                                bus_print_property_valuef(name, expected_value, flags, "%s %"PRIu64, strna(path), bandwidth);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        return 1;
 
                }  else if (contents[0] == SD_BUS_TYPE_STRUCT_BEGIN &&
                            streq(name, "IODeviceLatencyTargetUSec")) {
                        const char *path;
                        uint64_t target;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(st)");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        while ((r = sd_bus_message_read(m, "(st)", &path, &target)) > 0)
                                bus_print_property_valuef(name, expected_value, flags, "%s %s", strna(path),
                                                          FORMAT_TIMESPAN(target, 1));
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        return 1;
 
                } else if (contents[0] == SD_BUS_TYPE_BYTE && STR_IN_SET(name, "StandardInputData", "RootHashSignature")) {
                        _cleanup_free_ char *h = NULL;
                        const void *p;
                        size_t sz;
                        ssize_t n;
 
                        r = sd_bus_message_read_array(m, 'y', &p, &sz);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        n = base64mem(p, sz, &h);
                        if (n < 0)
                                return log_oom();
 
                        bus_print_property_value(name, expected_value, flags, h);
 
                        return 1;
 
                } else if (STR_IN_SET(name, "IPAddressAllow", "IPAddressDeny")) {
                        _cleanup_free_ char *addresses = NULL;
 
                        r = sd_bus_message_enter_container(m, 'a', "(iayu)");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        for (;;) {
                                uint32_t prefixlen;
                                int32_t family;
                                const void *ap;
                                size_t an;
 
                                r = sd_bus_message_enter_container(m, 'r', "iayu");
                                if (r < 0)
                                        return bus_log_parse_error(r);
                                if (r == 0)
                                        break;
 
                                r = sd_bus_message_read(m, "i", &family);
                                if (r < 0)
                                        return bus_log_parse_error(r);
 
                                r = sd_bus_message_read_array(m, 'y', &ap, &an);
                                if (r < 0)
                                        return bus_log_parse_error(r);
 
                                r = sd_bus_message_read(m, "u", &prefixlen);
                                if (r < 0)
                                        return bus_log_parse_error(r);
 
                                r = sd_bus_message_exit_container(m);
                                if (r < 0)
                                        return bus_log_parse_error(r);
 
                                if (!IN_SET(family, AF_INET, AF_INET6))
                                        continue;
 
                                if (an != FAMILY_ADDRESS_SIZE(family))
                                        continue;
 
                                if (prefixlen > FAMILY_ADDRESS_SIZE(family) * 8)
                                        continue;
 
                                if (!strextend_with_separator(&addresses, " ",
                                                              IN_ADDR_PREFIX_TO_STRING(family, ap, prefixlen)))
                                        return log_oom();
                        }
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        bus_print_property_value(name, expected_value, flags, addresses);
 
                        return 1;
 
                } else if (STR_IN_SET(name, "BindPaths", "BindReadOnlyPaths")) {
                        _cleanup_free_ char *paths = NULL;
                        const char *source, *dest;
                        int ignore_enoent;
                        uint64_t rbind;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ssbt)");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        while ((r = sd_bus_message_read(m, "(ssbt)", &source, &dest, &ignore_enoent, &rbind)) > 0) {
                                _cleanup_free_ char *str = NULL;
 
                                if (isempty(source))
                                        continue;
 
                                if (asprintf(&str, "%s%s%s%s%s",
                                             ignore_enoent ? "-" : "",
                                             source,
                                             isempty(dest) ? "" : ":",
                                             strempty(dest),
                                             rbind == MS_REC ? ":rbind" : "") < 0)
                                        return log_oom();
 
                                if (!strextend_with_separator(&paths, " ", str))
                                        return log_oom();
                        }
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        bus_print_property_value(name, expected_value, flags, paths);
 
                        return 1;
 
                } else if (streq(name, "TemporaryFileSystem")) {
                        _cleanup_free_ char *paths = NULL;
                        const char *target, *option;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        while ((r = sd_bus_message_read(m, "(ss)", &target, &option)) > 0) {
                                _cleanup_free_ char *str = NULL;
 
                                if (isempty(target))
                                        continue;
 
                                if (asprintf(&str, "%s%s%s", target, isempty(option) ? "" : ":", strempty(option)) < 0)
                                        return log_oom();
 
                                if (!strextend_with_separator(&paths, " ", str))
                                        return log_oom();
                        }
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        bus_print_property_value(name, expected_value, flags, paths);
 
                        return 1;
 
                } else if (streq(name, "LogExtraFields")) {
                        _cleanup_free_ char *fields = NULL;
                        const void *p;
                        size_t sz;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "ay");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        while ((r = sd_bus_message_read_array(m, 'y', &p, &sz)) > 0) {
                                _cleanup_free_ char *str = NULL;
                                const char *eq;
 
                                if (memchr(p, 0, sz))
                                        continue;
 
                                eq = memchr(p, '=', sz);
                                if (!eq)
                                        continue;
 
                                if (!journal_field_valid(p, eq - (const char*) p, false))
                                        continue;
 
                                str = malloc(sz + 1);
                                if (!str)
                                        return log_oom();
 
                                memcpy(str, p, sz);
                                str[sz] = '\0';
 
                                if (!utf8_is_valid(str))
                                        continue;
 
                                if (!strextend_with_separator(&fields, " ", str))
                                        return log_oom();
                        }
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        bus_print_property_value(name, expected_value, flags, fields);
 
                        return 1;
                } else if (contents[0] == SD_BUS_TYPE_BYTE &&
                           STR_IN_SET(name,
                                      "CPUAffinity", "NUMAMask", "AllowedCPUs", "AllowedMemoryNodes",
                                      "EffectiveCPUs", "EffectiveMemoryNodes")) {
 
                        _cleanup_free_ char *affinity = NULL;
                        _cleanup_(cpu_set_done) CPUSet set = {};
                        const void *a;
                        size_t n;
 
                        r = sd_bus_message_read_array(m, 'y', &a, &n);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = cpu_set_from_dbus(a, n, &set);
                        if (r < 0)
                                return log_error_errno(r, "Failed to deserialize %s: %m", name);
 
                        affinity = cpu_set_to_range_string(&set);
                        if (!affinity)
                                return log_oom();
 
                        bus_print_property_value(name, expected_value, flags, affinity);
 
                        return 1;
                } else if (streq(name, "LogFilterPatterns")) {
                        int is_allowlist;
                        const char *pattern;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(bs)");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        while ((r = sd_bus_message_read(m, "(bs)", &is_allowlist, &pattern)) > 0)
                                bus_print_property_valuef(name, expected_value, flags, "%s%s", is_allowlist ? "" : "~", pattern);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        return 1;
 
                } else if (streq(name, "RootImageOptions")) {
                        const char *a, *p;
 
                        /* In config files, the syntax allows the partition name to be omitted. Here, we
                         * always print the partition name, also because we have no way of knowing if it was
                         * originally omitted or not. We also print the partitions on separate lines. */
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        while ((r = sd_bus_message_read(m, "(ss)", &a, &p)) > 0)
                                bus_print_property_valuef(name, expected_value, flags, "%s:%s", a, p);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        return 1;
 
                } else if (streq(name, "MountImages")) {
                        _cleanup_free_ char *paths = NULL;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ssba(ss))");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        for (;;) {
                                _cleanup_free_ char *str = NULL;
                                const char *source, *destination, *partition, *mount_options;
                                int ignore_enoent;
 
                                r = sd_bus_message_enter_container(m, 'r', "ssba(ss)");
                                if (r < 0)
                                        return bus_log_parse_error(r);
                                if (r == 0)
                                        break;
 
                                r = sd_bus_message_read(m, "ssb", &source, &destination, &ignore_enoent);
                                if (r < 0)
                                        return bus_log_parse_error(r);
 
                                str = strjoin(ignore_enoent ? "-" : "",
                                              source,
                                              ":",
                                              destination);
                                if (!str)
                                        return log_oom();
 
                                r = sd_bus_message_enter_container(m, 'a', "(ss)");
                                if (r < 0)
                                        return bus_log_parse_error(r);
 
                                while ((r = sd_bus_message_read(m, "(ss)", &partition, &mount_options)) > 0)
                                        if (!strextend_with_separator(&str, ":", partition, mount_options))
                                                return log_oom();
                                if (r < 0)
                                        return bus_log_parse_error(r);
 
                                if (!strextend_with_separator(&paths, " ", str))
                                        return log_oom();
 
                                r = sd_bus_message_exit_container(m);
                                if (r < 0)
                                        return bus_log_parse_error(r);
 
                                r = sd_bus_message_exit_container(m);
                                if (r < 0)
                                        return bus_log_parse_error(r);
                        }
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        bus_print_property_value(name, expected_value, flags, paths);
 
                        return 1;
 
                } else if (streq(name, "ExtensionImages")) {
                        _cleanup_free_ char *paths = NULL;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sba(ss))");
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        for (;;) {