HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/imds/imdsd.c

121,943 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: d4e5b23937d568a82c995f2f37217f1f28097dc8

Lines 2001–3000 of 3,099

static int dispatch_fwmark(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        Context *c = ASSERT_PTR(userdata);
        int r;
 
        /* Parses a firewall mark passed via Varlink/JSON. Note that any 32bit fwmark is valid, hence we keep
         * track if it is set or not in a separate boolean. */
 
        if (sd_json_variant_is_null(variant)) {
                c->fwmark_set = false;
                return 0;
        }
 
        r = sd_json_dispatch_uint32(name, variant, flags, &c->fwmark);
        if (r < 0)
                return r;
 
        c->fwmark_set = true;
        return 0;
}
 
static int vl_method_get(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        Context *c = ASSERT_PTR(userdata);
        int r;
 
        assert(link);
 
        if (!c->event)
                c->event = sd_event_ref(sd_varlink_get_event(link));
 
        context_new_request(c);
 
        static const sd_json_dispatch_field dispatch_table[] = {
                { "wellKnown",    SD_JSON_VARIANT_STRING,        dispatch_well_known,      offsetof(Context, well_known),   0 },
                { "key",          SD_JSON_VARIANT_STRING,        sd_json_dispatch_string,  offsetof(Context, key),          0 },
                { "interface",    _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_ifindex,    offsetof(Context, ifindex),      0 },
                { "refreshUSec",  _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64,  offsetof(Context, refresh_usec), 0 },
                { "firewallMark", _SD_JSON_VARIANT_TYPE_INVALID, dispatch_fwmark,          0,                               0 },
                { "cache",        SD_JSON_VARIANT_BOOLEAN,       sd_json_dispatch_stdbool, offsetof(Context, cache),        0 },
                { "wait",         SD_JSON_VARIANT_BOOLEAN,       sd_json_dispatch_stdbool, offsetof(Context, wait),         0 },
                VARLINK_DISPATCH_POLKIT_FIELD,
                {}
        };
 
        r = sd_varlink_dispatch(link, parameters, dispatch_table, c);
        if (r != 0)
                return r;
 
        if (c->key) {
                if (!imds_key_is_valid(c->key))
                        return sd_varlink_error_invalid_parameter_name(link, "key");
 
                if (c->well_known < 0)
                        c->well_known = IMDS_BASE;
                else if (!imds_well_known_can_suffix(c->well_known))
                        return sd_varlink_error_invalid_parameter_name(link, "key");
        } else if (c->well_known < 0)
                return sd_varlink_error_invalid_parameter_name(link, "key");
 
        if (c->refresh_usec < REFRESH_USEC_MIN)
                c->refresh_usec = REFRESH_USEC_MIN;
 
        uid_t peer_uid;
        r = sd_varlink_get_peer_uid(link, &peer_uid);
        if (r < 0)
                return r;
 
        if (peer_uid != 0 && peer_uid != getuid()) {
                /* Ask polkit if client is not privileged */
 
                r = context_acquire_system_bus(c);
                if (r < 0)
                        return r;
 
                const char* l[5];
                size_t k = 0;
                if (c->well_known >= 0) {
                        l[k++] = "wellKnown";
                        l[k++] = imds_well_known_to_string(c->well_known);
                }
                if (c->key) {
                        l[k++] = "key";
                        l[k++] = c->key;
                }
                l[k] = NULL;
 
                r = varlink_verify_polkit_async(
                                link,
                                c->system_bus,
                                "io.systemd.imds.get",
                                l,
                                &c->polkit_registry);
                if (r <= 0)
                        return r;
        }
 
        if (imds_configured(LOG_DEBUG) < 0)
                return sd_varlink_error(link, "io.systemd.InstanceMetadata.NotSupported", NULL);
 
        /* Up to this point we only validated/parsed stuff. Now we actually execute stuff, hence from now on
         * we need to go through context_fail() when failing (context_success() if we succeed early), to
         * release resources we might have allocated. */
        assert(!c->current_link);
        c->current_link = sd_varlink_ref(link);
 
        _cleanup_free_ char *k = NULL; /* initialize here, to avoid that this remains uninitialized due to the gotos below */
 
        if (c->ifindex <= 0) {
                /* Try to load the previously used network interface */
                r = context_load_ifname(c);
                if (r < 0)
                        goto fail;
        }
 
        r = context_combine_key(c, &k);
        if (r == -ENODATA) {
                context_fail_full(c, r, "io.systemd.InstanceMetadata.WellKnownKeyUnset");
                return r;
        }
        if (r < 0)
                goto fail;
 
        context_log(c, LOG_DEBUG, "Will request '%s' now.", k);
 
        if (c->ifindex > 0) {
                CacheResult cr = context_process_cache(c);
                if (cr < 0) {
                        r = cr;
                        goto fail;
                }
                if (cr == CACHE_RESULT_HIT) {
                        context_success(c);
                        return 0;
                }
                if (cr == CACHE_RESULT_KEY_NOT_FOUND)
                        return context_fail_cached_key_not_found(c);
 
                r = context_acquire_token(c);
                if (r < 0)
                        goto fail;
 
                r = context_acquire_data(c);
                if (r < 0)
                        goto fail;
 
                r = context_start_overall_timeout(c, DIRECT_OVERALL_TIMEOUT_USEC);
                if (r < 0)
                        goto fail;
        } else {
                r = context_spawn_children(c);
                if (r < 0)
                        goto fail;
 
                r = context_start_overall_timeout(c, INDIRECT_OVERALL_TIMEOUT_USEC);
                if (r < 0)
                        goto fail;
        }
 
        context_log(c, LOG_DEBUG, "Incoming method call is now pending");
        return 1;
 
fail:
        context_fail(c, r);
        return r;
}
 
static int vl_method_get_vendor_info(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        Context *c = ASSERT_PTR(userdata);
        int r;
 
        assert(link);
 
        r = sd_varlink_dispatch(link, parameters, /* dispatch_table= */ NULL, c);
        if (r != 0)
                return r;
 
        /* NB! We allow access to this call without Polkit */
 
        if (imds_configured(LOG_DEBUG) < 0)
                return sd_varlink_error(link, "io.systemd.InstanceMetadata.NotSupported", NULL);
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *wkj = NULL;
        for (ImdsWellKnown i = 0; i < _IMDS_WELL_KNOWN_MAX; i++) {
                if (!arg_well_known_key[i])
                        continue;
 
                r = sd_json_variant_set_field_string(&wkj, imds_well_known_to_string(i), arg_well_known_key[i]);
                if (r < 0)
                        return r;
        }
 
        return sd_varlink_replybo(
                        link,
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("vendor", arg_vendor),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("tokenUrl", arg_token_url),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("refreshHeaderName", arg_refresh_header_name),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("dataUrl", arg_data_url),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("dataUrlSuffix", arg_data_url_suffix),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("tokenHeaderName", arg_token_header_name),
                        JSON_BUILD_PAIR_STRV_NON_EMPTY("extraHeader", arg_extra_header),
                        JSON_BUILD_PAIR_IN4_ADDR_NON_NULL("addressIPv4", &arg_address_ipv4),
                        JSON_BUILD_PAIR_IN6_ADDR_NON_NULL("addressIPv6", &arg_address_ipv6),
                        JSON_BUILD_PAIR_VARIANT_NON_EMPTY("wellKnown", wkj));
}
 
static int vl_server(void) {
        _cleanup_(context_done) Context c = CONTEXT_NULL;
        int r;
 
        /* Invocation as Varlink service */
 
        _cleanup_(sd_varlink_server_unrefp) sd_varlink_server *varlink_server = NULL;
        r = varlink_server_new(
                        &varlink_server,
                        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(varlink_server, &vl_interface_io_systemd_InstanceMetadata);
        if (r < 0)
                return log_error_errno(r, "Failed to add Varlink interface: %m");
 
        r = sd_varlink_server_bind_method_many(
                        varlink_server,
                        "io.systemd.InstanceMetadata.Get", vl_method_get,
                        "io.systemd.InstanceMetadata.GetVendorInfo", vl_method_get_vendor_info);
        if (r < 0)
                return log_error_errno(r, "Failed to bind Varlink methods: %m");
 
        r = sd_varlink_server_loop_auto(varlink_server);
        if (r < 0)
                return log_error_errno(r, "Failed to run Varlink event loop: %m");
 
        return 0;
}
 
static bool http_header_name_valid(const char *a) {
        return a && ascii_is_valid(a) && !string_has_cc(a, /* ok= */ NULL) && !strchr(a, ':');
}
 
static int parse_argv(int argc, char *argv[]) {
        int r;
 
        assert(argc >= 0);
        assert(argv);
 
        OptionParser opts = { argc, argv };
 
        FOREACH_OPTION_OR_RETURN(c, &opts)
                switch (c) {
 
                OPTION_COMMON_HELP:
                        return command_print_help();
 
                OPTION_COMMON_VERSION:
                        return version();
 
                OPTION('i', "interface", "INTERFACE", "Use the specified interface"):
                        if (isempty(opts.arg)) {
                                arg_ifname = mfree(arg_ifname);
                                break;
                        }
 
                        if (!ifname_valid_full(opts.arg, IFNAME_VALID_ALTERNATIVE|IFNAME_VALID_NUMERIC))
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Interface name '%s' is not valid.", opts.arg);
 
                        r = free_and_strdup_warn(&arg_ifname, opts.arg);
                        if (r < 0)
                                return r;
 
                        break;
 
                OPTION_LONG("refresh", "SEC", "Set token refresh time"): {
                        if (isempty(opts.arg)) {
                                arg_refresh_usec = REFRESH_USEC_DEFAULT;
                                break;
                        }
 
                        usec_t t;
                        r = parse_sec(opts.arg, &t);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse refresh timeout: %s", opts.arg);
                        if (t < REFRESH_USEC_MIN) {
                                log_info("Increasing specified refresh time to %s, lower values are not supported.",
                                         FORMAT_TIMESPAN(REFRESH_USEC_MIN, 0));
                                arg_refresh_usec = REFRESH_USEC_MIN;
                        } else
                                arg_refresh_usec = t;
                        break;
                }
 
                OPTION_LONG("fwmark", "INTEGER", "Choose firewall mark for HTTP traffic"):
                        if (isempty(opts.arg)) {
                                arg_fwmark_set = false;
                                break;
                        }
 
                        if (streq(opts.arg, "default")) {
                                arg_fwmark = FWMARK_DEFAULT;
                                arg_fwmark_set = true;
                                break;
                        }
 
                        r = safe_atou32(opts.arg, &arg_fwmark);
                        if (r < 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to parse --fwmark= parameter: %s", opts.arg);
 
                        arg_fwmark_set = true;
                        break;
 
                OPTION_LONG("cache", "BOOL", "Enable/disable cache use"):
                        r = parse_boolean_argument("--cache", opts.arg, &arg_cache);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("wait", "BOOL", "Whether to wait for connectivity"):
                        r = parse_boolean_argument("--wait", opts.arg, &arg_wait);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_SHORT('w', NULL, "Same as --wait=yes"):
                        arg_wait = true;
                        break;
 
                OPTION('K', "well-known", "KEY", "Select well-known key"): {
                        if (isempty(opts.arg)) {
                                arg_well_known = _IMDS_WELL_KNOWN_INVALID;
                                break;
                        }
 
                        ImdsWellKnown wk = imds_well_known_from_string(opts.arg);
                        if (wk < 0)
                                return log_error_errno(wk, "Failed to parse --well-known= parameter: %m");
 
                        arg_well_known = wk;
                        break;
                }
 
                OPTION_LONG("setup-network", NULL, "Generate .network and .rr files"):
                        arg_setup_network = true;
                        break;
 
                /* The following all configure endpoint information explicitly */
                OPTION_GROUP("Manual Endpoint Configuration"): {}
 
                OPTION_LONG("vendor", "VENDOR", "Specify IMDS vendor literally"):
                        if (isempty(opts.arg)) {
                                arg_vendor = mfree(arg_vendor);
                                break;
                        }
 
                        r = free_and_strdup_warn(&arg_vendor, opts.arg);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("token-url", "URL", "URL for acquiring token"):
                        if (isempty(opts.arg)) {
                                arg_token_url = mfree(arg_token_url);
                                break;
                        }
 
                        if (!http_url_is_valid(opts.arg))
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid URL: %s", opts.arg);
 
                        r = free_and_strdup_warn(&arg_token_url, opts.arg);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("refresh-header-name", "NAME", "Header name for passing refresh time"):
                        if (isempty(opts.arg)) {
                                arg_refresh_header_name = mfree(arg_refresh_header_name);
                                break;
                        }
 
                        if (!http_header_name_valid(opts.arg))
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid HTTP header name: %s", opts.arg);
 
                        r = free_and_strdup_warn(&arg_refresh_header_name, opts.arg);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("data-url", "URL", "Base URL for acquiring data"):
                        if (isempty(opts.arg)) {
                                arg_data_url = mfree(arg_data_url);
                                break;
                        }
 
                        if (!http_url_is_valid(opts.arg))
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid URL: %s", opts.arg);
 
                        r = free_and_strdup_warn(&arg_data_url, opts.arg);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("data-url-suffix", "STRING", "Suffix to append to data URL"):
                        if (isempty(opts.arg)) {
                                arg_data_url_suffix = mfree(arg_data_url_suffix);
                                break;
                        }
 
                        if (!ascii_is_valid(opts.arg) || string_has_cc(opts.arg, /* ok= */ NULL))
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid URL suffix: %s", opts.arg);
 
                        r = free_and_strdup_warn(&arg_data_url_suffix, opts.arg);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("token-header-name", "NAME", "Header name for passing token string"):
                        if (isempty(opts.arg)) {
                                arg_token_header_name = mfree(arg_token_header_name);
                                break;
                        }
 
                        if (!http_header_name_valid(opts.arg))
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid HTTP header name: %s", opts.arg);
 
                        r = free_and_strdup_warn(&arg_token_header_name, opts.arg);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("extra-header", "NAME: VALUE", "Additional header to pass to data transfer"):
                        if (isempty(opts.arg)) {
                                arg_extra_header = strv_free(arg_extra_header);
                                break;
                        }
 
                        if (!http_header_valid(opts.arg))
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid HTTP header: %s", opts.arg);
 
                        if (strv_extend(&arg_extra_header, opts.arg) < 0)
                                return log_oom();
                        break;
 
                OPTION_LONG("address-ipv4", "ADDRESS", "Configure IPv4 address of the IMDS server"): {
                        if (isempty(opts.arg)) {
                                arg_address_ipv4 = (struct in_addr) {};
                                break;
                        }
 
                        union in_addr_union u;
                        r = in_addr_from_string(AF_INET, opts.arg, &u);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse IPv4 address: %s", opts.arg);
                        arg_address_ipv4 = u.in;
                        break;
                }
 
                OPTION_LONG("address-ipv6", "ADDRESS", "Configure IPv6 address of the IMDS server"): {
                        if (isempty(opts.arg)) {
                                arg_address_ipv6 = (struct in6_addr) {};
                                break;
                        }
 
                        union in_addr_union u;
                        r = in_addr_from_string(AF_INET6, opts.arg, &u);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse IPv6 address: %s", opts.arg);
                        arg_address_ipv6 = u.in6;
                        break;
                }
 
                OPTION_LONG("well-known-key", "NAME:KEY", "Configure the location of well-known keys"): {
                        if (isempty(opts.arg)) {
                                for (ImdsWellKnown wk = 0; wk < _IMDS_WELL_KNOWN_MAX; wk++)
                                        arg_well_known_key[wk] = mfree(arg_well_known_key[wk]);
                                break;
                        }
 
                        const char *e = strchr(opts.arg, ':');
                        if (!e)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--well-known-key= expects colon separated name and key pairs.");
 
                        _cleanup_free_ char *name = strndup(opts.arg, e - opts.arg);
                        if (!name)
                                return log_oom();
 
                        ImdsWellKnown wk = imds_well_known_from_string(name);
                        if (wk < 0)
                                return log_error_errno(wk, "Failed to parse --well-known-key= argument: %m");
 
                        e++;
                        if (!imds_key_is_valid(e))
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Well known key '%s' is not valid.", e);
 
                        r = free_and_strdup_warn(arg_well_known_key + wk, e);
                        if (r < 0)
                                return r;
                        break;
                }
 
                OPTION_COMMON_INTROSPECT_CLI:
                        return introspect_cli(SD_JSON_FORMAT_OFF);
                }
 
        if (arg_vendor || arg_token_url || arg_refresh_header_name || arg_data_url || arg_data_url_suffix || arg_token_header_name || arg_extra_header)
                arg_endpoint_source = ENDPOINT_USER;
 
        r = sd_varlink_invocation(SD_VARLINK_ALLOW_ACCEPT);
        if (r < 0)
                return log_error_errno(r, "Failed to check if invoked in Varlink mode: %m");
 
        arg_varlink = r;
 
        if (!arg_varlink) {
                char **args = option_parser_get_args(&opts);
                size_t n_args = option_parser_get_n_args(&opts);
 
                if (arg_setup_network) {
                        if (n_args != 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "No argument expected.");
                } else {
                        if (arg_well_known < 0) {
                                /* if no --well-known= parameter was specified we require an argument */
                                if (n_args != 1)
                                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "A single argument expected.");
                        } else if (n_args > 1) /* if not, then the additional parameter is optional */
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "At most a single argument expected.");
 
                        if (n_args > 0) {
                                if (!imds_key_is_valid(args[0]))
                                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Specified IMDS key is not valid, refusing: %s", args[0]);
 
                                r = free_and_strdup_warn(&arg_key, args[0]);
                                if (r < 0)
                                        return r;
                        }
                }
        }
 
        return 1;
}
 
static int device_get_property_ip_address(
                sd_device *d,
                const char *name,
                int family,
                union in_addr_union *ret) {
 
        int r;
 
        /* Parses an IP address stored in the udev database for a device */
 
        assert(d);
        assert(name);
        assert(IN_SET(family, AF_INET, AF_INET6));
 
        const char *v = NULL;
        r = sd_device_get_property_value(d, name, &v);
        if (r < 0)
                return r;
 
        return in_addr_from_string(family, v, ret);
}
 
static const char * const imds_well_known_udev_table[_IMDS_WELL_KNOWN_MAX] = {
        [IMDS_HOSTNAME]        = "IMDS_KEY_HOSTNAME",
        [IMDS_REGION]          = "IMDS_KEY_REGION",
        [IMDS_ZONE]            = "IMDS_KEY_ZONE",
        [IMDS_IPV4_PUBLIC]     = "IMDS_KEY_IPV4_PUBLIC",
        [IMDS_IPV6_PUBLIC]     = "IMDS_KEY_IPV6_PUBLIC",
        [IMDS_SSH_KEY]         = "IMDS_KEY_SSH_KEY",
        [IMDS_USERDATA]        = "IMDS_KEY_USERDATA",
        [IMDS_USERDATA_BASE]   = "IMDS_KEY_USERDATA_BASE",
        [IMDS_USERDATA_BASE64] = "IMDS_KEY_USERDATA_BASE64",
};
 
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(imds_well_known_udev, ImdsWellKnown);
 
static int smbios_server_info(void) {
        int r;
 
        /* Acquires IMDS server information from udev/hwdb */
 
        if (arg_endpoint_source >= 0)
                return 0;
 
        _cleanup_(sd_device_unrefp) sd_device *d = NULL;
        r = sd_device_new_from_syspath(&d, "/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");
 
        const char *vendor;
        r = sd_device_get_property_value(d, "IMDS_VENDOR", &vendor);
        if (r == -ENOENT) {
                log_debug_errno(r, "IMDS_VENDOR= property not set on DMI device, skipping.");
                return 0;
        }
        if (r < 0)
                return log_error_errno(r, "Failed to read IMDS_VENDOR= property of DMI device: %m");
 
        log_debug("Detected IMDS vendor support '%s'.", vendor);
 
        r = free_and_strdup_warn(&arg_vendor, vendor);
        if (r < 0)
                return r;
 
        struct {
                const char *property;
                char **variable;
        } table[] = {
                { "IMDS_TOKEN_URL",           &arg_token_url           },
                { "IMDS_REFRESH_HEADER_NAME", &arg_refresh_header_name },
                { "IMDS_DATA_URL",            &arg_data_url            },
                { "IMDS_DATA_URL_SUFFIX",     &arg_data_url_suffix     },
                { "IMDS_TOKEN_HEADER_NAME",   &arg_token_header_name   },
        };
 
        FOREACH_ELEMENT(i, table) {
                const char *v = NULL;
 
                r = sd_device_get_property_value(d, i->property, &v);
                if (r < 0 && r != -ENOENT)
                        return log_error_errno(r, "Failed to read property '%s' of DMI: %m", i->property);
 
                r = free_and_strdup_warn(i->variable, v);
                if (r < 0)
                        return r;
        }
 
        for (size_t i = 0; i < 64U; i++) {
                _cleanup_free_ char *property = NULL;
                const char *p = NULL;
                if (i > 0) {
                        if (asprintf(&property, "IMDS_EXTRA_HEADER%zu", i + 1) < 0)
                                return log_oom();
                        p = property;
                } else
                        p = "IMDS_EXTRA_HEADER";
 
                const char *v = NULL;
                r = sd_device_get_property_value(d, p, &v);
                if (r < 0 && r != -ENOENT)
                        return log_error_errno(r, "Failed to read property '%s' of DMI: %m", p);
 
                if (v)
                        if (strv_extend(&arg_extra_header, v) < 0)
                                return log_oom();
        }
 
        union in_addr_union u;
        r = device_get_property_ip_address(d, "IMDS_ADDRESS_IPV4", AF_INET, &u);
        if (r < 0 && r != -ENOENT)
                return log_error_errno(r, "Failed to read property 'IMDS_ADDRESS_IPV4' of DMI: %m");
        else if (r >= 0)
                arg_address_ipv4 = u.in;
 
        r = device_get_property_ip_address(d, "IMDS_ADDRESS_IPV6", AF_INET6, &u);
        if (r < 0 && r != -ENOENT)
                return log_error_errno(r, "Failed to read property 'IMDS_ADDRESS_IPV6' of DMI: %m");
        else if (r >= 0)
                arg_address_ipv6 = u.in6;
 
        for (ImdsWellKnown k = 0; k < _IMDS_WELL_KNOWN_MAX; k++) {
                const char *p = imds_well_known_udev_to_string(k);
                if (!p)
                        continue;
 
                const char *v = NULL;
                r = sd_device_get_property_value(d, p, &v);
                if (r < 0 && r != -ENOENT)
                        return log_error_errno(r, "Failed to read property '%s' of DMI: %m", p);
 
                r = free_and_strdup_warn(arg_well_known_key + k, v);
                if (r < 0)
                        return r;
        }
 
        log_debug("IMDS endpoint data set from SMBIOS device.");
        arg_endpoint_source = ENDPOINT_UDEV;
        return 0;
}
 
static int secure_getenv_ip_address(
                const char *name,
                int family,
                union in_addr_union *ret) {
 
        assert(name);
        assert(IN_SET(family, AF_INET, AF_INET6));
 
        /* Parses an IP address specified in an environment variable */
 
        const char *e = secure_getenv(name);
        if (!e)
                return -ENXIO;
 
        return in_addr_from_string(family, e, ret);
}
 
static const char * const imds_well_known_environment_table[_IMDS_WELL_KNOWN_MAX] = {
        [IMDS_HOSTNAME]        = "SYSTEMD_IMDS_KEY_HOSTNAME",
        [IMDS_REGION]          = "SYSTEMD_IMDS_KEY_REGION",
        [IMDS_ZONE]            = "SYSTEMD_IMDS_KEY_ZONE",
        [IMDS_IPV4_PUBLIC]     = "SYSTEMD_IMDS_KEY_IPV4_PUBLIC",
        [IMDS_IPV6_PUBLIC]     = "SYSTEMD_IMDS_KEY_IPV6_PUBLIC",
        [IMDS_SSH_KEY]         = "SYSTEMD_IMDS_KEY_SSH_KEY",
        [IMDS_USERDATA]        = "SYSTEMD_IMDS_KEY_USERDATA",
        [IMDS_USERDATA_BASE]   = "SYSTEMD_IMDS_KEY_USERDATA_BASE",
        [IMDS_USERDATA_BASE64] = "SYSTEMD_IMDS_KEY_USERDATA_BASE64",
};
 
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(imds_well_known_environment, ImdsWellKnown);
 
static int environment_server_info(void) {
        int r;
 
        /* Acquires IMDS endpoint info from environment variables */
 
        if (arg_endpoint_source >= 0)
                return 0;
 
        static const struct {
                const char *name;
                char **variable;
        } table[] = {
                { "SYSTEMD_IMDS_VENDOR",              &arg_vendor              },
                { "SYSTEMD_IMDS_TOKEN_URL",           &arg_token_url           },
                { "SYSTEMD_IMDS_REFRESH_HEADER_NAME", &arg_refresh_header_name },
                { "SYSTEMD_IMDS_DATA_URL",            &arg_data_url            },
                { "SYSTEMD_IMDS_DATA_URL_SUFFIX",     &arg_data_url_suffix     },
                { "SYSTEMD_IMDS_TOKEN_HEADER_NAME",   &arg_token_header_name   },
        };
 
        FOREACH_ELEMENT(i, table) {
                const char *e = secure_getenv(i->name);
                if (!e)
                        continue;
 
                r = free_and_strdup_warn(i->variable, e);
                if (r < 0)
                        return r;
 
                arg_endpoint_source = ENDPOINT_ENVIRONMENT;
        }
 
        for (unsigned u = 1; u < 64; u++) {
                _cleanup_free_ char *name = NULL;
 
                if (u > 1 && asprintf(&name, "SYSTEMD_IMDS_EXTRA_HEADER%u", u) < 0)
                        return log_oom();
 
                const char *e = secure_getenv(name ?: "SYSTEMD_IMDS_EXTRA_HEADER");
                if (!e)
                        break;
 
                if (strv_extend(&arg_extra_header, e) < 0)
                        return log_oom();
 
                arg_endpoint_source = ENDPOINT_ENVIRONMENT;
        }
 
        union in_addr_union u;
        r = secure_getenv_ip_address("SYSTEMD_IMDS_ADDRESS_IPV4", AF_INET, &u);
        if (r < 0 && r != -ENXIO)
                return log_error_errno(r, "Failed read IPv4 address from environment variable 'SYSTEMD_IMDS_ADDRESS_IPV4': %m");
        if (r >= 0) {
                arg_address_ipv4 = u.in;
                arg_endpoint_source = ENDPOINT_ENVIRONMENT;
        }
 
        r = secure_getenv_ip_address("SYSTEMD_IMDS_ADDRESS_IPV6", AF_INET6, &u);
        if (r < 0 && r != -ENXIO)
                return log_error_errno(r, "Failed read IPv6 address from environment variable 'SYSTEMD_IMDS_ADDRESS_IPV6': %m");
        if (r >= 0) {
                arg_address_ipv6 = u.in6;
                arg_endpoint_source = ENDPOINT_ENVIRONMENT;
        }
 
        for (ImdsWellKnown k = 0; k < _IMDS_WELL_KNOWN_MAX; k++) {
                const char *n = imds_well_known_environment_to_string(k);
                if (!n)
                        continue;
 
                const char *e = secure_getenv(n);
                if (!e)
                        continue;
 
                r = free_and_strdup_warn(arg_well_known_key + k, e);
                if (r < 0)
                        return r;
 
                arg_endpoint_source = ENDPOINT_ENVIRONMENT;
        }
 
        if (arg_endpoint_source >= 0)
                log_debug("IMDS endpoint data set from environment.");
 
        return 0;
}
 
static int read_credential_ip_address(
                const char *name,
                int family,
                union in_addr_union *ret) {
 
        int r;
 
        assert(name);
        assert(IN_SET(family, AF_INET, AF_INET6));
 
        /* Parses an IP address specified in a credential */
 
        _cleanup_free_ char *s = NULL;
        r = read_credential(name, (void**) &s, /* ret_size= */ NULL);
        if (r < 0)
                return r;
 
        return in_addr_from_string(family, s, ret);
}
 
static const char * const imds_well_known_credential_table[_IMDS_WELL_KNOWN_MAX] = {
        [IMDS_HOSTNAME]        = "imds.key_hostname",
        [IMDS_REGION]          = "imds.key_region",
        [IMDS_ZONE]            = "imds.key_zone",
        [IMDS_IPV4_PUBLIC]     = "imds.key_ipv4_public",
        [IMDS_IPV6_PUBLIC]     = "imds.key_ipv6_public",
        [IMDS_SSH_KEY]         = "imds.key_ssh_key",
        [IMDS_USERDATA]        = "imds.key_userdata",
        [IMDS_USERDATA_BASE]   = "imds.key_userdata_base",
        [IMDS_USERDATA_BASE64] = "imds.key_userdata_base64",
};
 
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(imds_well_known_credential, ImdsWellKnown);
 
static int credential_server_info(void) {
        int r;
 
        /* Acquires IMDS endpoint info from credentials */
 
        if (arg_endpoint_source >= 0)
                return 0;
 
        static const struct {
                const char *name;
                char **variable;
        } table[] = {
                { "imds.vendor",              &arg_vendor              },
                { "imds.vendor_token",        &arg_token_url           },
                { "imds.refresh_header_name", &arg_refresh_header_name },
                { "imds.data_url",            &arg_data_url            },
                { "imds.data_url_suffix",     &arg_data_url_suffix     },
                { "imds.token_header_name",   &arg_token_header_name   },
        };
 
        FOREACH_ELEMENT(i, table) {
                _cleanup_free_ char *s = NULL;
 
                r = read_credential(i->name, (void**) &s, /* ret_size= */ NULL);
                if (IN_SET(r, -ENOENT, -ENXIO))
                        continue;
                if (r < 0) {
                        log_warning_errno(r, "Failed to read credential '%s', ignoring: %m", i->name);
                        continue;
                }
 
                r = free_and_strdup_warn(i->variable, s);
                if (r < 0)
                        return r;
 
                arg_endpoint_source = ENDPOINT_CREDENTIALS;
        }
 
        for (unsigned u = 1; u < 64; u++) {
                _cleanup_free_ char *name = NULL;
                if (u > 1 && asprintf(&name, "imds.extra_header%u", u) < 0)
                        return log_oom();
 
                const char *n = name ?: "imds.extra_header";
 
                _cleanup_free_ char *s = NULL;
                r = read_credential(n, (void**) &s, /* ret_size= */ NULL);
                if (IN_SET(r, -ENOENT, -ENXIO))
                        continue;
                if (r < 0) {
                        log_warning_errno(r, "Failed to read credential '%s', ignoring: %m", n);
                        continue;
                }
 
                if (strv_extend(&arg_extra_header, s) < 0)
                        return log_oom();
 
                arg_endpoint_source = ENDPOINT_CREDENTIALS;
        }
 
        union in_addr_union u;
        r = read_credential_ip_address("imds.address_ipv4", AF_INET, &u);
        if (r < 0 && !IN_SET(r, -ENOENT, -ENXIO))
                log_warning_errno(r, "Failed read IPv4 address from credential 'imds.address_ipv4', ignoring: %m");
        if (r >= 0) {
                arg_address_ipv4 = u.in;
                arg_endpoint_source = ENDPOINT_CREDENTIALS;
        }
 
        r = read_credential_ip_address("imds.address_ipv6", AF_INET6, &u);
        if (r < 0 && !IN_SET(r, -ENOENT, -ENXIO))
                log_warning_errno(r, "Failed read IPv6 address from credential 'imds.address_ipv6', ignoring: %m");
        if (r >= 0) {
                arg_address_ipv6 = u.in6;
                arg_endpoint_source = ENDPOINT_CREDENTIALS;
        }
 
        for (ImdsWellKnown k = 0; k < _IMDS_WELL_KNOWN_MAX; k++) {
                const char *n = imds_well_known_credential_to_string(k);
                if (!n)
                        continue;
 
                _cleanup_free_ char *s = NULL;
                r = read_credential(n, (void**) &s, /* ret_size= */ NULL);
                if (IN_SET(r, -ENOENT, -ENXIO))
                        continue;
                if (r < 0) {
                        log_warning_errno(r, "Failed to read credential '%s', ignoring: %m", n);
                        continue;
                }
 
                free_and_replace(arg_well_known_key[k], s);
                arg_endpoint_source = ENDPOINT_CREDENTIALS;
        }
 
        if (arg_endpoint_source >= 0)
                log_debug("IMDS endpoint data set from credentials.");
 
        return 0;
}
 
static int parse_proc_cmdline_item(const char *key, const char *value, void *data) {
        int r;
 
        assert(key);
 
        /* Called for each kernel command line option. */
 
        if (proc_cmdline_key_streq(key, "systemd.imds.network")) {
                if (proc_cmdline_value_missing(key, value))
                        return 0;
 
                ImdsNetworkMode m = imds_network_mode_from_string(value);
                if (m < 0)
                        return log_warning_errno(m, "Failed to parse systemd.imds.network= value: %m");
 
                arg_network_mode = m;
                return 0;
        }
 
        /* The other kernel command line options configured IMDS endpoint data. We'll only check it if no
         * other configuration source for it has been used */
        if (arg_endpoint_source >= 0 && arg_endpoint_source != ENDPOINT_PROC_CMDLINE)
                return 0;
 
        static const struct {
                const char *key;
                char **variable;
        } table[] = {
                { "systemd.imds.vendor",              &arg_vendor              },
                { "systemd.imds.token_url",           &arg_token_url           },
                { "systemd.imds.refresh_header_name", &arg_refresh_header_name },
                { "systemd.imds.data_url",            &arg_data_url            },
                { "systemd.imds.data_url_suffix",     &arg_data_url_suffix     },
                { "systemd.imds.token_header_name",   &arg_token_header_name   },
        };
 
        FOREACH_ELEMENT(i, table) {
                if (!proc_cmdline_key_streq(key, i->key))
                        continue;
 
                if (proc_cmdline_value_missing(key, value))
                        return 0;
 
                r = free_and_strdup_warn(i->variable, value);
                if (r < 0)
                        return r;
 
                arg_endpoint_source = ENDPOINT_PROC_CMDLINE;
                return 0;
        }
 
        if (proc_cmdline_key_streq(key, "systemd.imds.extra_header")) {
                if (proc_cmdline_value_missing(key, value))
                        return 0;
 
                if (isempty(value))
                        arg_extra_header = strv_free(arg_extra_header);
                else if (strv_extend(&arg_extra_header, value) < 0)
                        return log_oom();
 
                arg_endpoint_source = ENDPOINT_PROC_CMDLINE;
                return 0;
        }