#include <arpa/inet.h>

#include <errno.h>

#include <fcntl.h>

#include <getopt.h>

#include <math.h>

#include <net/if.h>

#include <netinet/in.h>

#include <sys/mount.h>

#include <sys/socket.h>

#include <unistd.h>

#include "sd-bus.h"

#include "alloc-util.h"

#include "bus-common-errors.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 "bus-unit-util.h"

#include "bus-wait-for-jobs.h"

#include "cgroup-show.h"

#include "cgroup-util.h"

#include "copy.h"

#include "def.h"

#include "env-util.h"

#include "fd-util.h"

#include "format-table.h"

#include "hostname-util.h"

#include "import-util.h"

#include "locale-util.h"

#include "log.h"

#include "logs-show.h"

#include "macro.h"

#include "main-func.h"

#include "mkdir.h"

#include "nulstr-util.h"

#include "pager.h"

#include "parse-argument.h"

#include "parse-util.h"

#include "path-util.h"

#include "pretty-print.h"

#include "process-util.h"

#include "ptyfwd.h"

#include "rlimit-util.h"

#include "sigbus.h"

#include "signal-util.h"

#include "sort-util.h"

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

#include "spawn-polkit-agent.h"

#include "stdio-util.h"

#include "string-table.h"

#include "strv.h"

#include "terminal-util.h"

#include "unit-name.h"

#include "verbs.h"

#include "web-util.h"

#define ALL_ADDRESSES -1

static char **arg_property = NULL;

static bool arg_all = false;

static BusPrintPropertyFlags arg_print_flags = 0;

static bool arg_full = false;

static PagerFlags arg_pager_flags = 0;

static bool arg_legend = true;

static const char *arg_kill_who = NULL;

static int arg_signal = SIGTERM;

static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;

static const char *arg_host = NULL;

static bool arg_read_only = false;

static bool arg_mkdir = false;

static bool arg_quiet = false;

static bool arg_ask_password = true;

static unsigned arg_lines = 10;

static OutputMode arg_output = OUTPUT_SHORT;

static bool arg_force = false;

static ImportVerify arg_verify = IMPORT_VERIFY_SIGNATURE;

static const char* arg_format = NULL;

static const char *arg_uid = NULL;

static char **arg_setenv = NULL;

static int arg_max_addresses = 1;

STATIC_DESTRUCTOR_REGISTER(arg_property, strv_freep);

STATIC_DESTRUCTOR_REGISTER(arg_setenv, strv_freep);

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;

}

static int call_get_os_release(sd_bus *bus, const char *method, const char *name, const char *query, ...) {

_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;

const char *k, *v, *iter, **query_res = NULL;

size_t count = 0, awaited_args = 0;

va_list ap;

int r;

assert(bus);

assert(name);

assert(query);

NULSTR_FOREACH(iter, query)

awaited_args++;

query_res = newa0(const char *, awaited_args);

r = bus_call_method(bus, bus_machine_mgr, method, &error, &reply, "s", name);

if (r < 0)

return log_debug_errno(r, "Failed to call '%s()': %s", method, bus_error_message(&error, r));

r = sd_bus_message_enter_container(reply, 'a', "{ss}");

if (r < 0)

return bus_log_parse_error(r);

while ((r = sd_bus_message_read(reply, "{ss}", &k, &v)) > 0) {

count = 0;

NULSTR_FOREACH(iter, query) {

if (streq(k, iter)) {

query_res[count] = v;

break;

}

count++;

}

}

if (r < 0)

return bus_log_parse_error(r);

r = sd_bus_message_exit_container(reply);

if (r < 0)

return bus_log_parse_error(r);

va_start(ap, query);

for (count = 0; count < awaited_args; count++) {

char *val, **out;

out = va_arg(ap, char **);

assert(out);

if (query_res[count]) {

val = strdup(query_res[count]);

if (!val) {

va_end(ap);

return -ENOMEM;

}

*out = val;

}

}

va_end(ap);

return 0;

}

static int call_get_addresses(

char **ret) {

_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;

_cleanup_free_ char *addresses = NULL;

unsigned n = 0;

int r;

assert(bus);

assert(name);

assert(prefix);

assert(prefix2);

r = bus_call_method(bus, bus_machine_mgr, "GetMachineAddresses", NULL, &reply, "s", name);

if (r < 0)

return log_debug_errno(r, "Could not get addresses: %s", bus_error_message(&error, r));

addresses = strdup(prefix);

if (!addresses)

return log_oom();

prefix = "";

r = sd_bus_message_enter_container(reply, 'a', "(iay)");

if (r < 0)

return bus_log_parse_error(r);

while ((r = sd_bus_message_enter_container(reply, 'r', "iay")) > 0) {

int family;

const void *a;

size_t sz;

char buf_ifi[DECIMAL_STR_MAX(int) + 2], buffer[MAX(INET6_ADDRSTRLEN, INET_ADDRSTRLEN)];

r = sd_bus_message_read(reply, "i", &family);

if (r < 0)

return bus_log_parse_error(r);

r = sd_bus_message_read_array(reply, 'y', &a, &sz);

if (r < 0)

return bus_log_parse_error(r);

if (family == AF_INET6 && ifi > 0)

xsprintf(buf_ifi, "%%%i", ifi);

else

strcpy(buf_ifi, "");

if (!strextend(&addresses,

prefix,

inet_ntop(family, a, buffer, sizeof(buffer)),

buf_ifi))

return log_oom();

r = sd_bus_message_exit_container(reply);

if (r < 0)

return bus_log_parse_error(r);

prefix = prefix2;

n++;

}

if (r < 0)

return bus_log_parse_error(r);

r = sd_bus_message_exit_container(reply);

if (r < 0)

return bus_log_parse_error(r);

*ret = TAKE_PTR(addresses);

return (int) n;

}

static int show_table(Table *table, const char *word) {

int r;

assert(table);

assert(word);

if (table_get_rows(table) > 1 || OUTPUT_MODE_IS_JSON(arg_output)) {

r = table_set_sort(table, (size_t) 0);

if (r < 0)

return table_log_sort_error(r);

table_set_header(table, arg_legend);

if (OUTPUT_MODE_IS_JSON(arg_output))

r = table_print_json(table, NULL, output_mode_to_json_format_flags(arg_output) | JSON_FORMAT_COLOR_AUTO);

else

r = table_print(table, NULL);

if (r < 0)

return table_log_print_error(r);

}

if (arg_legend) {

if (table_get_rows(table) > 1)

printf("\n%zu %s listed.\n", table_get_rows(table) - 1, word);

else

printf("No %s.\n", word);

}

return 0;

}

static int list_machines(int argc, char *argv[], void *userdata) {

_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;

_cleanup_(table_unrefp) Table *table = NULL;

sd_bus *bus = userdata;

int r;

assert(bus);

pager_open(arg_pager_flags);

r = bus_call_method(bus, bus_machine_mgr, "ListMachines", &error, &reply, NULL);

if (r < 0)

return log_error_errno(r, "Could not get machines: %s", bus_error_message(&error, r));

table = table_new("machine", "class", "service", "os", "version", "addresses");

if (!table)

return log_oom();

table_set_empty_string(table, "-");

if (!arg_full && arg_max_addresses != ALL_ADDRESSES)

table_set_cell_height_max(table, arg_max_addresses);

if (arg_full)

table_set_width(table, 0);

r = sd_bus_message_enter_container(reply, 'a', "(ssso)");

if (r < 0)

return bus_log_parse_error(r);

for (;;) {

_cleanup_free_ char *os = NULL, *version_id = NULL, *addresses = NULL;

const char *name, *class, *service;

r = sd_bus_message_read(reply, "(ssso)", &name, &class, &service, NULL);

if (r < 0)

return bus_log_parse_error(r);

if (r == 0)

break;

if (name[0] == '.' && !arg_all)

continue;

(void) call_get_os_release(

bus,

"GetMachineOSRelease",

name,

"ID\0"

"VERSION_ID\0",

&os,

&version_id);

(void) call_get_addresses(

bus,

name,

0,

"",

"\n",

&addresses);

r = table_add_many(table,

TABLE_STRING, empty_to_null(name),

TABLE_STRING, empty_to_null(class),

TABLE_STRING, empty_to_null(service),

TABLE_STRING, empty_to_null(os),

TABLE_STRING, empty_to_null(version_id),

TABLE_STRING, empty_to_null(addresses));

if (r < 0)

return table_log_add_error(r);

}

r = sd_bus_message_exit_container(reply);

if (r < 0)

return bus_log_parse_error(r);

return show_table(table, "machines");

}

static int list_images(int argc, char *argv[], void *userdata) {

_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;

_cleanup_(table_unrefp) Table *table = NULL;

sd_bus *bus = userdata;

int r;

assert(bus);

pager_open(arg_pager_flags);

r = bus_call_method(bus, bus_machine_mgr, "ListImages", &error, &reply, NULL);

if (r < 0)

return log_error_errno(r, "Could not get images: %s", bus_error_message(&error, r));

table = table_new("name", "type", "ro", "usage", "created", "modified");

if (!table)

return log_oom();

if (arg_full)

table_set_width(table, 0);

(void) table_set_align_percent(table, TABLE_HEADER_CELL(3), 100);

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

if (r < 0)

return bus_log_parse_error(r);

for (;;) {

uint64_t crtime, mtime, size;

const char *name, *type;

int ro_int;

r = sd_bus_message_read(reply, "(ssbttto)", &name, &type, &ro_int, &crtime, &mtime, &size, NULL);

if (r < 0)

return bus_log_parse_error(r);

if (r == 0)

break;

if (name[0] == '.' && !arg_all)

continue;

r = table_add_many(table,

TABLE_STRING, name,

TABLE_STRING, type,

TABLE_BOOLEAN, ro_int,

TABLE_SET_COLOR, ro_int ? ansi_highlight_red() : NULL,

TABLE_SIZE, size,

TABLE_TIMESTAMP, crtime,

TABLE_TIMESTAMP, mtime);

if (r < 0)

return table_log_add_error(r);

}

r = sd_bus_message_exit_container(reply);

if (r < 0)

return bus_log_parse_error(r);

return show_table(table, "images");

}

static int show_unit_cgroup(sd_bus *bus, const char *unit, pid_t leader) {

_cleanup_free_ char *cgroup = NULL;

_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;

int r;

unsigned c;

assert(bus);

assert(unit);

r = show_cgroup_get_unit_path_and_warn(bus, unit, &cgroup);

if (r < 0)

return r;

if (isempty(cgroup))

return 0;

c = columns();

if (c > 18)

c -= 18;

else

c = 0;

r = unit_show_processes(bus, unit, cgroup, "\t\t ", c, get_output_flags(), &error);

if (r == -EBADR) {

if (arg_transport == BUS_TRANSPORT_REMOTE)

return 0;

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

if (cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, cgroup) != 0 && leader <= 0)

return 0;

show_cgroup_and_extra(SYSTEMD_CGROUP_CONTROLLER, cgroup, "\t\t ", c, &leader, leader > 0, get_output_flags());

} else if (r < 0)

return log_error_errno(r, "Failed to dump process list: %s", bus_error_message(&error, r));

return 0;

}

static int print_os_release(sd_bus *bus, const char *method, const char *name, const char *prefix) {

_cleanup_free_ char *pretty = NULL;

int r;

assert(bus);

assert(name);

assert(prefix);

r = call_get_os_release(bus, method, name, "PRETTY_NAME\0", &pretty, NULL);

if (r < 0)

return r;

if (pretty)

printf("%s%s\n", prefix, pretty);

return 0;

}

static int print_uid_shift(sd_bus *bus, const char *name) {

_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;

uint32_t shift;

int r;

assert(bus);

assert(name);

r = bus_call_method(bus, bus_machine_mgr, "GetMachineUIDShift", &error, &reply, "s", name);

if (r < 0)

return log_debug_errno(r, "Failed to query UID/GID shift: %s", bus_error_message(&error, r));

r = sd_bus_message_read(reply, "u", &shift);

if (r < 0)

return r;

if (shift == 0) /* Don't show trivial mappings */

return 0;

printf(" UID Shift: %" PRIu32 "\n", shift);

return 0;

}

typedef struct MachineStatusInfo {

} MachineStatusInfo;

static void machine_status_info_clear(MachineStatusInfo *info) {

if (info) {

free(info->netif);

zero(*info);

}

}

static void print_machine_status_info(sd_bus *bus, MachineStatusInfo *i) {

_cleanup_free_ char *addresses = NULL, *s1 = NULL, *s2 = NULL;

int ifi = -1;

assert(bus);

assert(i);

fputs(strna(i->name), stdout);

if (!sd_id128_is_null(i->id))

printf("(" SD_ID128_FORMAT_STR ")\n", SD_ID128_FORMAT_VAL(i->id));

else

putchar('\n');

s1 = strdup(strempty(FORMAT_TIMESTAMP_RELATIVE(i->timestamp.realtime)));

s2 = strdup(strempty(FORMAT_TIMESTAMP(i->timestamp.realtime)));

if (!isempty(s1))

printf("\t Since: %s; %s\n", strna(s2), s1);

else if (!isempty(s2))

printf("\t Since: %s\n", s2);

if (i->leader > 0) {

_cleanup_free_ char *t = NULL;

printf("\t Leader: %u", (unsigned) i->leader);

get_process_comm(i->leader, &t);

if (t)

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

putchar('\n');

}

if (i->service) {

printf("\t Service: %s", i->service);

if (i->class)

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

putchar('\n');

} else if (i->class)

printf("\t Class: %s\n", i->class);

if (i->root_directory)

printf("\t Root: %s\n", i->root_directory);

if (i->n_netif > 0) {

fputs("\t Iface:", stdout);

for (size_t c = 0; c < i->n_netif; c++) {

char name[IF_NAMESIZE];

if (format_ifname(i->netif[c], name) >= 0) {

fputc(' ', stdout);

fputs(name, stdout);

if (ifi < 0)

ifi = i->netif[c];

else

ifi = 0;

} else

printf(" %i", i->netif[c]);

}

fputc('\n', stdout);

}

if (call_get_addresses(bus, i->name, ifi,

"\t Address: ", "\n\t ",

&addresses) > 0) {

fputs(addresses, stdout);

fputc('\n', stdout);

}

print_os_release(bus, "GetMachineOSRelease", i->name, "\t OS: ");

print_uid_shift(bus, i->name);

if (i->unit) {

printf("\t Unit: %s\n", i->unit);

show_unit_cgroup(bus, i->unit, i->leader);

if (arg_transport == BUS_TRANSPORT_LOCAL)

show_journal_by_unit(

stdout,

i->unit,

NULL,

arg_output,

0,

i->timestamp.monotonic,

arg_lines,

0,

get_output_flags() | OUTPUT_BEGIN_NEWLINE,

SD_JOURNAL_LOCAL_ONLY,

true,

NULL);

}

}

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

MachineStatusInfo *i = userdata;

size_t l;

const void *v;

int r;

assert_cc(sizeof(int32_t) == sizeof(int));

r = sd_bus_message_read_array(m, SD_BUS_TYPE_INT32, &v, &l);

if (r < 0)

return r;

if (r == 0)

return -EBADMSG;

i->n_netif = l / sizeof(int32_t);

i->netif = memdup(v, l);

if (!i->netif)

return -ENOMEM;

return 0;

}

static int show_machine_info(const char *verb, sd_bus *bus, const char *path, bool *new_line) {

static const struct bus_properties_map map[] = {

{ "Name", "s", NULL, offsetof(MachineStatusInfo, name) },

{ "Class", "s", NULL, offsetof(MachineStatusInfo, class) },

{ "Service", "s", NULL, offsetof(MachineStatusInfo, service) },

{ "Unit", "s", NULL, offsetof(MachineStatusInfo, unit) },

{ "RootDirectory", "s", NULL, offsetof(MachineStatusInfo, root_directory) },

{ "Leader", "u", NULL, offsetof(MachineStatusInfo, leader) },

{ "Timestamp", "t", NULL, offsetof(MachineStatusInfo, timestamp.realtime) },

{ "TimestampMonotonic", "t", NULL, offsetof(MachineStatusInfo, timestamp.monotonic) },

{ "Id", "ay", bus_map_id128, offsetof(MachineStatusInfo, id) },

{ "NetworkInterfaces", "ai", map_netif, 0 },

{}

};

_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;

_cleanup_(machine_status_info_clear) MachineStatusInfo info = {};

int r;

assert(verb);

assert(bus);

assert(path);

assert(new_line);

r = bus_map_all_properties(bus,

"org.freedesktop.machine1",

path,

map,

0,

&error,

&m,

&info);

if (r < 0)

return log_error_errno(r, "Could not get properties: %s", bus_error_message(&error, r));

if (*new_line)

printf("\n");

*new_line = true;

print_machine_status_info(bus, &info);

return r;

}

static int show_machine_properties(sd_bus *bus, const char *path, bool *new_line) {

int r;

assert(bus);

assert(path);

assert(new_line);

if (*new_line)

printf("\n");

*new_line = true;

r = bus_print_all_properties(bus, "org.freedesktop.machine1", path, NULL, arg_property, arg_print_flags, NULL);

if (r < 0)

log_error_errno(r, "Could not get properties: %m");

return r;

}

static int show_machine(int argc, char *argv[], void *userdata) {

_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;

bool properties, new_line = false;

sd_bus *bus = userdata;

int r = 0;

assert(bus);

properties = !strstr(argv[0], "status");

pager_open(arg_pager_flags);

if (properties && argc <= 1) {

/* If no argument is specified, inspect the manager

r = show_machine_properties(bus, "/org/freedesktop/machine1", &new_line);

if (r < 0)

return r;

}

for (int i = 1; i < argc; i++) {

const char *path = NULL;

r = bus_call_method(bus, bus_machine_mgr, "GetMachine", &error, &reply, "s", argv[i]);

if (r < 0)

return log_error_errno(r, "Could not get path to machine: %s", bus_error_message(&error, r));

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

if (r < 0)

return bus_log_parse_error(r);

if (properties)

r = show_machine_properties(bus, path, &new_line);

else

r = show_machine_info(argv[0], bus, path, &new_line);

}

return r;

}

static int print_image_hostname(sd_bus *bus, const char *name) {

_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;

const char *hn;

int r;

r = bus_call_method(bus, bus_machine_mgr, "GetImageHostname", NULL, &reply, "s", name);

if (r < 0)

return r;

r = sd_bus_message_read(reply, "s", &hn);

if (r < 0)

return r;

if (!isempty(hn))

printf("\tHostname: %s\n", hn);

return 0;

}

static int print_image_machine_id(sd_bus *bus, const char *name) {

_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;

sd_id128_t id = SD_ID128_NULL;

const void *p;

size_t size;

int r;

r = bus_call_method(bus, bus_machine_mgr, "GetImageMachineID", NULL, &reply, "s", name);

if (r < 0)

return r;

r = sd_bus_message_read_array(reply, 'y', &p, &size);

if (r < 0)

return r;

if (size == sizeof(sd_id128_t))

memcpy(&id, p, size);

if (!sd_id128_is_null(id))

printf(" Machine ID: " SD_ID128_FORMAT_STR "\n", SD_ID128_FORMAT_VAL(id));

return 0;

}

static int print_image_machine_info(sd_bus *bus, const char *name) {

_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;

int r;

r = bus_call_method(bus, bus_machine_mgr, "GetImageMachineInfo", NULL, &reply, "s", name);

if (r < 0)

return r;

r = sd_bus_message_enter_container(reply, 'a', "{ss}");

if (r < 0)

return r;

for (;;) {

const char *p, *q;

r = sd_bus_message_read(reply, "{ss}", &p, &q);

if (r < 0)

return r;

if (r == 0)

break;

if (streq(p, "DEPLOYMENT"))

printf(" Deployment: %s\n", q);

}

r = sd_bus_message_exit_container(reply);

if (r < 0)

return r;

return 0;

}

typedef struct ImageStatusInfo {

} ImageStatusInfo;

static void print_image_status_info(sd_bus *bus, ImageStatusInfo *i) {

assert(bus);

assert(i);

if (i->name) {

fputs(i->name, stdout);

putchar('\n');

}

if (i->type)

printf("\t Type: %s\n", i->type);

if (i->path)

printf("\t Path: %s\n", i->path);

(void) print_image_hostname(bus, i->name);

(void) print_image_machine_id(bus, i->name);

(void) print_image_machine_info(bus, i->name);

print_os_release(bus, "GetImageOSRelease", i->name, "\t OS: ");

printf("\t RO: %s%s%s\n",

i->read_only ? ansi_highlight_red() : "",

i->read_only ? "read-only" : "writable",

i->read_only ? ansi_normal() : "");

if (timestamp_is_set(i->crtime))

printf("\t Created: %s; %s\n",

FORMAT_TIMESTAMP(i->crtime), FORMAT_TIMESTAMP_RELATIVE(i->crtime));

if (timestamp_is_set(i->mtime))

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

FORMAT_TIMESTAMP(i->mtime), FORMAT_TIMESTAMP_RELATIVE(i->mtime));

if (i->usage != UINT64_MAX) {

if (i->usage_exclusive != i->usage && i->usage_exclusive != UINT64_MAX)

printf("\t Usage: %s (exclusive: %s)\n",

FORMAT_BYTES(i->usage), FORMAT_BYTES(i->usage_exclusive));

else

printf("\t Usage: %s\n", FORMAT_BYTES(i->usage));

}

if (i->limit != UINT64_MAX) {

if (i->limit_exclusive != i->limit && i->limit_exclusive != UINT64_MAX)

printf("\t Limit: %s (exclusive: %s)\n",

FORMAT_BYTES(i->limit), FORMAT_BYTES(i->limit_exclusive));

else

printf("\t Limit: %s\n", FORMAT_BYTES(i->limit));

}

}

static int show_image_info(sd_bus *bus, const char *path, bool *new_line) {

static const struct bus_properties_map map[] = {

{ "Name", "s", NULL, offsetof(ImageStatusInfo, name) },

{ "Path", "s", NULL, offsetof(ImageStatusInfo, path) },

{ "Type", "s", NULL, offsetof(ImageStatusInfo, type) },

{ "ReadOnly", "b", NULL, offsetof(ImageStatusInfo, read_only) },

{ "CreationTimestamp", "t", NULL, offsetof(ImageStatusInfo, crtime) },

{ "ModificationTimestamp", "t", NULL, offsetof(ImageStatusInfo, mtime) },

{ "Usage", "t", NULL, offsetof(ImageStatusInfo, usage) },

{ "Limit", "t", NULL, offsetof(ImageStatusInfo, limit) },

{ "UsageExclusive", "t", NULL, offsetof(ImageStatusInfo, usage_exclusive) },

{ "LimitExclusive", "t", NULL, offsetof(ImageStatusInfo, limit_exclusive) },

{}

};

_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;

ImageStatusInfo info = {};

int r;

assert(bus);

assert(path);

assert(new_line);

r = bus_map_all_properties(bus,

"org.freedesktop.machine1",

path,

map,

BUS_MAP_BOOLEAN_AS_BOOL,

&error,

&m,

&info);

if (r < 0)

return log_error_errno(r, "Could not get properties: %s", bus_error_message(&error, r));

if (*new_line)

printf("\n");

*new_line = true;

print_image_status_info(bus, &info);

return r;

}

typedef struct PoolStatusInfo {

} PoolStatusInfo;

static void print_pool_status_info(sd_bus *bus, PoolStatusInfo *i) {

if (i->path)

printf("\t Path: %s\n", i->path);

if (i->usage != UINT64_MAX)

printf("\t Usage: %s\n", FORMAT_BYTES(i->usage));

if (i->limit != UINT64_MAX)

printf("\t Limit: %s\n", FORMAT_BYTES(i->limit));

}

static int show_pool_info(sd_bus *bus) {

static const struct bus_properties_map map[] = {

{ "PoolPath", "s", NULL, offsetof(PoolStatusInfo, path) },

{ "PoolUsage", "t", NULL, offsetof(PoolStatusInfo, usage) },

{ "PoolLimit", "t", NULL, offsetof(PoolStatusInfo, limit) },

{}

};

PoolStatusInfo info = {

.usage = UINT64_MAX,

.limit = UINT64_MAX,

};

_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;

int r;

assert(bus);

r = bus_map_all_properties(bus,

"org.freedesktop.machine1",

"/org/freedesktop/machine1",

map,

0,

&error,

&m,

&info);

if (r < 0)

return log_error_errno(r, "Could not get properties: %s", bus_error_message(&error, r));

print_pool_status_info(bus, &info);

return 0;

}

static int show_image_properties(sd_bus *bus, const char *path, bool *new_line) {

int r;

assert(bus);

assert(path);

assert(new_line);

if (*new_line)

printf("\n");

*new_line = true;

r = bus_print_all_properties(bus, "org.freedesktop.machine1", path, NULL, arg_property, arg_print_flags, NULL);

if (r < 0)

log_error_errno(r, "Could not get properties: %m");

return r;

}

static int show_image(int argc, char *argv[], void *userdata) {

_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;

bool properties, new_line = false;

sd_bus *bus = userdata;