Debian Codegraph @

src/basic/hostname-util.c

raw
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))
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))
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) && (*p != '?' || !FLAGS_SET(flags, VALID_HOSTNAME_QUESTION_MARK)))
86 return false;
87
88 dot = false;
89 hyphen = false;
90 }
91
92 if (dot && (n_dots < 2 || !FLAGS_SET(flags, VALID_HOSTNAME_TRAILING_DOT)))
93 return false;
94 if (hyphen)
95 return false;
96
97 /* Note that host name max is 64 on Linux, but DNS allows domain names up to 255 characters. */
98 if (p - s > (ssize_t) LINUX_HOST_NAME_MAX)
99 return false;
100
101 return true;
102 }
103
104 char* hostname_cleanup(char *s) {
105 char *p, *d;
106 bool dot, hyphen;
107
108 assert(s);
109
110 for (p = s, d = s, dot = hyphen = true; *p && d - s < (ssize_t) LINUX_HOST_NAME_MAX; p++)
111 if (*p == '.') {
112 if (dot || hyphen)
113 continue;
114
115 *(d++) = '.';
116 dot = true;
117 hyphen = false;
118
119 } else if (*p == '-') {
120 if (dot)
121 continue;
122
123 *(d++) = '-';
124 dot = false;
125 hyphen = true;
126
127 } else if (valid_ldh_char(*p) || *p == '?') {
128 *(d++) = *p;
129 dot = false;
130 hyphen = false;
131 }
132
133 if (d > s && IN_SET(d[-1], '-', '.'))
134 /* The dot can occur at most once, but we might have multiple
135 * hyphens, hence the loop */
136 d--;
137 *d = 0;
138
139 return s;
140 }
141
142 bool is_localhost(const char *hostname) {
143 assert(hostname);
144
145 /* This tries to identify local host and domain names
146 * described in RFC6761 plus the redhatism of localdomain */
147
148 return STRCASE_IN_SET(
149 hostname,
150 "localhost",
151 "localhost.",
152 "localhost.localdomain",
153 "localhost.localdomain.") ||
154 endswith_no_case(hostname, ".localhost") ||
155 endswith_no_case(hostname, ".localhost.") ||
156 endswith_no_case(hostname, ".localhost.localdomain") ||
157 endswith_no_case(hostname, ".localhost.localdomain.");
158 }
159
160 const char* etc_hostname(void) {
161 static const char *cached = NULL;
162
163 if (!cached)
164 cached = secure_getenv("SYSTEMD_ETC_HOSTNAME") ?: "/etc/hostname";
165
166 return cached;
167 }
168
169 const char* etc_machine_info(void) {
170 static const char *cached = NULL;
171
172 if (!cached)
173 cached = secure_getenv("SYSTEMD_ETC_MACHINE_INFO") ?: "/etc/machine-info";
174
175 return cached;
176 }
177
178 int get_pretty_hostname(char **ret) {
179 _cleanup_free_ char *n = NULL;
180 int r;
181
182 assert(ret);
183
184 r = parse_env_file(NULL, etc_machine_info(), "PRETTY_HOSTNAME", &n);
185 if (r < 0)
186 return r;
187
188 if (isempty(n))
189 return -ENXIO;
190
191 *ret = TAKE_PTR(n);
192 return 0;
193 }
194
195 int split_user_at_host(const char *s, char **ret_user, char **ret_host) {
196 _cleanup_free_ char *u = NULL, *h = NULL;
197
198 /* Splits a user@host expression (one of those we accept on --machine= and similar). Returns NULL in
199 * each of the two return parameters if that part was left empty. */
200
201 assert(s);
202
203 const char *rhs = strchr(s, '@');
204 if (rhs) {
205 if (ret_user && rhs > s) {
206 u = strndup(s, rhs - s);
207 if (!u)
208 return -ENOMEM;
209 }
210
211 if (ret_host && rhs[1] != 0) {
212 h = strdup(rhs + 1);
213 if (!h)
214 return -ENOMEM;
215 }
216
217 } else {
218 if (isempty(s))
219 return -EINVAL;
220
221 if (ret_host) {
222 h = strdup(s);
223 if (!h)
224 return -ENOMEM;
225 }
226 }
227
228 if (ret_user)
229 *ret_user = TAKE_PTR(u);
230 if (ret_host)
231 *ret_host = TAKE_PTR(h);
232
233 return !!rhs; /* return > 0 if '@' was specified, 0 otherwise */
234 }
235
236 int machine_spec_valid(const char *s) {
237 _cleanup_free_ char *u = NULL, *h = NULL;
238 int r;
239
240 assert(s);
241
242 r = split_user_at_host(s, &u, &h);
243 if (r == -EINVAL)
244 return false;
245 if (r < 0)
246 return r;
247
248 if (u && !valid_user_group_name(u, VALID_USER_RELAX | VALID_USER_ALLOW_NUMERIC))
249 return false;
250
251 if (h && !hostname_is_valid(h, VALID_HOSTNAME_DOT_HOST))
252 return false;
253
254 return true;
255 }
256
257 bool machine_tag_is_valid(const char *s) {
258 size_t n = strlen_ptr(s);
259 if (n <= 0 || n >= 256)
260 return false;
261
262 /* Don't allow "-" and "." as first or last char. (This is load-bearing, we want that "+"/"-" can be
263 * used as prefix for adding/removing tags from the list). */
264 if (strchr("-.", s[0]) ||
265 strchr("-.", s[n-1]))
266 return false;
267
268 return in_charset(s, ALPHANUMERICAL "-.");
269 }
270
271 bool machine_tag_list_is_valid(char **l) {
272 size_t n = 0;
273 STRV_FOREACH(i, l) {
274 n++;
275 if (n > MACHINE_TAGS_MAX)
276 return false;
277
278 if (!machine_tag_is_valid(*i))
279 return false;
280 }
281
282 return true;
283 }
284
285 int machine_tags_from_string(const char *s, bool graceful, char ***ret) {
286 int r;
287
288 assert(ret);
289
290 /* Parses the colon-separated TAGS= machine-info field into a sorted, deduplicated strv. Each tag is
291 * validated: if 'graceful' is true invalid tags are silently dropped, otherwise an invalid tag makes
292 * us fail with -EINVAL. The result is NULL if no (valid) tags remain. */
293
294 if (isempty(s)) {
295 *ret = NULL;
296 return 0;
297 }
298
299 _cleanup_strv_free_ char **l = strv_split(s, ":");
300 if (!l)
301 return -ENOMEM;
302
303 strv_sort_uniq(l);
304
305 if (!graceful) {
306 if (!machine_tag_list_is_valid(l))
307 return -EINVAL;
308
309 *ret = strv_isempty(l) ? NULL : TAKE_PTR(l);
310 return 0;
311 }
312
313 size_t n = 0;
314 _cleanup_strv_free_ char **cleaned = NULL;
315 STRV_FOREACH(i, l) {
316 if (!machine_tag_is_valid(*i))
317 continue;
318
319 n++;
320 if (n > MACHINE_TAGS_MAX)
321 return -E2BIG;
322
323 r = strv_extend(&cleaned, *i);
324 if (r < 0)
325 return r;
326 }
327
328 *ret = TAKE_PTR(cleaned);
329 return 0;
330 }