Debian Codegraph @

src/shared/specifier.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <sys/utsname.h>
4 #include <unistd.h>
5
6 #include "sd-id128.h"
7
8 #include "alloc-util.h"
9 #include "architecture.h"
10 #include "chase.h"
11 #include "format-util.h"
12 #include "fs-util.h"
13 #include "hostname-setup.h"
14 #include "hostname-util.h"
15 #include "id128-util.h"
16 #include "os-util.h"
17 #include "path-util.h"
18 #include "runtime-scope.h"
19 #include "specifier.h"
20 #include "string-util.h"
21 #include "strv.h"
22 #include "user-util.h"
23
24 /*
25 * Generic infrastructure for replacing %x style specifiers in
26 * strings. Will call a callback for each replacement.
27 */
28
29 /* Any ASCII character or digit: our pool of potential specifiers,
30 * and "%" used for escaping. */
31 #define POSSIBLE_SPECIFIERS ALPHANUMERICAL "%"
32
33 int specifier_printf(const char *text, size_t max_length, const Specifier table[], const char *root, const void *userdata, char **ret) {
34 _cleanup_free_ char *result = NULL;
35 bool percent = false;
36 size_t l;
37 char *t;
38 int r;
39
40 assert(ret);
41 assert(text);
42 assert(table);
43
44 l = strlen(text);
45 if (!GREEDY_REALLOC(result, l + 1))
46 return -ENOMEM;
47 t = result;
48
49 for (const char *f = text; *f != '\0'; f++, l--) {
50 if (percent) {
51 percent = false;
52
53 if (*f == '%')
54 *(t++) = '%';
55 else {
56 const Specifier *i;
57
58 for (i = table; i->specifier; i++)
59 if (i->specifier == *f)
60 break;
61
62 if (i->lookup) {
63 _cleanup_free_ char *w = NULL;
64 size_t k, j;
65
66 r = i->lookup(i->specifier, i->data, root, userdata, &w);
67 if (r < 0)
68 return r;
69 if (isempty(w))
70 continue;
71
72 j = t - result;
73 k = strlen(w);
74
75 if (!GREEDY_REALLOC(result, j + k + l + 1))
76 return -ENOMEM;
77 t = mempcpy(result + j, w, k);
78 } else if (strchr(POSSIBLE_SPECIFIERS, *f))
79 /* Oops, an unknown specifier. */
80 return -EBADSLT;
81 else {
82 *(t++) = '%';
83 *(t++) = *f;
84 }
85 }
86 } else if (*f == '%')
87 percent = true;
88 else
89 *(t++) = *f;
90
91 if ((size_t) (t - result) > max_length)
92 return -ENAMETOOLONG;
93 }
94
95 /* If string ended with a stray %, also end with % */
96 if (percent) {
97 *(t++) = '%';
98 if ((size_t) (t - result) > max_length)
99 return -ENAMETOOLONG;
100 }
101 *(t++) = 0;
102
103 *ret = TAKE_PTR(result);
104 return 0;
105 }
106
107 /* Generic handler for simple string replacements */
108
109 int specifier_string(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
110 return strdup_to(ASSERT_PTR(ret), empty_to_null(data));
111 }
112
113 int specifier_real_path(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
114 const char *path = data;
115
116 assert(ret);
117
118 if (!path)
119 return -ENOENT;
120
121 return chase(path, root, 0, ret, NULL);
122 }
123
124 int specifier_real_directory(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
125 _cleanup_free_ char *path = NULL;
126 int r;
127
128 assert(ret);
129
130 r = specifier_real_path(specifier, data, root, userdata, &path);
131 if (r < 0)
132 return r;
133
134 assert(path);
135 return path_extract_directory(path, ret);
136 }
137
138 int specifier_id128(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
139 const sd_id128_t *id = ASSERT_PTR(data);
140 char *n;
141
142 assert(ret);
143
144 n = new(char, SD_ID128_STRING_MAX);
145 if (!n)
146 return -ENOMEM;
147
148 *ret = sd_id128_to_string(*id, n);
149 return 0;
150 }
151
152 int specifier_uuid(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
153 const sd_id128_t *id = ASSERT_PTR(data);
154 char *n;
155
156 assert(ret);
157
158 n = new(char, SD_ID128_UUID_STRING_MAX);
159 if (!n)
160 return -ENOMEM;
161
162 *ret = sd_id128_to_uuid_string(*id, n);
163 return 0;
164 }
165
166 int specifier_uint64(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
167 const uint64_t *n = ASSERT_PTR(data);
168
169 return asprintf(ret, "%" PRIu64, *n) < 0 ? -ENOMEM : 0;
170 }
171
172 int specifier_machine_id(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
173 sd_id128_t id;
174 int r;
175
176 assert(ret);
177
178 r = id128_get_machine(root, &id);
179 if (r < 0) /* Translate error for missing /etc/machine-id file to EUNATCH. */
180 return r == -ENOENT ? -EUNATCH : r;
181
182 return specifier_id128(specifier, &id, root, userdata, ret);
183 }
184
185 int specifier_boot_id(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
186 sd_id128_t id;
187 int r;
188
189 assert(ret);
190
191 r = sd_id128_get_boot(&id);
192 if (r < 0)
193 return r;
194
195 return specifier_id128(specifier, &id, root, userdata, ret);
196 }
197
198 int specifier_hostname(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
199 char *n;
200
201 assert(ret);
202
203 n = gethostname_malloc();
204 if (!n)
205 return -ENOMEM;
206
207 *ret = n;
208 return 0;
209 }
210
211 int specifier_short_hostname(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
212 char *n;
213
214 assert(ret);
215
216 n = gethostname_short_malloc();
217 if (!n)
218 return -ENOMEM;
219
220 *ret = n;
221 return 0;
222 }
223
224 int specifier_pretty_hostname(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
225 char *n = NULL;
226
227 assert(ret);
228
229 if (get_pretty_hostname(&n) < 0) {
230 n = gethostname_short_malloc();
231 if (!n)
232 return -ENOMEM;
233 }
234
235 *ret = n;
236 return 0;
237 }
238
239 int specifier_kernel_release(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
240 struct utsname uts;
241
242 assert(ret);
243
244 if (uname(&uts) < 0)
245 return -errno;
246
247 return strdup_to(ret, uts.release);
248 }
249
250 int specifier_architecture(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
251 return strdup_to(ASSERT_PTR(ret),
252 architecture_to_string(uname_architecture()));
253 }
254
255 /* Note: fields in /etc/os-release might quite possibly be missing, even if everything is entirely valid
256 * otherwise. We'll return an empty value or NULL in that case from the functions below. But if the
257 * os-release file is missing, we'll return -EUNATCH. This means that something is seriously wrong with the
258 * installation. */
259
260 static int parse_os_release_specifier(const char *root, const char *id, char **ret) {
261 _cleanup_free_ char *v = NULL;
262 int r;
263
264 assert(ret);
265
266 r = parse_os_release(root, id, &v);
267 if (r >= 0)
268 /* parse_os_release() calls parse_env_file() which only sets the return value for
269 * entries found. Let's make sure we set the return value in all cases. */
270 *ret = TAKE_PTR(v);
271
272 /* Translate error for missing os-release file to EUNATCH. */
273 return r == -ENOENT ? -EUNATCH : r;
274 }
275
276 int specifier_os_id(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
277 return parse_os_release_specifier(root, "ID", ret);
278 }
279
280 int specifier_os_version_id(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
281 return parse_os_release_specifier(root, "VERSION_ID", ret);
282 }
283
284 int specifier_os_build_id(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
285 return parse_os_release_specifier(root, "BUILD_ID", ret);
286 }
287
288 int specifier_os_variant_id(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
289 return parse_os_release_specifier(root, "VARIANT_ID", ret);
290 }
291
292 int specifier_os_image_id(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
293 return parse_os_release_specifier(root, "IMAGE_ID", ret);
294 }
295
296 int specifier_os_image_version(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
297 return parse_os_release_specifier(root, "IMAGE_VERSION", ret);
298 }
299
300 int specifier_group_name(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
301 RuntimeScope scope = PTR_TO_INT(data);
302 char *t;
303
304 assert(ret);
305
306 if (scope == RUNTIME_SCOPE_GLOBAL)
307 return -EINVAL;
308
309 t = gid_to_name(scope == RUNTIME_SCOPE_USER ? getgid() : 0);
310 if (!t)
311 return -ENOMEM;
312
313 *ret = t;
314 return 0;
315 }
316
317 int specifier_group_id(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
318 RuntimeScope scope = PTR_TO_INT(data);
319 gid_t gid;
320
321 assert(ret);
322
323 if (scope == RUNTIME_SCOPE_GLOBAL)
324 return -EINVAL;
325
326 gid = scope == RUNTIME_SCOPE_USER ? getgid() : 0;
327
328 if (asprintf(ret, UID_FMT, gid) < 0)
329 return -ENOMEM;
330
331 return 0;
332 }
333
334 int specifier_user_name(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
335 RuntimeScope scope = PTR_TO_INT(data);
336 uid_t uid;
337 char *t;
338
339 assert(ret);
340
341 if (scope == RUNTIME_SCOPE_GLOBAL)
342 return -EINVAL;
343
344 uid = scope == RUNTIME_SCOPE_USER ? getuid() : 0;
345
346 /* If we are UID 0 (root), this will not result in NSS, otherwise it might. This is good, as we want
347 * to be able to run this in PID 1, where our user ID is 0, but where NSS lookups are not allowed.
348
349 * We don't use getusername_malloc() here, because we don't want to look at $USER, to remain
350 * consistent with specifier_user_id() below.
351 */
352
353 t = uid_to_name(uid);
354 if (!t)
355 return -ENOMEM;
356
357 *ret = t;
358 return 0;
359 }
360
361 int specifier_user_id(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
362 RuntimeScope scope = PTR_TO_INT(data);
363 uid_t uid;
364
365 assert(ret);
366
367 if (scope == RUNTIME_SCOPE_GLOBAL)
368 return -EINVAL;
369
370 uid = scope == RUNTIME_SCOPE_USER ? getuid() : 0;
371
372 if (asprintf(ret, UID_FMT, uid) < 0)
373 return -ENOMEM;
374
375 return 0;
376 }
377
378 int specifier_user_home(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
379 assert(ret);
380
381 /* On PID 1 (which runs as root) this will not result in NSS,
382 * which is good. See above */
383
384 return get_home_dir(ret);
385 }
386
387 int specifier_user_shell(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
388 assert(ret);
389
390 /* On PID 1 (which runs as root) this will not result in NSS,
391 * which is good. See above */
392
393 return get_shell(ret);
394 }
395
396 int specifier_tmp_dir(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
397 const char *p;
398 int r;
399
400 assert(ret);
401
402 if (root) /* If root dir is set, don't honour $TMP or similar */
403 p = "/tmp";
404 else {
405 r = tmp_dir(&p);
406 if (r < 0)
407 return r;
408 }
409
410 return strdup_to(ret, p);
411 }
412
413 int specifier_var_tmp_dir(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
414 const char *p;
415 int r;
416
417 assert(ret);
418
419 if (root)
420 p = "/var/tmp";
421 else {
422 r = var_tmp_dir(&p);
423 if (r < 0)
424 return r;
425 }
426
427 return strdup_to(ret, p);
428 }
429
430 char* specifier_escape(const char *string) {
431 return strreplace(string, "%", "%%");
432 }
433
434 int specifier_escape_strv(char **l, char ***ret) {
435 _cleanup_strv_free_ char **z = NULL;
436 char **p, **q;
437
438 assert(ret);
439
440 if (strv_isempty(l)) {
441 *ret = NULL;
442 return 0;
443 }
444
445 z = new(char*, strv_length(l)+1);
446 if (!z)
447 return -ENOMEM;
448
449 for (p = l, q = z; *p; p++, q++) {
450
451 *q = specifier_escape(*p);
452 if (!*q)
453 return -ENOMEM;
454 }
455
456 *q = NULL;
457 *ret = TAKE_PTR(z);
458
459 return 0;
460 }
461
462 const Specifier system_and_tmp_specifier_table[] = {
463 COMMON_SYSTEM_SPECIFIERS,
464 COMMON_TMP_SPECIFIERS,
465 {}
466 };