HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/hostname/hostnamed.c
Git blob: 70adccae80d3626caa853adba05a973b4b21e9d2
Lines 2001–2746 of 2,746
return log_error_errno(r, "Failed to get boot ID: %m");
(void) vsock_get_local_cid(&local_cid);
(void) load_os_release_pairs(/* root= */ NULL, &os_release_pairs);
(void) load_env_file_pairs(/* f= */ NULL, etc_machine_info(), &machine_info_pairs);
/* Silently drop any invalid tags that might have been written into the file by hand */
_cleanup_strv_free_ char **tags = NULL;
r = machine_tags_from_string(c->data[PROP_TAGS], /* graceful= */ true, &tags);
if (r < 0)
log_warning_errno(r, "Failed to parse machine tags '%s', ignoring: %m", strnull(c->data[PROP_TAGS]));
r = sd_json_buildo(
&v,
SD_JSON_BUILD_PAIR_STRING("Hostname", hn ?: dhn),
SD_JSON_BUILD_PAIR_STRING("StaticHostname", c->data[PROP_STATIC_HOSTNAME_SUBSTITUTED_WILDCARDS]),
SD_JSON_BUILD_PAIR_STRING("PrettyHostname", c->data[PROP_PRETTY_HOSTNAME]),
SD_JSON_BUILD_PAIR_STRING("DefaultHostname", dhn),
SD_JSON_BUILD_PAIR_STRING("HostnameSource", hostname_source_to_string(c->hostname_source)),
SD_JSON_BUILD_PAIR_STRING("IconName", in ?: c->data[PROP_ICON_NAME]),
SD_JSON_BUILD_PAIR_STRING("Chassis", chassis),
SD_JSON_BUILD_PAIR_STRING("ChassisAssetTag", chassis_asset_tag),
SD_JSON_BUILD_PAIR_STRING("Deployment", c->data[PROP_DEPLOYMENT]),
SD_JSON_BUILD_PAIR_STRING("Location", c->data[PROP_LOCATION]),
SD_JSON_BUILD_PAIR_STRING("KernelName", u.sysname),
SD_JSON_BUILD_PAIR_STRING("KernelRelease", u.release),
SD_JSON_BUILD_PAIR_STRING("KernelVersion", u.version),
SD_JSON_BUILD_PAIR_STRING("OperatingSystemPrettyName", c->data[PROP_OS_PRETTY_NAME]),
SD_JSON_BUILD_PAIR_STRING("OperatingSystemFancyName", c->data[PROP_OS_FANCY_NAME]),
SD_JSON_BUILD_PAIR_STRING("OperatingSystemCPEName", c->data[PROP_OS_CPE_NAME]),
SD_JSON_BUILD_PAIR_STRING("OperatingSystemHomeURL", c->data[PROP_OS_HOME_URL]),
JSON_BUILD_PAIR_FINITE_USEC("OperatingSystemSupportEnd", eol),
SD_JSON_BUILD_PAIR("OperatingSystemReleaseData", JSON_BUILD_STRV_ENV_PAIR(os_release_pairs)),
SD_JSON_BUILD_PAIR_STRING("OperatingSystemImageID", c->data[PROP_OS_IMAGE_ID]),
SD_JSON_BUILD_PAIR_STRING("OperatingSystemImageVersion", c->data[PROP_OS_IMAGE_VERSION]),
SD_JSON_BUILD_PAIR("MachineInformationData", JSON_BUILD_STRV_ENV_PAIR(machine_info_pairs)),
SD_JSON_BUILD_PAIR_STRV("MachineTags", tags),
SD_JSON_BUILD_PAIR_STRING("HardwareVendor", vendor ?: c->data[PROP_HARDWARE_VENDOR]),
SD_JSON_BUILD_PAIR_STRING("HardwareModel", model ?: c->data[PROP_HARDWARE_MODEL]),
SD_JSON_BUILD_PAIR_STRING("HardwareSerial", serial),
SD_JSON_BUILD_PAIR_STRING("HardwareSKU", sku ?: c->data[PROP_HARDWARE_SKU]),
SD_JSON_BUILD_PAIR_STRING("HardwareVersion", hardware_version ?: c->data[PROP_HARDWARE_VERSION]),
SD_JSON_BUILD_PAIR_STRING("FirmwareVersion", firmware_version),
SD_JSON_BUILD_PAIR_STRING("FirmwareVendor", firmware_vendor),
JSON_BUILD_PAIR_FINITE_USEC("FirmwareDate", firmware_date),
SD_JSON_BUILD_PAIR_ID128("MachineID", machine_id),
SD_JSON_BUILD_PAIR_ID128("BootID", boot_id),
SD_JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(product_uuid), "ProductUUID", SD_JSON_BUILD_ID128(product_uuid)),
SD_JSON_BUILD_PAIR_CONDITION(sd_id128_is_null(product_uuid), "ProductUUID", SD_JSON_BUILD_NULL),
SD_JSON_BUILD_PAIR_CONDITION(local_cid != VMADDR_CID_ANY, "VSockCID", SD_JSON_BUILD_UNSIGNED(local_cid)),
SD_JSON_BUILD_PAIR_CONDITION(local_cid == VMADDR_CID_ANY, "VSockCID", SD_JSON_BUILD_NULL));
if (r < 0)
return log_error_errno(r, "Failed to build JSON data: %m");
*ret = TAKE_PTR(v);
return 0;
}
static int method_describe(sd_bus_message *m, void *userdata, sd_bus_error *error) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
Context *c = ASSERT_PTR(userdata);
_cleanup_free_ char *text = NULL;
bool privileged;
int r;
assert(m);
r = bus_verify_polkit_async(
m,
"org.freedesktop.hostname1.get-description",
/* details= */ NULL,
&c->polkit_registry,
error);
if (r == 0)
return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
/* We ignore all authentication errors here, since most data is unprivileged, the one exception being
* the product ID which we'll check explicitly. */
privileged = r > 0;
r = build_describe_response(c, privileged, &v);
if (r < 0)
return r;
r = sd_json_variant_format(v, 0, &text);
if (r < 0)
return log_error_errno(r, "Failed to format JSON data: %m");
return sd_bus_reply_method_return(m, "s", text);
}
static const sd_bus_vtable hostname_vtable[] = {
SD_BUS_VTABLE_START(0),
SD_BUS_PROPERTY("Hostname", "s", property_get_hostname, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("StaticHostname", "s", property_get_static_hostname, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("PrettyHostname", "s", property_get_machine_info_field, offsetof(Context, data[PROP_PRETTY_HOSTNAME]), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("DefaultHostname", "s", property_get_default_hostname, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("HostnameSource", "s", property_get_hostname_source, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("IconName", "s", property_get_icon_name, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("Chassis", "s", property_get_chassis, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("Deployment", "s", property_get_machine_info_field, offsetof(Context, data[PROP_DEPLOYMENT]), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("Location", "s", property_get_machine_info_field, offsetof(Context, data[PROP_LOCATION]), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("Tags", "as", property_get_tags, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("KernelName", "s", property_get_uname_field, offsetof(struct utsname, sysname), SD_BUS_VTABLE_ABSOLUTE_OFFSET|SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("KernelRelease", "s", property_get_uname_field, offsetof(struct utsname, release), SD_BUS_VTABLE_ABSOLUTE_OFFSET|SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("KernelVersion", "s", property_get_uname_field, offsetof(struct utsname, version), SD_BUS_VTABLE_ABSOLUTE_OFFSET|SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("OperatingSystemPrettyName", "s", property_get_os_release_field, offsetof(Context, data[PROP_OS_PRETTY_NAME]), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("OperatingSystemFancyName", "s", property_get_os_release_field, offsetof(Context, data[PROP_OS_FANCY_NAME]), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("OperatingSystemCPEName", "s", property_get_os_release_field, offsetof(Context, data[PROP_OS_CPE_NAME]), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("OperatingSystemSupportEnd", "t", property_get_os_support_end, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("HomeURL", "s", property_get_os_release_field, offsetof(Context, data[PROP_OS_HOME_URL]), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("OperatingSystemImageID", "s", property_get_os_release_field, offsetof(Context, data[PROP_OS_IMAGE_ID]), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("OperatingSystemImageVersion", "s", property_get_os_release_field, offsetof(Context, data[PROP_OS_IMAGE_VERSION]), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("HardwareVendor", "s", property_get_hardware_vendor, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("HardwareModel", "s", property_get_hardware_model, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("HardwareSKU", "s", property_get_hardware_sku, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("HardwareVersion", "s", property_get_hardware_version, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("FirmwareVersion", "s", property_get_firmware_version, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("FirmwareVendor", "s", property_get_firmware_vendor, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("FirmwareDate", "t", property_get_firmware_date, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("MachineID", "ay", property_get_machine_id, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("BootID", "ay", property_get_boot_id, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("VSockCID", "u", property_get_vsock_cid, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("ChassisAssetTag", "s", property_get_chassis_asset_tag, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_METHOD_WITH_ARGS("SetHostname",
SD_BUS_ARGS("s", hostname, "b", interactive),
SD_BUS_NO_RESULT,
method_set_hostname,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SetStaticHostname",
SD_BUS_ARGS("s", hostname, "b", interactive),
SD_BUS_NO_RESULT,
method_set_static_hostname,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SetPrettyHostname",
SD_BUS_ARGS("s", hostname, "b", interactive),
SD_BUS_NO_RESULT,
method_set_pretty_hostname,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SetIconName",
SD_BUS_ARGS("s", icon, "b", interactive),
SD_BUS_NO_RESULT,
method_set_icon_name,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SetChassis",
SD_BUS_ARGS("s", chassis, "b", interactive),
SD_BUS_NO_RESULT,
method_set_chassis,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SetDeployment",
SD_BUS_ARGS("s", deployment, "b", interactive),
SD_BUS_NO_RESULT,
method_set_deployment,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SetLocation",
SD_BUS_ARGS("s", location, "b", interactive),
SD_BUS_NO_RESULT,
method_set_location,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SetTags",
SD_BUS_ARGS("as", tags),
SD_BUS_NO_RESULT,
method_set_tags,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("AddAndRemoveTags",
SD_BUS_ARGS("as", add, "as", remove),
SD_BUS_NO_RESULT,
method_add_and_remove_tags,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("GetProductUUID",
SD_BUS_ARGS("b", interactive),
SD_BUS_RESULT("ay", uuid),
method_get_product_uuid,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("GetHardwareSerial",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("s", serial),
method_get_hardware_serial,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("Describe",
SD_BUS_NO_ARGS,
SD_BUS_RESULT("s", json),
method_describe,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("GetMachineInfo",
SD_BUS_ARGS("s", field),
SD_BUS_RESULT("s", value),
method_get_machine_info,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_VTABLE_END,
};
static const BusObjectImplementation manager_object = {
"/org/freedesktop/hostname1",
"org.freedesktop.hostname1",
.vtables = BUS_VTABLES(hostname_vtable),
};
static int connect_bus(Context *c) {
int r;
assert(c);
assert(c->event);
assert(!c->bus);
r = bus_open_system_watch_bind_with_description(&c->bus, "bus-api-hostname");
if (r < 0)
return log_error_errno(r, "Failed to get system bus connection: %m");
r = bus_add_implementation(c->bus, &manager_object, c);
if (r < 0)
return r;
r = bus_log_control_api_register(c->bus);
if (r < 0)
return r;
r = sd_bus_request_name_async(c->bus, NULL, "org.freedesktop.hostname1", 0, NULL, NULL);
if (r < 0)
return log_error_errno(r, "Failed to request name: %m");
r = sd_bus_attach_event(c->bus, c->event, 0);
if (r < 0)
return log_error_errno(r, "Failed to attach bus to event loop: %m");
return 0;
}
static int vl_method_describe(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
Context *c = ASSERT_PTR(userdata);
bool privileged;
int r;
assert(link);
assert(parameters);
r = sd_varlink_dispatch(link, parameters, dispatch_table_polkit_only, /* userdata= */ NULL);
if (r != 0)
return r;
r = varlink_verify_polkit_async_full(
link,
c->bus,
"org.freedesktop.hostname1.get-hardware-serial",
/* details= */ NULL,
UID_INVALID,
POLKIT_DONT_REPLY,
&c->polkit_registry,
/* ret_admin= */ NULL);
if (r == 0)
return 0; /* No authorization for now, but the async polkit stuff will call us again when it has it */
/* We ignore all authentication errors here, since most data is unprivileged, the one exception being
* the product ID which we'll check explicitly. */
privileged = r > 0;
_cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
r = build_describe_response(c, privileged, &v);
if (r < 0)
return r;
return sd_varlink_reply(link, v);
}
static int vl_validate_and_substitute_hostname(sd_varlink *link, const char *name, char **ret_substituted) {
int r;
assert(link);
assert(ret_substituted);
r = validate_and_substitute_hostname(name, ret_substituted);
if (r == -EUCLEAN)
return sd_varlink_error_invalid_parameter_name(link, "newValue");
return r;
}
static int vl_method_set_hostname(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
static const sd_json_dispatch_field dispatch_table[] = {
{ "newValue", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, 0, SD_JSON_NULLABLE },
VARLINK_DISPATCH_POLKIT_FIELD,
{}
};
Context *c = ASSERT_PTR(userdata);
int r;
assert(link);
assert(parameters);
_cleanup_free_ char *value = NULL;
r = sd_varlink_dispatch(link, parameters, dispatch_table, &value);
if (r != 0)
return r;
const char *name = empty_to_null(value);
/* We always go through with the procedure below without comparing to the current hostname, because
* we might want to adjust hostname source information even if the actual hostname is unchanged. */
_cleanup_free_ char *substituted = NULL;
r = vl_validate_and_substitute_hostname(link, name, &substituted);
if (r < 0)
return r;
name = substituted;
r = varlink_verify_polkit_async(
link,
c->bus,
"org.freedesktop.hostname1.set-hostname",
/* details= */ NULL,
&c->polkit_registry);
if (r <= 0)
return r;
context_read_etc_hostname(c);
r = context_update_kernel_hostname(c, name);
if (r < 0)
return r;
if (r > 0)
(void) sd_bus_emit_properties_changed(c->bus,
"/org/freedesktop/hostname1", "org.freedesktop.hostname1",
"Hostname", "HostnameSource", NULL);
return sd_varlink_reply(link, NULL);
}
static int vl_method_set_static_hostname(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
static const sd_json_dispatch_field dispatch_table[] = {
{ "newValue", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, 0, SD_JSON_NULLABLE },
VARLINK_DISPATCH_POLKIT_FIELD,
{}
};
Context *c = ASSERT_PTR(userdata);
int r;
assert(link);
assert(parameters);
_cleanup_free_ char *value = NULL;
r = sd_varlink_dispatch(link, parameters, dispatch_table, &value);
if (r != 0)
return r;
const char *name = empty_to_null(value);
context_read_etc_hostname(c);
if (streq_ptr(name, c->data[PROP_STATIC_HOSTNAME]))
return sd_varlink_reply(link, NULL);
_cleanup_free_ char *substituted = NULL;
r = vl_validate_and_substitute_hostname(link, name, &substituted);
if (r < 0)
return r;
r = varlink_verify_polkit_async(
link,
c->bus,
"org.freedesktop.hostname1.set-static-hostname",
/* details= */ NULL,
&c->polkit_registry);
if (r <= 0)
return r;
r = free_and_strdup_warn(&c->data[PROP_STATIC_HOSTNAME], name);
if (r < 0)
return r;
free_and_replace(c->data[PROP_STATIC_HOSTNAME_SUBSTITUTED_WILDCARDS], substituted);
r = context_write_data_static_hostname(c);
if (r < 0)
return r;
r = context_update_kernel_hostname(c, /* transient_hostname= */ NULL);
if (r < 0)
return r;
(void) sd_bus_emit_properties_changed(c->bus,
"/org/freedesktop/hostname1", "org.freedesktop.hostname1",
"StaticHostname", "Hostname", "HostnameSource", NULL);
return sd_varlink_reply(link, NULL);
}
static int vl_set_machine_info(sd_varlink *link, sd_json_variant *parameters, void *userdata, HostProperty prop) {
static const sd_json_dispatch_field dispatch_table[] = {
{ "newValue", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, 0, SD_JSON_NULLABLE },
VARLINK_DISPATCH_POLKIT_FIELD,
{}
};
Context *c = ASSERT_PTR(userdata);
int r;
assert(link);
assert(parameters);
_cleanup_free_ char *value = NULL;
r = sd_varlink_dispatch(link, parameters, dispatch_table, &value);
if (r != 0)
return r;
const char *name = empty_to_null(value),
*polkit_action = "org.freedesktop.hostname1.set-machine-info",
*bus_property, *human_name;
switch (prop) {
case PROP_PRETTY_HOSTNAME:
if (name && !pretty_hostname_is_valid(name))
return sd_varlink_error_invalid_parameter_name(link, "newValue");
bus_property = "PrettyHostname";
human_name = "pretty hostname";
/* Since the pretty hostname should always be changed at the same time as the static one, use
* the same policy action for both... */
polkit_action = "org.freedesktop.hostname1.set-static-hostname";
break;
case PROP_ICON_NAME:
/* The icon name might ultimately be used as file name, so better be safe than sorry. */
if (name && !icon_name_is_valid(name))
return sd_varlink_error_invalid_parameter_name(link, "newValue");
bus_property = "IconName";
human_name = "icon name";
break;
case PROP_CHASSIS:
if (name && !chassis_is_valid(name))
return sd_varlink_error_invalid_parameter_name(link, "newValue");
bus_property = "Chassis";
human_name = "chassis";
break;
case PROP_DEPLOYMENT:
if (name && !deployment_is_valid(name))
return sd_varlink_error_invalid_parameter_name(link, "newValue");
bus_property = "Deployment";
human_name = "deployment";
break;
case PROP_LOCATION:
if (name && !location_is_valid(name))
return sd_varlink_error_invalid_parameter_name(link, "newValue");
bus_property = "Location";
human_name = "location";
break;
default:
assert_not_reached();
}
context_read_machine_info(c);
if (streq_ptr(name, c->data[prop]))
return sd_varlink_reply(link, NULL);
r = varlink_verify_polkit_async(
link,
c->bus,
polkit_action,
/* details= */ NULL,
&c->polkit_registry);
if (r <= 0)
return r;
r = free_and_strdup_warn(&c->data[prop], name);
if (r < 0)
return r;
r = context_write_data_machine_info(c);
if (r < 0)
return r;
log_info("Changed %s to '%s'", human_name, strna(c->data[prop]));
(void) sd_bus_emit_properties_changed(
c->bus,
"/org/freedesktop/hostname1",
"org.freedesktop.hostname1",
bus_property,
NULL);
return sd_varlink_reply(link, NULL);
}
static int vl_method_set_pretty_hostname(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
return vl_set_machine_info(link, parameters, userdata, PROP_PRETTY_HOSTNAME);
}
static int vl_method_set_icon_name(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
return vl_set_machine_info(link, parameters, userdata, PROP_ICON_NAME);
}
static int vl_method_set_chassis(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
return vl_set_machine_info(link, parameters, userdata, PROP_CHASSIS);
}
static int vl_method_set_deployment(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
return vl_set_machine_info(link, parameters, userdata, PROP_DEPLOYMENT);
}
static int vl_method_set_location(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
return vl_set_machine_info(link, parameters, userdata, PROP_LOCATION);
}
typedef struct SetTagsParameters {
char **set;
char **add;
char **remove;
} SetTagsParameters;
static void set_tags_parameters_done(SetTagsParameters *p) {
assert(p);
strv_free(p->set);
strv_free(p->add);
strv_free(p->remove);
}
static int vl_method_set_tags(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
static const sd_json_dispatch_field dispatch_table[] = {
{ "set", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_strv, offsetof(SetTagsParameters, set), SD_JSON_NULLABLE },
{ "add", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_strv, offsetof(SetTagsParameters, add), SD_JSON_NULLABLE },
{ "remove", SD_JSON_VARIANT_ARRAY, sd_json_dispatch_strv, offsetof(SetTagsParameters, remove), SD_JSON_NULLABLE },
VARLINK_DISPATCH_POLKIT_FIELD,
{}
};
Context *c = ASSERT_PTR(userdata);
int r;
assert(link);
assert(parameters);
_cleanup_(set_tags_parameters_done) SetTagsParameters p = {};
r = sd_varlink_dispatch(link, parameters, dispatch_table, &p);
if (r != 0)
return r;
/* Both an absent 'set' field and an explicit null map to a NULL strv after dispatching, but only the
* former should keep the current tags — an explicit (possibly empty) 'set' resets the list. Hence
* check for the field's presence separately. */
bool reset = sd_json_variant_by_key(parameters, "set");
if (reset && !machine_tag_list_is_valid(p.set))
return sd_varlink_error_invalid_parameter_name(link, "set");
if (!machine_tag_list_is_valid(p.add))
return sd_varlink_error_invalid_parameter_name(link, "add");
if (!machine_tag_list_is_valid(p.remove))
return sd_varlink_error_invalid_parameter_name(link, "remove");
context_read_machine_info(c);
_cleanup_strv_free_ char **current = NULL;
r = machine_tags_from_string(c->data[PROP_TAGS], /* graceful= */ true, ¤t);
if (r < 0)
return r;
/* Use either the explicitly specified tag list or the current one as the basis, then apply the
* additions and removals on top. */
_cleanup_strv_free_ char **tags = NULL;
r = machine_tags_add_remove(reset ? p.set : current, p.add, p.remove, &tags);
if (r == -E2BIG)
return sd_varlink_error_invalid_parameter_name(link, "add");
if (r < 0)
return r;
if (strv_equal(tags, current))
return sd_varlink_reply(link, NULL);
r = varlink_verify_polkit_async(
link,
c->bus,
"org.freedesktop.hostname1.set-machine-info",
/* details= */ NULL,
&c->polkit_registry);
if (r <= 0)
return r;
r = context_store_tags(c, tags);
if (r < 0)
return r;
return sd_varlink_reply(link, NULL);
}
static int connect_varlink(Context *c) {
int r;
assert(c);
assert(c->event);
assert(!c->varlink_server);
r = varlink_server_new(
&c->varlink_server,
SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA,
c);
if (r < 0)
return log_error_errno(r, "Failed to allocate Varlink server: %m");
r = sd_varlink_server_add_interface_many(
c->varlink_server,
&vl_interface_io_systemd_Hostname,
&vl_interface_io_systemd_service);
if (r < 0)
return log_error_errno(r, "Failed to add Hostname interface to Varlink server: %m");
r = sd_varlink_server_bind_method_many(
c->varlink_server,
"io.systemd.Hostname.Describe", vl_method_describe,
"io.systemd.Hostname.SetHostname", vl_method_set_hostname,
"io.systemd.Hostname.SetStaticHostname", vl_method_set_static_hostname,
"io.systemd.Hostname.SetPrettyHostname", vl_method_set_pretty_hostname,
"io.systemd.Hostname.SetIconName", vl_method_set_icon_name,
"io.systemd.Hostname.SetChassis", vl_method_set_chassis,
"io.systemd.Hostname.SetDeployment", vl_method_set_deployment,
"io.systemd.Hostname.SetLocation", vl_method_set_location,
"io.systemd.Hostname.SetTags", vl_method_set_tags,
"io.systemd.service.Ping", varlink_method_ping,
"io.systemd.service.SetLogLevel", varlink_method_set_log_level,
"io.systemd.service.GetLogLevel", varlink_method_get_log_level,
"io.systemd.service.GetEnvironment", varlink_method_get_environment);
if (r < 0)
return log_error_errno(r, "Failed to bind Varlink method calls: %m");
r = sd_varlink_server_attach_event(c->varlink_server, c->event, SD_EVENT_PRIORITY_NORMAL);
if (r < 0)
return log_error_errno(r, "Failed to attach Varlink server to event loop: %m");
r = sd_varlink_server_listen_auto(c->varlink_server);
if (r < 0)
return log_error_errno(r, "Failed to bind to passed Varlink sockets: %m");
if (r == 0) {
r = sd_varlink_server_listen_address(c->varlink_server, "/run/systemd/io.systemd.Hostname", 0666);
if (r < 0)
return log_error_errno(r, "Failed to bind to Varlink socket: %m");
}
return 0;
}
static bool context_check_idle(void *userdata) {
Context *c = ASSERT_PTR(userdata);
return sd_varlink_server_current_connections(c->varlink_server) == 0 &&
hashmap_isempty(c->polkit_registry);
}
COMMAND(
"systemd-hostnamed\0",
"Manage the system hostname and related metadata.",
.man_pages = "systemd-hostnamed.service(8)\0",
.option_namespace = "service",
.option_groups =
"Options\0"
"Bus introspection\0",
);
static int run(int argc, char *argv[]) {
_cleanup_(context_destroy) Context context = {
.hostname_source = _HOSTNAME_INVALID, /* appropriate value will be set later */
};
int r;
LIBSELINUX_NOTE(recommended);
log_setup();
r = service_parse_argv(BUS_IMPLEMENTATIONS(&manager_object,
&log_control_object),
/* runtime_scope= */ NULL,
argc, argv);
if (r <= 0)
return r;
umask(0022);
r = mac_init();
if (r < 0)
return r;
r = context_acquire_dmi_device(&context);
if (r < 0)
return r;
r = context_acquire_acpi_device(&context);
if (r < 0)
return r;
r = context_acquire_device_tree(&context);
if (r < 0)
return r;
r = sd_event_default(&context.event);
if (r < 0)
return log_error_errno(r, "Failed to allocate event loop: %m");
(void) sd_event_set_watchdog(context.event, true);
r = sd_event_set_signal_exit(context.event, true);
if (r < 0)
return log_error_errno(r, "Failed to install SIGINT/SIGTERM handlers: %m");
r = sd_event_add_signal(context.event, /* ret= */ NULL, (SIGRTMIN+18)|SD_EVENT_SIGNAL_PROCMASK, sigrtmin18_handler, /* userdata= */ NULL);
if (r < 0)
return log_error_errno(r, "Failed to install SIGRTMIN+18 handler: %m");
r = sd_event_add_memory_pressure(context.event, /* ret= */ NULL, /* callback= */ NULL, /* userdata= */ NULL);
if (r < 0)
log_debug_errno(r, "Failed to allocate memory pressure event source, ignoring: %m");
r = connect_bus(&context);
if (r < 0)
return r;
r = connect_varlink(&context);
if (r < 0)
return r;
r = sd_notify(false, NOTIFY_READY_MESSAGE);
if (r < 0)
log_warning_errno(r, "Failed to send readiness notification, ignoring: %m");
r = bus_event_loop_with_idle(
context.event,
context.bus,
"org.freedesktop.hostname1",
DEFAULT_EXIT_USEC,
context_check_idle,
&context);
if (r < 0)
return log_error_errno(r, "Failed to run event loop: %m");
return 0;
}
DEFINE_MAIN_FUNCTION(run);