[thirdparty/systemd.git] / src / basic / hostname-util.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <stdlib.h>

#include "alloc-util.h"
#include "env-file.h"
#include "hostname-util.h"
#include "log.h"
#include "os-util.h"
#include "string-util.h"
#include "strv.h"
#include "user-util.h"

char* get_default_hostname_raw(void) {
        int r;

        /* Returns the default hostname, and leaves any ??? in place. */

        const char *e = secure_getenv("SYSTEMD_DEFAULT_HOSTNAME");
        if (e) {
                if (hostname_is_valid(e, VALID_HOSTNAME_QUESTION_MARK|VALID_HOSTNAME_WORD_TOKEN))
                        return strdup(e);

                log_debug("Invalid hostname in $SYSTEMD_DEFAULT_HOSTNAME, ignoring: %s", e);
        }

        _cleanup_free_ char *f = NULL;
        r = parse_os_release(NULL, "DEFAULT_HOSTNAME", &f);
        if (r < 0)
                log_debug_errno(r, "Failed to parse os-release, ignoring: %m");
        else if (f) {
                if (hostname_is_valid(f, VALID_HOSTNAME_QUESTION_MARK|VALID_HOSTNAME_WORD_TOKEN))
                        return TAKE_PTR(f);

                log_debug("Invalid hostname in os-release, ignoring: %s", f);
        }

        return strdup(FALLBACK_HOSTNAME);
}

bool valid_ldh_char(char c) {
        /* "LDH" → "Letters, digits, hyphens", as per RFC 5890, Section 2.3.1 */

        return ascii_isalpha(c) ||
                ascii_isdigit(c) ||
                c == '-';
}

bool hostname_is_valid(const char *s, ValidHostnameFlags flags) {
        unsigned n_dots = 0;
        const char *p;
        bool dot, hyphen;

        /* Check if s looks like a valid hostname or FQDN. This does not do full DNS validation, but only
         * checks if the name is composed of allowed characters and the length is not above the maximum
         * allowed by Linux (c.f. dns_name_is_valid()). A trailing dot is allowed if
         * VALID_HOSTNAME_TRAILING_DOT flag is set and at least two components are present in the name. Note
         * that due to the restricted charset and length this call is substantially more conservative than
         * dns_name_is_valid(). Doesn't accept empty hostnames, hostnames with leading dots, and hostnames
         * with multiple dots in a sequence. Doesn't allow hyphens at the beginning or end of label. */

        if (isempty(s))
                return false;

        if (streq(s, ".host")) /* Used by the container logic to denote the "root container" */
                return FLAGS_SET(flags, VALID_HOSTNAME_DOT_HOST);

        for (p = s, dot = hyphen = true; *p; p++)
                if (*p == '.') {
                        if (dot || hyphen)
                                return false;

                        dot = true;
                        hyphen = false;
                        n_dots++;

                } else if (*p == '-') {
                        if (dot)
                                return false;

                        dot = false;
                        hyphen = true;

                } else {
                        if (!valid_ldh_char(*p) &&
                            (*p != '?' || !FLAGS_SET(flags, VALID_HOSTNAME_QUESTION_MARK)) &&
                            (*p != '$' || !FLAGS_SET(flags, VALID_HOSTNAME_WORD_TOKEN)))
                                return false;

                        dot = false;
                        hyphen = false;
                }

        if (dot && (n_dots < 2 || !FLAGS_SET(flags, VALID_HOSTNAME_TRAILING_DOT)))
                return false;
        if (hyphen)
                return false;

        /* Note that host name max is 64 on Linux, but DNS allows domain names up to 255 characters. */
        if (p - s > (ssize_t) LINUX_HOST_NAME_MAX)
                return false;

        return true;
}

char* hostname_cleanup(char *s) {
        char *p, *d;
        bool dot, hyphen;

        assert(s);

        for (p = s, d = s, dot = hyphen = true; *p && d - s < (ssize_t) LINUX_HOST_NAME_MAX; p++)
                if (*p == '.') {
                        if (dot || hyphen)
                                continue;

                        *(d++) = '.';
                        dot = true;
                        hyphen = false;

                } else if (*p == '-') {
                        if (dot)
                                continue;

                        *(d++) = '-';
                        dot = false;
                        hyphen = true;

                } else if (valid_ldh_char(*p) || IN_SET(*p, '?', '$')) {
                        *(d++) = *p;
                        dot = false;
                        hyphen = false;
                }

        if (d > s && IN_SET(d[-1], '-', '.'))
                /* The dot can occur at most once, but we might have multiple
                 * hyphens, hence the loop */
                d--;
        *d = 0;

        return s;
}

bool is_localhost(const char *hostname) {
        assert(hostname);

        /* This tries to identify local host and domain names
         * described in RFC6761 plus the redhatism of localdomain */

        return STRCASE_IN_SET(
                        hostname,
                        "localhost",
                        "localhost.",
                        "localhost.localdomain",
                        "localhost.localdomain.") ||
                endswith_no_case(hostname, ".localhost") ||
                endswith_no_case(hostname, ".localhost.") ||
                endswith_no_case(hostname, ".localhost.localdomain") ||
                endswith_no_case(hostname, ".localhost.localdomain.");
}

const char* etc_hostname(void) {
        static const char *cached = NULL;

        if (!cached)
                cached = secure_getenv("SYSTEMD_ETC_HOSTNAME") ?: "/etc/hostname";

        return cached;
}

const char* etc_machine_info(void) {
        static const char *cached = NULL;

        if (!cached)
                cached = secure_getenv("SYSTEMD_ETC_MACHINE_INFO") ?: "/etc/machine-info";

        return cached;
}

int get_pretty_hostname(char **ret) {
        _cleanup_free_ char *n = NULL;
        int r;

        assert(ret);

        r = parse_env_file(NULL, etc_machine_info(), "PRETTY_HOSTNAME", &n);
        if (r < 0)
                return r;

        if (isempty(n))
                return -ENXIO;

        *ret = TAKE_PTR(n);
        return 0;
}

int split_user_at_host(const char *s, char **ret_user, char **ret_host) {
        _cleanup_free_ char *u = NULL, *h = NULL;

        /* Splits a user@host expression (one of those we accept on --machine= and similar). Returns NULL in
         * each of the two return parameters if that part was left empty. */

        assert(s);

        const char *rhs = strchr(s, '@');
        if (rhs) {
                if (ret_user && rhs > s) {
                        u = strndup(s, rhs - s);
                        if (!u)
                                return -ENOMEM;
                }

                if (ret_host && rhs[1] != 0) {
                        h = strdup(rhs + 1);
                        if (!h)
                                return -ENOMEM;
                }

        } else {
                if (isempty(s))
                        return -EINVAL;

                if (ret_host) {
                        h = strdup(s);
                        if (!h)
                                return -ENOMEM;
                }
        }

        if (ret_user)
                *ret_user = TAKE_PTR(u);
        if (ret_host)
                *ret_host = TAKE_PTR(h);

        return !!rhs; /* return > 0 if '@' was specified, 0 otherwise */
}

int machine_spec_valid(const char *s) {
        _cleanup_free_ char *u = NULL, *h = NULL;
        int r;

        assert(s);

        r = split_user_at_host(s, &u, &h);
        if (r == -EINVAL)
                return false;
        if (r < 0)
                return r;

        if (u && !valid_user_group_name(u, VALID_USER_RELAX | VALID_USER_ALLOW_NUMERIC))
                return false;

        if (h && !hostname_is_valid(h, VALID_HOSTNAME_DOT_HOST))
                return false;

        return true;
}

bool machine_tag_is_valid(const char *s) {
        size_t n = strlen_ptr(s);
        if (n <= 0 || n >= 256)
                return false;

        /* Don't allow "-" and "." as first char. (This is load-bearing, we want that "+"/"-" can be used as
         * prefix for adding/removing tags from the list). */
        if (strchr("-.=", s[0]))
                return false;

        /* We allow parameterization of tags, with a "=" as separator */
        const char *eq = strchr(s, '=');
        if (eq) {
                assert(eq > s);

                /* If there is an '=', then make the same restrictions as for the first char on the last char before it */
                if (strchr("-.", eq[-1]))
                        return false;
        } else {
                /* If there's no '=', then make the restriction on the very last character */
                if (strchr("-.", s[n-1]))
                        return false;
        }

        return in_charset(s, ALPHANUMERICAL "-.=");
}

bool machine_tag_list_is_valid(char **l) {
        size_t n = 0;
        STRV_FOREACH(i, l) {
                n++;
                if (n > MACHINE_TAGS_MAX)
                        return false;

                if (!machine_tag_is_valid(*i))
                        return false;

                const char *eq = strchr(*i, '=');
                if (!eq)
                        continue;

                /* Refuse tags with a common part before the '=', that do no also carry the same value. */
                size_t np = eq - *i + 1;
                STRV_FOREACH(j, l) {
                        if (j == i)
                                break;

                        if (streq(*i, *j)) /* Fully identical is OK */
                                continue;

                        if (strneq(*i, *j, np)) /* Not identical, but same key: refuse */
                                return false;
                }
        }

        return true;
}

int machine_tags_from_string(const char *s, bool graceful, char ***ret) {
        int r;

        assert(ret);

        /* Parses the colon-separated TAGS= machine-info field into a sorted, deduplicated strv. Each tag is
         * validated: if 'graceful' is true invalid tags are silently dropped, otherwise an invalid tag makes
         * us fail with -EINVAL. The result is NULL if no (valid) tags remain. */

        if (isempty(s)) {
                *ret = NULL;
                return 0;
        }

        _cleanup_strv_free_ char **l = strv_split(s, ":");
        if (!l)
                return -ENOMEM;

        strv_sort_uniq(l);

        if (!graceful) {
                if (!machine_tag_list_is_valid(l))
                        return -EINVAL;

                *ret = strv_isempty(l) ? NULL : TAKE_PTR(l);
                return 0;
        }

        size_t n = 0;
        _cleanup_strv_free_ char **cleaned = NULL;
        STRV_FOREACH(i, l) {
                if (!machine_tag_is_valid(*i))
                        continue;

                n++;
                if (n > MACHINE_TAGS_MAX)
                        return -E2BIG;

                const char *eq = strchr(*i, '=');
                if (eq) {
                        /* Suppress duplicate assignments */
                        bool skip = false;
                        size_t np = eq - *i + 1;
                        STRV_FOREACH(j, cleaned)
                                if (strneq(*i, *j, np)) {
                                        skip = true;
                                        break;
                                }

                        if (skip)
                                continue;
                }

                r = strv_extend(&cleaned, *i);
                if (r < 0)
                        return r;
        }

        *ret = TAKE_PTR(cleaned);
        return 0;
}
Commit	Line	Data
	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
	2
	3	#include <stdlib.h>
	4
	5	#include "alloc-util.h"
	6	#include "env-file.h"
	7	#include "hostname-util.h"
	8	#include "log.h"
	9	#include "os-util.h"
	10	#include "string-util.h"
	11	#include "strv.h"
	12	#include "user-util.h"
	13
	14	char* get_default_hostname_raw(void) {
	15	int r;
	16
	17	/* Returns the default hostname, and leaves any ??? in place. */
	18
	19	const char *e = secure_getenv("SYSTEMD_DEFAULT_HOSTNAME");
	20	if (e) {
	21	if (hostname_is_valid(e, VALID_HOSTNAME_QUESTION_MARK\|VALID_HOSTNAME_WORD_TOKEN))
	22	return strdup(e);
	23
	24	log_debug("Invalid hostname in $SYSTEMD_DEFAULT_HOSTNAME, ignoring: %s", e);
	25	}
	26
	27	_cleanup_free_ char *f = NULL;
	28	r = parse_os_release(NULL, "DEFAULT_HOSTNAME", &f);
	29	if (r < 0)
	30	log_debug_errno(r, "Failed to parse os-release, ignoring: %m");
	31	else if (f) {
	32	if (hostname_is_valid(f, VALID_HOSTNAME_QUESTION_MARK\|VALID_HOSTNAME_WORD_TOKEN))
	33	return TAKE_PTR(f);
	34
	35	log_debug("Invalid hostname in os-release, ignoring: %s", f);
	36	}
	37
	38	return strdup(FALLBACK_HOSTNAME);
	39	}
	40
	41	bool valid_ldh_char(char c) {
	42	/* "LDH" → "Letters, digits, hyphens", as per RFC 5890, Section 2.3.1 */
	43
	44	return ascii_isalpha(c) \|\|
	45	ascii_isdigit(c) \|\|
	46	c == '-';
	47	}
	48
	49	bool hostname_is_valid(const char *s, ValidHostnameFlags flags) {
	50	unsigned n_dots = 0;
	51	const char *p;
	52	bool dot, hyphen;
	53
	54	/* Check if s looks like a valid hostname or FQDN. This does not do full DNS validation, but only
	55	* checks if the name is composed of allowed characters and the length is not above the maximum
	56	* allowed by Linux (c.f. dns_name_is_valid()). A trailing dot is allowed if
	57	* VALID_HOSTNAME_TRAILING_DOT flag is set and at least two components are present in the name. Note
	58	* that due to the restricted charset and length this call is substantially more conservative than
	59	* dns_name_is_valid(). Doesn't accept empty hostnames, hostnames with leading dots, and hostnames
	60	* with multiple dots in a sequence. Doesn't allow hyphens at the beginning or end of label. */
	61
	62	if (isempty(s))
	63	return false;
	64
	65	if (streq(s, ".host")) /* Used by the container logic to denote the "root container" */
	66	return FLAGS_SET(flags, VALID_HOSTNAME_DOT_HOST);
	67
	68	for (p = s, dot = hyphen = true; *p; p++)
	69	if (*p == '.') {
	70	if (dot \|\| hyphen)
	71	return false;
	72
	73	dot = true;
	74	hyphen = false;
	75	n_dots++;
	76
	77	} else if (*p == '-') {
	78	if (dot)
	79	return false;
	80
	81	dot = false;
	82	hyphen = true;
	83
	84	} else {
	85	if (!valid_ldh_char(*p) &&
	86	(*p != '?' \|\| !FLAGS_SET(flags, VALID_HOSTNAME_QUESTION_MARK)) &&
	87	(*p != '$' \|\| !FLAGS_SET(flags, VALID_HOSTNAME_WORD_TOKEN)))
	88	return false;
	89
	90	dot = false;
	91	hyphen = false;
	92	}
	93
	94	if (dot && (n_dots < 2 \|\| !FLAGS_SET(flags, VALID_HOSTNAME_TRAILING_DOT)))
	95	return false;
	96	if (hyphen)
	97	return false;
	98
	99	/* Note that host name max is 64 on Linux, but DNS allows domain names up to 255 characters. */
	100	if (p - s > (ssize_t) LINUX_HOST_NAME_MAX)
	101	return false;
	102
	103	return true;
	104	}
	105
	106	char* hostname_cleanup(char *s) {
	107	char p, d;
	108	bool dot, hyphen;
	109
	110	assert(s);
	111
	112	for (p = s, d = s, dot = hyphen = true; *p && d - s < (ssize_t) LINUX_HOST_NAME_MAX; p++)
	113	if (*p == '.') {
	114	if (dot \|\| hyphen)
	115	continue;
	116
	117	*(d++) = '.';
	118	dot = true;
	119	hyphen = false;
	120
	121	} else if (*p == '-') {
	122	if (dot)
	123	continue;
	124
	125	*(d++) = '-';
	126	dot = false;
	127	hyphen = true;
	128
	129	} else if (valid_ldh_char(p) \|\| IN_SET(p, '?', '$')) {
	130	(d++) = p;
	131	dot = false;
	132	hyphen = false;
	133	}
	134
	135	if (d > s && IN_SET(d[-1], '-', '.'))
	136	/* The dot can occur at most once, but we might have multiple
	137	* hyphens, hence the loop */
	138	d--;
	139	*d = 0;
	140
	141	return s;
	142	}
	143
	144	bool is_localhost(const char *hostname) {
	145	assert(hostname);
	146
	147	/* This tries to identify local host and domain names
	148	* described in RFC6761 plus the redhatism of localdomain */
	149
	150	return STRCASE_IN_SET(
	151	hostname,
	152	"localhost",
	153	"localhost.",
	154	"localhost.localdomain",
	155	"localhost.localdomain.") \|\|
	156	endswith_no_case(hostname, ".localhost") \|\|
	157	endswith_no_case(hostname, ".localhost.") \|\|
	158	endswith_no_case(hostname, ".localhost.localdomain") \|\|
	159	endswith_no_case(hostname, ".localhost.localdomain.");
	160	}
	161
	162	const char* etc_hostname(void) {
	163	static const char *cached = NULL;
	164
	165	if (!cached)
	166	cached = secure_getenv("SYSTEMD_ETC_HOSTNAME") ?: "/etc/hostname";
	167
	168	return cached;
	169	}
	170
	171	const char* etc_machine_info(void) {
	172	static const char *cached = NULL;
	173
	174	if (!cached)
	175	cached = secure_getenv("SYSTEMD_ETC_MACHINE_INFO") ?: "/etc/machine-info";
	176
	177	return cached;
	178	}
	179
	180	int get_pretty_hostname(char **ret) {
	181	_cleanup_free_ char *n = NULL;
	182	int r;
	183
	184	assert(ret);
	185
	186	r = parse_env_file(NULL, etc_machine_info(), "PRETTY_HOSTNAME", &n);
	187	if (r < 0)
	188	return r;
	189
	190	if (isempty(n))
	191	return -ENXIO;
	192
	193	*ret = TAKE_PTR(n);
	194	return 0;
	195	}
	196
	197	int split_user_at_host(const char s, char ret_user, char *ret_host) {
	198	_cleanup_free_ char u = NULL, h = NULL;
	199
	200	/* Splits a user@host expression (one of those we accept on --machine= and similar). Returns NULL in
	201	* each of the two return parameters if that part was left empty. */
	202
	203	assert(s);
	204
	205	const char *rhs = strchr(s, '@');
	206	if (rhs) {
	207	if (ret_user && rhs > s) {
	208	u = strndup(s, rhs - s);
	209	if (!u)
	210	return -ENOMEM;
	211	}
	212
	213	if (ret_host && rhs[1] != 0) {
	214	h = strdup(rhs + 1);
	215	if (!h)
	216	return -ENOMEM;
	217	}
	218
	219	} else {
	220	if (isempty(s))
	221	return -EINVAL;
	222
	223	if (ret_host) {
	224	h = strdup(s);
	225	if (!h)
	226	return -ENOMEM;
	227	}
	228	}
	229
	230	if (ret_user)
	231	*ret_user = TAKE_PTR(u);
	232	if (ret_host)
	233	*ret_host = TAKE_PTR(h);
	234
	235	return !!rhs; /* return > 0 if '@' was specified, 0 otherwise */
	236	}
	237
	238	int machine_spec_valid(const char *s) {
	239	_cleanup_free_ char u = NULL, h = NULL;
	240	int r;
	241
	242	assert(s);
	243
	244	r = split_user_at_host(s, &u, &h);
	245	if (r == -EINVAL)
	246	return false;
	247	if (r < 0)
	248	return r;
	249
	250	if (u && !valid_user_group_name(u, VALID_USER_RELAX \| VALID_USER_ALLOW_NUMERIC))
	251	return false;
	252
	253	if (h && !hostname_is_valid(h, VALID_HOSTNAME_DOT_HOST))
	254	return false;
	255
	256	return true;
	257	}
	258
	259	bool machine_tag_is_valid(const char *s) {
	260	size_t n = strlen_ptr(s);
	261	if (n <= 0 \|\| n >= 256)
	262	return false;
	263
	264	/* Don't allow "-" and "." as first char. (This is load-bearing, we want that "+"/"-" can be used as
	265	* prefix for adding/removing tags from the list). */
	266	if (strchr("-.=", s[0]))
	267	return false;
	268
	269	/* We allow parameterization of tags, with a "=" as separator */
	270	const char *eq = strchr(s, '=');
	271	if (eq) {
	272	assert(eq > s);
	273
	274	/* If there is an '=', then make the same restrictions as for the first char on the last char before it */
	275	if (strchr("-.", eq[-1]))
	276	return false;
	277	} else {
	278	/* If there's no '=', then make the restriction on the very last character */
	279	if (strchr("-.", s[n-1]))
	280	return false;
	281	}
	282
	283	return in_charset(s, ALPHANUMERICAL "-.=");
	284	}
	285
	286	bool machine_tag_list_is_valid(char **l) {
	287	size_t n = 0;
	288	STRV_FOREACH(i, l) {
	289	n++;
	290	if (n > MACHINE_TAGS_MAX)
	291	return false;
	292
	293	if (!machine_tag_is_valid(*i))
	294	return false;
	295
	296	const char eq = strchr(i, '=');
	297	if (!eq)
	298	continue;
	299
	300	/* Refuse tags with a common part before the '=', that do no also carry the same value. */
	301	size_t np = eq - *i + 1;
	302	STRV_FOREACH(j, l) {
	303	if (j == i)
	304	break;
	305
	306	if (streq(i, j)) /* Fully identical is OK */
	307	continue;
	308
	309	if (strneq(i, j, np)) /* Not identical, but same key: refuse */
	310	return false;
	311	}
	312	}
	313
	314	return true;
	315	}
	316
	317	int machine_tags_from_string(const char s, bool graceful, char **ret) {
	318	int r;
	319
	320	assert(ret);
	321
	322	/* Parses the colon-separated TAGS= machine-info field into a sorted, deduplicated strv. Each tag is
	323	* validated: if 'graceful' is true invalid tags are silently dropped, otherwise an invalid tag makes
	324	* us fail with -EINVAL. The result is NULL if no (valid) tags remain. */
	325
	326	if (isempty(s)) {
	327	*ret = NULL;
	328	return 0;
	329	}
	330
	331	_cleanup_strv_free_ char **l = strv_split(s, ":");
	332	if (!l)
	333	return -ENOMEM;
	334
	335	strv_sort_uniq(l);
	336
	337	if (!graceful) {
	338	if (!machine_tag_list_is_valid(l))
	339	return -EINVAL;
	340
	341	*ret = strv_isempty(l) ? NULL : TAKE_PTR(l);
	342	return 0;
	343	}
	344
	345	size_t n = 0;
	346	_cleanup_strv_free_ char **cleaned = NULL;
	347	STRV_FOREACH(i, l) {
	348	if (!machine_tag_is_valid(*i))
	349	continue;
	350
	351	n++;
	352	if (n > MACHINE_TAGS_MAX)
	353	return -E2BIG;
	354
	355	const char eq = strchr(i, '=');
	356	if (eq) {
	357	/* Suppress duplicate assignments */
	358	bool skip = false;
	359	size_t np = eq - *i + 1;
	360	STRV_FOREACH(j, cleaned)
	361	if (strneq(i, j, np)) {
	362	skip = true;
	363	break;
	364	}
	365
	366	if (skip)
	367	continue;
	368	}
	369
	370	r = strv_extend(&cleaned, *i);
	371	if (r < 0)
	372	return r;
	373	}
	374
	375	*ret = TAKE_PTR(cleaned);
	376	return 0;
	377	}