HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/imds/imdsd.c
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;
}