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 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, &current);
        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);