HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/hostname/hostnamed.c
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(), ¤t_stat) >= 0 &&
stat_inode_unmodified(&c->etc_hostname_stat, ¤t_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(), ¤t_stat) >= 0 &&
stat_inode_unmodified(&c->etc_machine_info_stat, ¤t_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", ¤t_stat) >= 0 ||
stat("/usr/lib/os-release", ¤t_stat) >= 0) &&
stat_inode_unmodified(&c->etc_os_release_stat, ¤t_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);