HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/hostname/hostnamed.c

102,276 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 70adccae80d3626caa853adba05a973b4b21e9d2

Lines 1–1000 of 2,746

/* SPDX-License-Identifier: LGPL-2.1-or-later */
 
#include <sys/stat.h>
#include <sys/utsname.h>
#include <unistd.h>
 
#include "sd-bus.h"
#include "sd-device.h"
#include "sd-event.h"
#include "sd-json.h"
 
#include "alloc-util.h"
#include "bitfield.h"
#include "bus-common-errors.h"
#include "bus-get-properties.h"
#include "bus-log-control-api.h"
#include "bus-object.h"
#include "bus-polkit.h"
#include "bus-util.h"
#include "common-signal.h"
#include "constants.h"
#include "daemon-util.h"
#include "device-private.h"
#include "device-util.h"
#include "dlopen-note.h"
#include "env-file.h"
#include "env-util.h"
#include "extract-word.h"
#include "fileio.h"
#include "hashmap.h"
#include "hostname-setup.h"
#include "hostname-util.h"
#include "id128-util.h"
#include "json-util.h"
#include "label-util.h"
#include "log.h"
#include "main-func.h"
#include "nulstr-util.h"
#include "os-util.h"
#include "parse-util.h"
#include "service-util.h"
#include "stat-util.h"
#include "string-util.h"
#include "strv.h"
#include "time-util.h"
#include "varlink-io.systemd.Hostname.h"
#include "varlink-io.systemd.service.h"
#include "varlink-util.h"
#include "verbs.h"
#include "virt.h"
#include "vsock-util.h"
 
#define VALID_DEPLOYMENT_CHARS (ALPHANUMERICAL "-.:")
 
/* Properties we cache are indexed by an enum, to make invalidation easy and systematic (as we can iterate
 * through them all, and they are uniformly strings). */
typedef enum {
        /* Read from /etc/hostname */
        PROP_STATIC_HOSTNAME,
        PROP_STATIC_HOSTNAME_SUBSTITUTED_WILDCARDS,
 
        /* Read from /etc/machine-info (with fallbacks) */
        PROP_PRETTY_HOSTNAME,
        _PROP_MACHINE_INFO_SETTABLE_FIRST = PROP_PRETTY_HOSTNAME,
        PROP_ICON_NAME,
        PROP_CHASSIS,
        PROP_DEPLOYMENT,
        PROP_LOCATION,
        PROP_TAGS,
        _PROP_MACHINE_INFO_SETTABLE_LAST = PROP_TAGS,
        PROP_HARDWARE_VENDOR,
        PROP_HARDWARE_MODEL,
        PROP_HARDWARE_SKU,
        PROP_HARDWARE_VERSION,
 
        /* Read from /etc/os-release (or /usr/lib/os-release) */
        PROP_OS_PRETTY_NAME,
        PROP_OS_FANCY_NAME,
        PROP_OS_CPE_NAME,
        PROP_OS_HOME_URL,
        PROP_OS_SUPPORT_END,
        PROP_OS_IMAGE_ID,
        PROP_OS_IMAGE_VERSION,
 
        _PROP_MAX,
        _PROP_INVALID = -EINVAL,
} HostProperty;
 
typedef struct Context {
        char *data[_PROP_MAX];
 
        HostnameSource hostname_source;
 
        struct stat etc_hostname_stat;
        struct stat etc_os_release_stat;
        struct stat etc_machine_info_stat;
 
        sd_event *event;
        sd_bus *bus;
        sd_varlink_server *varlink_server;
        Hashmap *polkit_registry;
        sd_device *device_dmi;
        sd_device *device_acpi;
        sd_device *device_tree;
} Context;
 
static void context_reset(Context *c, uint64_t mask) {
        assert(c);
 
        for (HostProperty p = 0; p < _PROP_MAX; p++) {
                if (!BIT_SET(mask, p))
                        continue;
 
                c->data[p] = mfree(c->data[p]);
        }
}
 
#define context_reset_many(c, ...)      \
        context_reset((c), INDEXES_TO_MASK(uint64_t, __VA_ARGS__))
 
static void context_destroy(Context *c) {
        assert(c);
 
        context_reset(c, UINT64_MAX);
        hashmap_free(c->polkit_registry);
        sd_event_unref(c->event);
        sd_bus_flush_close_unref(c->bus);
        sd_varlink_server_unref(c->varlink_server);
        sd_device_unref(c->device_dmi);
        sd_device_unref(c->device_acpi);
        sd_device_unref(c->device_tree);
}
 
static void context_read_etc_hostname(Context *c) {
        struct stat current_stat = {};
        int r;
 
        assert(c);
 
        if (stat(etc_hostname(), &current_stat) >= 0 &&
            stat_inode_unmodified(&c->etc_hostname_stat, &current_stat))
                return;
 
        context_reset_many(c, PROP_STATIC_HOSTNAME,
                              PROP_STATIC_HOSTNAME_SUBSTITUTED_WILDCARDS);
 
        r = read_etc_hostname(/* path= */ NULL, /* substitute_wildcards= */ false, &c->data[PROP_STATIC_HOSTNAME]);
        if (r < 0) {
                if (r != -ENOENT)
                        log_warning_errno(r, "Failed to read /etc/hostname, ignoring: %m");
        } else {
                _cleanup_free_ char *substituted = NULL;
 
                r = hostname_substitute_wildcards(c->data[PROP_STATIC_HOSTNAME], &substituted);
                if (r < 0)
                        log_warning_errno(r, "Failed to substitute wildcards in /etc/hostname, ignoring: %m");
                else if (!hostname_is_valid(substituted, VALID_HOSTNAME_TRAILING_DOT))
                        log_warning("Hostname '%s' in /etc/hostname is invalid after expansion, ignoring.", substituted);
                else
                        c->data[PROP_STATIC_HOSTNAME_SUBSTITUTED_WILDCARDS] = TAKE_PTR(substituted);
        }
 
        c->etc_hostname_stat = current_stat;
}
 
static void context_read_machine_info(Context *c) {
        struct stat current_stat = {};
        int r;
 
        assert(c);
 
        if (stat(etc_machine_info(), &current_stat) >= 0 &&
            stat_inode_unmodified(&c->etc_machine_info_stat, &current_stat))
                return;
 
        context_reset_many(c, PROP_PRETTY_HOSTNAME,
                              PROP_ICON_NAME,
                              PROP_CHASSIS,
                              PROP_DEPLOYMENT,
                              PROP_LOCATION,
                              PROP_TAGS,
                              PROP_HARDWARE_VENDOR,
                              PROP_HARDWARE_MODEL,
                              PROP_HARDWARE_SKU,
                              PROP_HARDWARE_VERSION);
 
        r = parse_env_file(NULL, etc_machine_info(),
                           "PRETTY_HOSTNAME", &c->data[PROP_PRETTY_HOSTNAME],
                           "ICON_NAME", &c->data[PROP_ICON_NAME],
                           "CHASSIS", &c->data[PROP_CHASSIS],
                           "DEPLOYMENT", &c->data[PROP_DEPLOYMENT],
                           "LOCATION", &c->data[PROP_LOCATION],
                           "TAGS", &c->data[PROP_TAGS],
                           "HARDWARE_VENDOR", &c->data[PROP_HARDWARE_VENDOR],
                           "HARDWARE_MODEL", &c->data[PROP_HARDWARE_MODEL],
                           "HARDWARE_SKU", &c->data[PROP_HARDWARE_SKU],
                           "HARDWARE_VERSION", &c->data[PROP_HARDWARE_VERSION]);
        if (r < 0 && r != -ENOENT)
                log_warning_errno(r, "Failed to read /etc/machine-info, ignoring: %m");
 
        c->etc_machine_info_stat = current_stat;
}
 
static void context_read_os_release(Context *c) {
        _cleanup_free_ char *os_name = NULL, *os_pretty_name = NULL, *os_fancy_name = NULL, *os_ansi_color = NULL;
        struct stat current_stat = {};
        int r;
 
        assert(c);
 
        if ((stat("/etc/os-release", &current_stat) >= 0 ||
             stat("/usr/lib/os-release", &current_stat) >= 0) &&
            stat_inode_unmodified(&c->etc_os_release_stat, &current_stat))
                return;
 
        context_reset_many(c, PROP_OS_PRETTY_NAME,
                              PROP_OS_FANCY_NAME,
                              PROP_OS_CPE_NAME,
                              PROP_OS_HOME_URL,
                              PROP_OS_SUPPORT_END,
                              PROP_OS_IMAGE_ID,
                              PROP_OS_IMAGE_VERSION);
 
        r = parse_os_release(NULL,
                             "PRETTY_NAME",   &os_pretty_name,
                             "FANCY_NAME",    &os_fancy_name,
                             "ANSI_COLOR",    &os_ansi_color,
                             "NAME",          &os_name,
                             "CPE_NAME",      &c->data[PROP_OS_CPE_NAME],
                             "HOME_URL",      &c->data[PROP_OS_HOME_URL],
                             "SUPPORT_END",   &c->data[PROP_OS_SUPPORT_END],
                             "IMAGE_ID",      &c->data[PROP_OS_IMAGE_ID],
                             "IMAGE_VERSION", &c->data[PROP_OS_IMAGE_VERSION]);
        if (r < 0 && r != -ENOENT)
                log_warning_errno(r, "Failed to read os-release file, ignoring: %m");
 
        if (free_and_strdup(&c->data[PROP_OS_PRETTY_NAME], os_release_pretty_name(os_pretty_name, os_name)) < 0)
                log_oom();
 
        unescape_fancy_name(&os_fancy_name);
 
        if (isempty(os_fancy_name)) {
                free(os_fancy_name); /* free if empty string */
 
                if (isempty(os_ansi_color))
                        os_fancy_name = strdup(c->data[PROP_OS_PRETTY_NAME]);
                else
                        os_fancy_name = strjoin("\x1B[", os_ansi_color, "m", c->data[PROP_OS_PRETTY_NAME]);
                if (!os_fancy_name)
                        log_oom();
        }
 
        free_and_replace(c->data[PROP_OS_FANCY_NAME], os_fancy_name);
 
        c->etc_os_release_stat = current_stat;
}
 
static bool use_dmi_data(void) {
        int r;
 
        r = getenv_bool("SYSTEMD_HOSTNAME_FORCE_DMI");
        if (r >= 0) {
                log_debug("Honouring $SYSTEMD_HOSTNAME_FORCE_DMI override: %s", yes_no(r));
                return r;
        }
        if (r != -ENXIO)
                log_debug_errno(r, "Failed to parse $SYSTEMD_HOSTNAME_FORCE_DMI, ignoring: %m");
 
        if (detect_container() > 0) {
                log_debug("Running in a container, not using DMI hardware data.");
                return false;
        }
 
        return true;
}
 
static int context_acquire_dmi_device(Context *c) {
        int r;
 
        assert(c);
        assert(!c->device_dmi);
 
        if (!use_dmi_data())
                return 0;
 
        r = sd_device_new_from_syspath(&c->device_dmi, "/sys/class/dmi/id/");
        if (ERRNO_IS_NEG_DEVICE_ABSENT(r)) {
                log_debug_errno(r, "Failed to open /sys/class/dmi/id/ device, ignoring: %m");
                return 0;
        }
        if (r < 0)
                return log_error_errno(r, "Failed to open /sys/class/dmi/id/ device: %m");
 
        return 1;
}
 
static int context_acquire_acpi_device(Context *c) {
        int r;
 
        assert(c);
        assert(!c->device_acpi);
 
        r = sd_device_new_from_syspath(&c->device_acpi, "/sys/firmware/acpi/");
        if (ERRNO_IS_NEG_DEVICE_ABSENT(r)) {
                log_debug_errno(r, "Failed to open /sys/firmware/acpi/ device, ignoring: %m");
                return 0;
        }
        if (r < 0)
                return log_error_errno(r, "Failed to open /sys/firmware/acpi/ device: %m");
 
        return 1;
}
 
static int context_acquire_device_tree(Context *c) {
        int r;
 
        assert(c);
        assert(!c->device_tree);
 
        r = sd_device_new_from_path(&c->device_tree, "/proc/device-tree/");
        if (ERRNO_IS_NEG_DEVICE_ABSENT(r)) {
                log_debug_errno(r, "Failed to open /proc/device-tree/ device, ignoring: %m");
                return 0;
        }
        if (r < 0)
                return log_error_errno(r, "Failed to open /proc/device-tree/ device: %m");
 
        return 1;
}
 
static int get_dmi_property(Context *c, const char *key, char **ret) {
        const char *s;
        int r;
 
        assert(c);
        assert(key);
        assert(ret);
 
        if (!c->device_dmi)
                return -ENODEV;
 
        r = sd_device_get_property_value(c->device_dmi, key, &s);
        if (r < 0)
                return r;
 
        if (!string_is_safe(s, STRING_ALLOW_EMPTY|STRING_ALLOW_BACKSLASHES|STRING_ALLOW_QUOTES|STRING_ALLOW_GLOBS))
                return -ENXIO;
 
        return strdup_to(ret, s);
}
 
static int get_dmi_properties(Context *c, const char * const * keys, char **ret) {
        int r = -ENOENT;
 
        assert(c);
        assert(ret);
 
        STRV_FOREACH(k, keys) {
                r = get_dmi_property(c, *k, ret);
                if (r >= 0 || !ERRNO_IS_NEG_DEVICE_ABSENT(r))
                        return r;
        }
 
        return r;
}
 
static int get_chassis_asset_tag(Context *c, char **ret) {
        return get_dmi_property(c, "ID_CHASSIS_ASSET_TAG", ret);
}
 
static int get_hardware_vendor(Context *c, char **ret) {
        return get_dmi_properties(c, STRV_MAKE_CONST("ID_VENDOR_FROM_DATABASE", "ID_VENDOR"), ret);
}
 
static int get_hardware_model(Context *c, char **ret) {
        return get_dmi_properties(c, STRV_MAKE_CONST("ID_MODEL_FROM_DATABASE", "ID_MODEL"), ret);
}
 
static int get_hardware_sku(Context *c, char **ret) {
        _cleanup_free_ char *model = NULL, *sku = NULL;
        int r;
 
        assert(ret);
 
        r = get_dmi_property(c, "ID_SKU", &sku);
        if (r < 0)
                return r;
 
        /* Suppress reporting the SKU field, if it's the same string as the
         * model field, which it appears to be on various systems */
        r = get_hardware_model(c, &model);
        if (r < 0) {
                if (r != -ENOENT)
                        return r;
        } else if (streq_ptr(sku, model))
                return -ENOENT;
 
        *ret = TAKE_PTR(sku);
        return 0;
}
 
static int get_hardware_version(Context *c, char **ret) {
        _cleanup_free_ char *version = NULL;
        int r;
 
        assert(ret);
 
        r = get_dmi_property(c, "ID_HARDWARE_VERSION", &version);
        if (r < 0)
                return r;
 
        /* Suppress reporting the version field, if it's the same string as the
         * model or sku field, which it appears to be on various systems */
        int (*getter)(Context *c, char **ret);
        FOREACH_ARGUMENT(getter, get_hardware_model, get_hardware_sku) {
                _cleanup_free_ char *value = NULL;
 
                r = getter(c, &value);
                if (r == -ENOENT)
                        continue;
                if (r < 0)
                        return r;
                if (streq_ptr(version, value))
                        return -ENOENT;
        }
 
        *ret = TAKE_PTR(version);
        return 0;
}
 
static int get_sysattr(sd_device *device, const char *key, char **ret) {
        const char *s;
        int r;
 
        assert(key);
        assert(ret);
 
        if (!device)
                return -ENODEV;
 
        r = device_get_sysattr_safe_string(device, key, &s);
        if (r < 0)
                return log_device_debug_errno(device, r, "Failed to read '%s' attribute: %m", key);
 
        if (!string_is_safe(s, STRING_ALLOW_EMPTY|STRING_ALLOW_BACKSLASHES|STRING_ALLOW_QUOTES|STRING_ALLOW_GLOBS))
                return log_device_debug_errno(device, SYNTHETIC_ERRNO(ENXIO),
                                              "'%s' attribute is not safe for exposing through DBus: %s",
                                              key, s);
 
        return strdup_to(ret, empty_to_null(s));
}
 
static int get_dmi_sysattr(Context *c, const char *key, char **ret) {
        return get_sysattr(ASSERT_PTR(c)->device_dmi, key, ret);
}
 
static int get_device_tree_sysattr(Context *c, const char *key, char **ret) {
        return get_sysattr(ASSERT_PTR(c)->device_tree, key, ret);
}
 
static int get_hardware_serial(Context *c, char **ret) {
        int r;
 
        assert(c);
        assert(ret);
 
        FOREACH_STRING(attr, "product_serial", "board_serial") {
                r = get_dmi_sysattr(c, attr, ret);
                if (r >= 0 || !ERRNO_IS_NEG_DEVICE_ABSENT(r))
                        return r;
        }
 
        return get_device_tree_sysattr(c, "serial-number", ret);
}
 
static int get_firmware_version(Context *c, char **ret) {
        return get_dmi_sysattr(c, "bios_version", ret);
}
 
static int get_firmware_vendor(Context *c, char **ret) {
        return get_dmi_sysattr(c, "bios_vendor", ret);
}
 
static int get_firmware_date(Context *c, usec_t *ret) {
        _cleanup_free_ char *bios_date = NULL, *month = NULL, *day = NULL, *year = NULL;
        int r;
 
        assert(c);
        assert(ret);
 
        r = get_dmi_sysattr(c, "bios_date", &bios_date);
        if (ERRNO_IS_NEG_DEVICE_ABSENT(r)) {
                *ret = USEC_INFINITY;
                return 0;
        }
        if (r < 0)
                return r;
 
        const char *p = bios_date;
        r = extract_many_words(&p, "/", EXTRACT_DONT_COALESCE_SEPARATORS, &month, &day, &year);
        if (r < 0)
                return r;
        if (r != 3) /* less than three args read? */
                return -EINVAL;
        if (!isempty(p)) /* more left in the string? */
                return -EINVAL;
 
        unsigned m, d, y;
        r = safe_atou_full(month, 10 | SAFE_ATO_REFUSE_PLUS_MINUS | SAFE_ATO_REFUSE_LEADING_WHITESPACE, &m);
        if (r < 0)
                return r;
        if (m < 1 || m > 12)
                return -EINVAL;
        m -= 1;
 
        r = safe_atou_full(day, 10 | SAFE_ATO_REFUSE_PLUS_MINUS | SAFE_ATO_REFUSE_LEADING_WHITESPACE, &d);
        if (r < 0)
                return r;
        if (d < 1 || d > 31)
                return -EINVAL;
 
        r = safe_atou_full(year, 10 | SAFE_ATO_REFUSE_PLUS_MINUS | SAFE_ATO_REFUSE_LEADING_WHITESPACE, &y);
        if (r < 0)
                return r;
        if (y < 1970 || y > (unsigned) INT_MAX)
                return -EINVAL;
        y -= 1900;
 
        struct tm tm = {
                .tm_mday = d,
                .tm_mon = m,
                .tm_year = y,
        };
 
        usec_t v;
        r = mktime_or_timegm_usec(&tm, /* utc= */ true, &v);
        if (r < 0)
                return r;
        if (tm.tm_mday != (int) d || tm.tm_mon != (int) m || tm.tm_year != (int) y)
                return -EINVAL; /* date was not normalized? (e.g. "30th of feb") */
 
        *ret = v;
        return 0;
}
 
static const char* chassis_is_valid(const char *chassis) {
        assert(chassis);
 
        return nulstr_get(
                        "vm\0"
                        "container\0"
                        "desktop\0"
                        "laptop\0"
                        "convertible\0"
                        "server\0"
                        "tablet\0"
                        "handset\0"
                        "watch\0"
                        "embedded\0",
                        chassis);
}
 
static bool deployment_is_valid(const char *deployment) {
        assert(deployment);
 
        return !isempty(deployment) &&
                in_charset(deployment, VALID_DEPLOYMENT_CHARS);
}
 
static bool pretty_hostname_is_valid(const char *pretty_hostname) {
        assert(pretty_hostname);
 
        return string_is_safe(pretty_hostname, STRING_ALLOW_BACKSLASHES|STRING_ALLOW_QUOTES|STRING_ALLOW_GLOBS);
}
 
static bool icon_name_is_valid(const char *icon_name) {
        assert(icon_name);
 
        return string_is_safe(icon_name, STRING_FILENAME);
}
 
static bool location_is_valid(const char *location) {
        assert(location);
 
        return string_is_safe(location, STRING_ALLOW_BACKSLASHES|STRING_ALLOW_QUOTES|STRING_ALLOW_GLOBS);
}
 
static const char* fallback_chassis_by_virtualization(void) {
        Virtualization v = detect_virtualization();
        if (v < 0) {
                log_debug_errno(v, "Failed to detect virtualization, ignoring: %m");
                return NULL;
        }
 
        if (VIRTUALIZATION_IS_VM(v))
                return "vm";
        if (VIRTUALIZATION_IS_CONTAINER(v))
                return "container";
 
        return NULL;
}
 
static const char* fallback_chassis_by_dmi(Context *c) {
        unsigned t;
        int r;
 
        assert(c);
 
        if (!c->device_dmi)
                return NULL;
 
        r = device_get_sysattr_unsigned(c->device_dmi, "chassis_type", &t);
        if (r < 0) {
                log_debug_errno(r, "Failed to read/parse DMI chassis type, ignoring: %m");
                return NULL;
        }
 
        /* We only list the really obvious cases here. The DMI data is unreliable enough, so let's not do any
         * additional guesswork on top of that.
         *
         * See the SMBIOS Specification 3.5.0 section 7.4.1 for details about the values listed here:
         *
         * https://www.dmtf.org/sites/default/files/standards/documents/DSP0134_3.5.0.pdf
         */
 
        switch (t) {
 
        case 0x03: /* Desktop */
        case 0x04: /* Low Profile Desktop */
        case 0x06: /* Mini Tower */
        case 0x07: /* Tower */
        case 0x0D: /* All in one (i.e. PC built into monitor) */
        case 0x23: /* Mini PC */
        case 0x24: /* Stick PC */
                return "desktop";
 
        case 0x8: /* Portable */
        case 0x9: /* Laptop */
        case 0xA: /* Notebook */
        case 0xE: /* Sub Notebook */
                return "laptop";
 
        case 0xB: /* Hand Held */
                return "handset";
 
        case 0x11: /* Main Server Chassis */
        case 0x1C: /* Blade */
        case 0x1D: /* Blade Enclosure */
                return "server";
 
        case 0x1E: /* Tablet */
                return "tablet";
 
        case 0x1F: /* Convertible */
        case 0x20: /* Detachable */
                return "convertible";
 
        case 0x21: /* IoT Gateway */
        case 0x22: /* Embedded PC */
                return "embedded";
 
        default:
                log_debug("Unhandled DMI chassis type 0x%02x, ignoring.", t);
                return NULL;
        }
}
 
static const char* fallback_chassis_by_acpi(Context *c) {
        unsigned t;
        int r;
 
        assert(c);
 
        if (!c->device_acpi)
                return NULL;
 
        r = device_get_sysattr_unsigned(c->device_acpi, "pm_profile", &t);
        if (r < 0) {
                log_debug_errno(r, "Failed to read/parse ACPI PM profile, ignoring: %m");
                return NULL;
        }
 
        /* We only list the really obvious cases here as the ACPI data is not really super reliable.
         *
         * See the ACPI 5.0 Spec Section 5.2.9.1 for details:
         *
         * http://www.acpi.info/DOWNLOADS/ACPIspec50.pdf
         */
 
        switch (t) {
 
        case 1: /* Desktop */
        case 3: /* Workstation */
        case 6: /* Appliance PC */
                return "desktop";
 
        case 2: /* Mobile */
                return "laptop";
 
        case 4: /* Enterprise Server */
        case 5: /* SOHO Server */
        case 7: /* Performance Server */
                return "server";
 
        case 8: /* Tablet */
                return "tablet";
 
        default:
                log_debug("Unhandled ACPI PM profile 0x%02x, ignoring.", t);
                return NULL;
        }
}
 
static const char* fallback_chassis_by_device_tree(Context *c) {
        const char *type, *chassis;
        int r;
 
        assert(c);
 
        if (!c->device_tree)
                return NULL;
 
        r = device_get_sysattr_safe_string(c->device_tree, "chassis-type", &type);
        if (r < 0) {
                log_debug_errno(r, "Failed to read device-tree chassis type, ignoring: %m");
                return NULL;
        }
 
        /* Note that the DeviceTree specification uses the very same vocabulary
         * of chassis types as we do, hence we do not need to translate these types:
         *
         * https://github.com/devicetree-org/devicetree-specification/blob/master/source/chapter3-devicenodes.rst */
 
        chassis = chassis_is_valid(type);
        if (!chassis)
                log_debug("Invalid device-tree chassis type \"%s\", ignoring.", type);
        return chassis;
}
 
static const char* fallback_chassis(Context *c) {
        assert(c);
 
        return
                fallback_chassis_by_virtualization() ?:
                fallback_chassis_by_dmi(c) ?:
                fallback_chassis_by_acpi(c) ?:
                fallback_chassis_by_device_tree(c);
}
 
static char* context_get_chassis(Context *c) {
        const char *fallback;
        char *dmi;
 
        assert(c);
 
        if (!isempty(c->data[PROP_CHASSIS]))
                return strdup(c->data[PROP_CHASSIS]);
 
        if (get_dmi_property(c, "ID_CHASSIS", &dmi) >= 0)
                return dmi;
 
        fallback = fallback_chassis(c);
        if (fallback)
                return strdup(fallback);
 
        return NULL;
}
 
static char* context_fallback_icon_name(Context *c) {
        _cleanup_free_ char *chassis = NULL;
 
        assert(c);
 
        chassis = context_get_chassis(c);
        if (chassis)
                return strjoin("computer-", chassis);
 
        return strdup("computer");
}
 
static int context_update_kernel_hostname(
                Context *c,
                const char *transient_hostname) {
 
        _cleanup_free_ char *_hn_free = NULL;
        const char *hn;
        HostnameSource hns;
        int r;
 
        assert(c);
 
        /* /etc/hostname has the highest preference ... */
        if (c->data[PROP_STATIC_HOSTNAME_SUBSTITUTED_WILDCARDS]) {
                hn = c->data[PROP_STATIC_HOSTNAME_SUBSTITUTED_WILDCARDS];
                hns = HOSTNAME_STATIC;
 
        /* ... the transient hostname, (ie: DHCP) comes next ... */
        } else if (transient_hostname) {
                hn = transient_hostname;
                hns = HOSTNAME_TRANSIENT;
 
        /* ... and the ultimate fallback */
        } else {
                hn = _hn_free = get_default_hostname_or_fallback();
                if (!hn)
                        return log_oom();
 
                hns = HOSTNAME_DEFAULT;
        }
 
        r = sethostname_idempotent(hn);
        if (r < 0)
                return log_error_errno(r, "Failed to set hostname: %m");
 
        if (c->hostname_source != hns) {
                c->hostname_source = hns;
                r = 1;
        }
 
        if (r == 0)
                log_debug("Hostname was already set to <%s>.", hn);
        else {
                log_info("Hostname set to <%s> (%s)", hn, hostname_source_to_string(hns));
 
                hostname_update_source_hint(hn, hns);
        }
 
        return r; /* 0 if no change, 1 if something was done  */
}
 
static void unset_statp(struct stat **p) {
        assert(p);
 
        if (!*p)
                return;
 
        **p = (struct stat) {};
}
 
static int context_write_data_static_hostname(Context *c) {
        _cleanup_(unset_statp) struct stat *s = NULL;
        int r;
 
        assert(c);
 
        /* Make sure that if we fail here, we invalidate the cached information, since it was updated
         * already, even if we can't make it hit the disk. */
        s = &c->etc_hostname_stat;
 
        if (isempty(c->data[PROP_STATIC_HOSTNAME])) {
                if (unlink(etc_hostname()) < 0 && errno != ENOENT)
                        return log_error_errno(errno, "Failed to remove '%s': %m", etc_hostname());
 
                TAKE_PTR(s);
                return 0;
        }
 
        r = write_string_file(etc_hostname(), c->data[PROP_STATIC_HOSTNAME], WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_ATOMIC|WRITE_STRING_FILE_LABEL);
        if (r < 0)
                return log_error_errno(r, "Failed to write '%s': %m", etc_hostname());
 
        TAKE_PTR(s);
        return 0;
}
 
static int context_write_data_machine_info(Context *c) {
        _cleanup_(unset_statp) struct stat *s = NULL;
        static const char * const name[_PROP_MAX] = {
                [PROP_PRETTY_HOSTNAME]  = "PRETTY_HOSTNAME",
                [PROP_ICON_NAME]        = "ICON_NAME",
                [PROP_CHASSIS]          = "CHASSIS",
                [PROP_DEPLOYMENT]       = "DEPLOYMENT",
                [PROP_LOCATION]         = "LOCATION",
                [PROP_TAGS]             = "TAGS",
        };
        _cleanup_strv_free_ char **l = NULL;
        int r;
 
        assert(c);
 
        /* Make sure that if we fail here, we invalidate the cached information, since it was updated
         * already, even if we can't make it hit the disk. */
        s = &c->etc_machine_info_stat;
 
        r = load_env_file(NULL, etc_machine_info(), &l);
        if (r < 0 && r != -ENOENT)
                return log_error_errno(r, "Failed to read '%s': %m", etc_machine_info());
 
        for (HostProperty p = _PROP_MACHINE_INFO_SETTABLE_FIRST; p <= _PROP_MACHINE_INFO_SETTABLE_LAST; p++) {
                assert(name[p]);
 
                if (strv_env_assign(&l, name[p], empty_to_null(c->data[p])) < 0)
                        return log_oom();
        }
 
        if (strv_isempty(l)) {
                if (unlink(etc_machine_info()) < 0 && errno != ENOENT)
                        return log_error_errno(errno, "Failed to unlink '%s': %m", etc_machine_info());
 
                TAKE_PTR(s);
                return 0;
        }
 
        r = write_env_file(
                        AT_FDCWD,
                        etc_machine_info(),
                        /* headers= */ NULL,
                        l,
                        WRITE_ENV_FILE_LABEL);
        if (r < 0)
                return log_error_errno(r, "Failed to write '%s': %m", etc_machine_info());
 
        TAKE_PTR(s);
        return 0;
}
 
static int property_get_hardware_property(
                sd_bus_message *reply,
                Context *c,
                HostProperty prop,
                int (*getter)(Context *c, char **ret)) {
 
        _cleanup_free_ char *from_dmi = NULL;
 
        assert(reply);
        assert(c);
        assert(IN_SET(prop, PROP_HARDWARE_VENDOR, PROP_HARDWARE_MODEL,
                      PROP_HARDWARE_SKU, PROP_HARDWARE_VERSION));
        assert(getter);
 
        context_read_machine_info(c);
 
        if (isempty(c->data[prop]))
                (void) getter(c, &from_dmi);
 
        return sd_bus_message_append(reply, "s", from_dmi ?: c->data[prop]);
}
 
static int property_get_hardware_vendor(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {
 
        return property_get_hardware_property(reply, userdata, PROP_HARDWARE_VENDOR, get_hardware_vendor);
}
 
static int property_get_hardware_model(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {
 
        return property_get_hardware_property(reply, userdata, PROP_HARDWARE_MODEL, get_hardware_model);
}
 
static int property_get_hardware_sku(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {
 
        return property_get_hardware_property(reply, userdata, PROP_HARDWARE_SKU, get_hardware_sku);
}
 
static int property_get_hardware_version(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {
 
        return property_get_hardware_property(reply, userdata, PROP_HARDWARE_VERSION, get_hardware_version);
}
 
static int property_get_firmware_version(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {
 
        _cleanup_free_ char *firmware_version = NULL;
        Context *c = ASSERT_PTR(userdata);
 
        (void) get_firmware_version(c, &firmware_version);