]> git.ipfire.org Git - thirdparty/systemd.git/blame_incremental - src/hostname/hostnamed.c
projects / thirdparty / systemd.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
zsh: remove _files prefixes
[thirdparty/systemd.git] / src / hostname / hostnamed.c
... / ...
CommitLineData
1/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3#include <sys/stat.h>
4#include <sys/utsname.h>
5#include <unistd.h>
6
7#include "sd-bus.h"
8#include "sd-device.h"
9#include "sd-event.h"
10#include "sd-json.h"
11
12#include "alloc-util.h"
13#include "bitfield.h"
14#include "bus-common-errors.h"
15#include "bus-get-properties.h"
16#include "bus-log-control-api.h"
17#include "bus-object.h"
18#include "bus-polkit.h"
19#include "bus-util.h"
20#include "constants.h"
21#include "daemon-util.h"
22#include "device-private.h"
23#include "env-file.h"
24#include "env-util.h"
25#include "extract-word.h"
26#include "fileio.h"
27#include "hashmap.h"
28#include "hostname-setup.h"
29#include "hostname-util.h"
30#include "id128-util.h"
31#include "json-util.h"
32#include "label-util.h"
33#include "log.h"
34#include "main-func.h"
35#include "nulstr-util.h"
36#include "os-util.h"
37#include "parse-util.h"
38#include "path-util.h"
39#include "service-util.h"
40#include "socket-util.h"
41#include "stat-util.h"
42#include "string-util.h"
43#include "strv.h"
44#include "time-util.h"
45#include "utf8.h"
46#include "varlink-io.systemd.Hostname.h"
47#include "varlink-io.systemd.service.h"
48#include "varlink-util.h"
49#include "virt.h"
50
51#define VALID_DEPLOYMENT_CHARS (DIGITS LETTERS "-.:")
52
53/* Properties we cache are indexed by an enum, to make invalidation easy and systematic (as we can iterate
54 * through them all, and they are uniformly strings). */
55typedef enum {
56 /* Read from /etc/hostname */
57 PROP_STATIC_HOSTNAME,
58 PROP_STATIC_HOSTNAME_SUBSTITUTED_WILDCARDS,
59
60 /* Read from /etc/machine-info */
61 PROP_PRETTY_HOSTNAME,
62 PROP_ICON_NAME,
63 PROP_CHASSIS,
64 PROP_DEPLOYMENT,
65 PROP_LOCATION,
66 PROP_HARDWARE_VENDOR,
67 PROP_HARDWARE_MODEL,
68 PROP_HARDWARE_SKU,
69 PROP_HARDWARE_VERSION,
70
71 /* Read from /etc/os-release (or /usr/lib/os-release) */
72 PROP_OS_PRETTY_NAME,
73 PROP_OS_CPE_NAME,
74 PROP_OS_HOME_URL,
75 PROP_OS_SUPPORT_END,
76 PROP_OS_IMAGE_ID,
77 PROP_OS_IMAGE_VERSION,
78 _PROP_MAX,
79 _PROP_INVALID = -EINVAL,
80} HostProperty;
81
82typedef struct Context {
83 char *data[_PROP_MAX];
84
85 HostnameSource hostname_source;
86
87 struct stat etc_hostname_stat;
88 struct stat etc_os_release_stat;
89 struct stat etc_machine_info_stat;
90
91 sd_event *event;
92 sd_bus *bus;
93 sd_varlink_server *varlink_server;
94 Hashmap *polkit_registry;
95 sd_device *device_dmi;
96 sd_device *device_acpi;
97 sd_device *device_tree;
98} Context;
99
100static void context_reset(Context *c, uint64_t mask) {
101 assert(c);
102
103 for (HostProperty p = 0; p < _PROP_MAX; p++) {
104 if (!BIT_SET(mask, p))
105 continue;
106
107 c->data[p] = mfree(c->data[p]);
108 }
109}
110
111static void context_destroy(Context *c) {
112 assert(c);
113
114 context_reset(c, UINT64_MAX);
115 hashmap_free(c->polkit_registry);
116 sd_event_unref(c->event);
117 sd_bus_flush_close_unref(c->bus);
118 sd_varlink_server_unref(c->varlink_server);
119 sd_device_unref(c->device_dmi);
120 sd_device_unref(c->device_acpi);
121 sd_device_unref(c->device_tree);
122}
123
124static void context_read_etc_hostname(Context *c) {
125 struct stat current_stat = {};
126 int r;
127
128 assert(c);
129
130 if (stat(etc_hostname(), &current_stat) >= 0 &&
131 stat_inode_unmodified(&c->etc_hostname_stat, &current_stat))
132 return;
133
134 context_reset(c,
135 (UINT64_C(1) << PROP_STATIC_HOSTNAME) |
136 (UINT64_C(1) << PROP_STATIC_HOSTNAME_SUBSTITUTED_WILDCARDS));
137
138 r = read_etc_hostname(/* path= */ NULL, /* substitute_wildcards= */ false, &c->data[PROP_STATIC_HOSTNAME]);
139 if (r < 0) {
140 if (r != -ENOENT)
141 log_warning_errno(r, "Failed to read /etc/hostname, ignoring: %m");
142 } else {
143 _cleanup_free_ char *substituted = strdup(c->data[PROP_STATIC_HOSTNAME]);
144 if (!substituted)
145 return (void) log_oom();
146
147 r = hostname_substitute_wildcards(substituted);
148 if (r < 0)
149 log_warning_errno(r, "Failed to substitute wildcards in /etc/hostname, ignoring: %m");
150 else
151 c->data[PROP_STATIC_HOSTNAME_SUBSTITUTED_WILDCARDS] = TAKE_PTR(substituted);
152 }
153
154 c->etc_hostname_stat = current_stat;
155}
156
157static void context_read_machine_info(Context *c) {
158 struct stat current_stat = {};
159 int r;
160
161 assert(c);
162
163 if (stat(etc_machine_info(), &current_stat) >= 0 &&
164 stat_inode_unmodified(&c->etc_machine_info_stat, &current_stat))
165 return;
166
167 context_reset(c,
168 (UINT64_C(1) << PROP_PRETTY_HOSTNAME) |
169 (UINT64_C(1) << PROP_ICON_NAME) |
170 (UINT64_C(1) << PROP_CHASSIS) |
171 (UINT64_C(1) << PROP_DEPLOYMENT) |
172 (UINT64_C(1) << PROP_LOCATION) |
173 (UINT64_C(1) << PROP_HARDWARE_VENDOR) |
174 (UINT64_C(1) << PROP_HARDWARE_MODEL) |
175 (UINT64_C(1) << PROP_HARDWARE_SKU) |
176 (UINT64_C(1) << PROP_HARDWARE_VERSION));
177
178 r = parse_env_file(NULL, etc_machine_info(),
179 "PRETTY_HOSTNAME", &c->data[PROP_PRETTY_HOSTNAME],
180 "ICON_NAME", &c->data[PROP_ICON_NAME],
181 "CHASSIS", &c->data[PROP_CHASSIS],
182 "DEPLOYMENT", &c->data[PROP_DEPLOYMENT],
183 "LOCATION", &c->data[PROP_LOCATION],
184 "HARDWARE_VENDOR", &c->data[PROP_HARDWARE_VENDOR],
185 "HARDWARE_MODEL", &c->data[PROP_HARDWARE_MODEL],
186 "HARDWARE_SKU", &c->data[PROP_HARDWARE_SKU],
187 "HARDWARE_VERSION", &c->data[PROP_HARDWARE_VERSION]);
188 if (r < 0 && r != -ENOENT)
189 log_warning_errno(r, "Failed to read /etc/machine-info, ignoring: %m");
190
191 c->etc_machine_info_stat = current_stat;
192}
193
194static void context_read_os_release(Context *c) {
195 _cleanup_free_ char *os_name = NULL, *os_pretty_name = NULL;
196 struct stat current_stat = {};
197 int r;
198
199 assert(c);
200
201 if ((stat("/etc/os-release", &current_stat) >= 0 ||
202 stat("/usr/lib/os-release", &current_stat) >= 0) &&
203 stat_inode_unmodified(&c->etc_os_release_stat, &current_stat))
204 return;
205
206 context_reset(c,
207 (UINT64_C(1) << PROP_OS_PRETTY_NAME) |
208 (UINT64_C(1) << PROP_OS_CPE_NAME) |
209 (UINT64_C(1) << PROP_OS_HOME_URL) |
210 (UINT64_C(1) << PROP_OS_SUPPORT_END) |
211 (UINT64_C(1) << PROP_OS_IMAGE_ID) |
212 (UINT64_C(1) << PROP_OS_IMAGE_VERSION));
213
214 r = parse_os_release(NULL,
215 "PRETTY_NAME", &os_pretty_name,
216 "NAME", &os_name,
217 "CPE_NAME", &c->data[PROP_OS_CPE_NAME],
218 "HOME_URL", &c->data[PROP_OS_HOME_URL],
219 "SUPPORT_END", &c->data[PROP_OS_SUPPORT_END],
220 "IMAGE_ID", &c->data[PROP_OS_IMAGE_ID],
221 "IMAGE_VERSION", &c->data[PROP_OS_IMAGE_VERSION]);
222 if (r < 0 && r != -ENOENT)
223 log_warning_errno(r, "Failed to read os-release file, ignoring: %m");
224
225 if (free_and_strdup(&c->data[PROP_OS_PRETTY_NAME], os_release_pretty_name(os_pretty_name, os_name)) < 0)
226 log_oom();
227
228 c->etc_os_release_stat = current_stat;
229}
230
231static bool use_dmi_data(void) {
232 int r;
233
234 r = getenv_bool("SYSTEMD_HOSTNAME_FORCE_DMI");
235 if (r >= 0) {
236 log_debug("Honouring $SYSTEMD_HOSTNAME_FORCE_DMI override: %s", yes_no(r));
237 return r;
238 }
239 if (r != -ENXIO)
240 log_debug_errno(r, "Failed to parse $SYSTEMD_HOSTNAME_FORCE_DMI, ignoring: %m");
241
242 if (detect_container() > 0) {
243 log_debug("Running in a container, not using DMI hardware data.");
244 return false;
245 }
246
247 return true;
248}
249
250static int context_acquire_dmi_device(Context *c) {
251 int r;
252
253 assert(c);
254 assert(!c->device_dmi);
255
256 if (!use_dmi_data())
257 return 0;
258
259 r = sd_device_new_from_syspath(&c->device_dmi, "/sys/class/dmi/id/");
260 if (ERRNO_IS_NEG_DEVICE_ABSENT(r)) {
261 log_debug_errno(r, "Failed to open /sys/class/dmi/id/ device, ignoring: %m");
262 return 0;
263 }
264 if (r < 0)
265 return log_error_errno(r, "Failed to open /sys/class/dmi/id/ device: %m");
266
267 return 1;
268}
269
270static int context_acquire_acpi_device(Context *c) {
271 int r;
272
273 assert(c);
274 assert(!c->device_acpi);
275
276 r = sd_device_new_from_syspath(&c->device_acpi, "/sys/firmware/acpi/");
277 if (ERRNO_IS_NEG_DEVICE_ABSENT(r)) {
278 log_debug_errno(r, "Failed to open /sys/firmware/acpi/ device, ignoring: %m");
279 return 0;
280 }
281 if (r < 0)
282 return log_error_errno(r, "Failed to open /sys/firmware/acpi/ device: %m");
283
284 return 1;
285}
286
287static int context_acquire_device_tree(Context *c) {
288 int r;
289
290 assert(c);
291 assert(!c->device_tree);
292
293 r = sd_device_new_from_path(&c->device_tree, "/proc/device-tree/");
294 if (ERRNO_IS_NEG_DEVICE_ABSENT(r)) {
295 log_debug_errno(r, "Failed to open /proc/device-tree/ device, ignoring: %m");
296 return 0;
297 }
298 if (r < 0)
299 return log_error_errno(r, "Failed to open /proc/device-tree/ device: %m");
300
301 return 1;
302}
303
304static bool string_is_safe_for_dbus(const char *s) {
305 assert(s);
306
307 /* Do some superficial validation: do not allow CCs and make sure D-Bus won't kick us off the bus
308 * because we send invalid UTF-8 data */
309
310 if (string_has_cc(s, /* ok= */ NULL))
311 return false;
312
313 return utf8_is_valid(s);
314}
315
316static int get_dmi_property(Context *c, const char *key, char **ret) {
317 const char *s;
318 int r;
319
320 assert(c);
321 assert(key);
322 assert(ret);
323
324 if (!c->device_dmi)
325 return -ENODEV;
326
327 r = sd_device_get_property_value(c->device_dmi, key, &s);
328 if (r < 0)
329 return r;
330
331 if (!string_is_safe_for_dbus(s))
332 return -ENXIO;
333
334 return strdup_to(ret, s);
335}
336
337static int get_dmi_properties(Context *c, const char * const * keys, char **ret) {
338 int r = -ENOENT;
339
340 assert(c);
341 assert(ret);
342
343 STRV_FOREACH(k, keys) {
344 r = get_dmi_property(c, *k, ret);
345 if (r >= 0 || !ERRNO_IS_NEG_DEVICE_ABSENT(r))
346 return r;
347 }
348
349 return r;
350}
351
352static int get_chassis_asset_tag(Context *c, char **ret) {
353 return get_dmi_property(c, "ID_CHASSIS_ASSET_TAG", ret);
354}
355
356static int get_hardware_vendor(Context *c, char **ret) {
357 return get_dmi_properties(c, STRV_MAKE_CONST("ID_VENDOR_FROM_DATABASE", "ID_VENDOR"), ret);
358}
359
360static int get_hardware_model(Context *c, char **ret) {
361 return get_dmi_properties(c, STRV_MAKE_CONST("ID_MODEL_FROM_DATABASE", "ID_MODEL"), ret);
362}
363
364static int get_hardware_sku(Context *c, char **ret) {
365 _cleanup_free_ char *model = NULL, *sku = NULL;
366 int r;
367
368 r = get_dmi_property(c, "ID_SKU", &sku);
369 if (r < 0)
370 return r;
371
372 /* Suppress reporting the SKU field, if it's the same string as the
373 * model field, which it appears to be on various systems */
374 r = get_hardware_model(c, &model);
375 if (r < 0) {
376 if (r != -ENOENT)
377 return r;
378 } else if (streq_ptr(sku, model))
379 return -ENOENT;
380
381 *ret = TAKE_PTR(sku);
382 return 0;
383}
384
385static int get_hardware_version(Context *c, char **ret) {
386 _cleanup_free_ char *version = NULL;
387 int r;
388
389 r = get_dmi_property(c, "ID_HARDWARE_VERSION", &version);
390 if (r < 0)
391 return r;
392
393 /* Suppress reporting the version field, if it's the same string as the
394 * model or sku field, which it appears to be on various systems */
395 int (*getter)(Context *c, char **ret);
396 FOREACH_ARGUMENT(getter, get_hardware_model, get_hardware_sku) {
397 _cleanup_free_ char *value = NULL;
398
399 r = getter(c, &value);
400 if (r == -ENOENT)
401 continue;
402 if (r < 0)
403 return r;
404 if (streq_ptr(version, value))
405 return -ENOENT;
406 }
407
408 *ret = TAKE_PTR(version);
409 return 0;
410}
411
412static int get_sysattr(sd_device *device, const char *key, char **ret) {
413 const char *s;
414 int r;
415
416 assert(key);
417 assert(ret);
418
419 if (!device)
420 return -ENODEV;
421
422 r = sd_device_get_sysattr_value(device, key, &s);
423 if (r < 0)
424 return r;
425
426 if (!string_is_safe_for_dbus(s))
427 return -ENXIO;
428
429 return strdup_to(ret, empty_to_null(s));
430}
431
432static int get_dmi_sysattr(Context *c, const char *key, char **ret) {
433 return get_sysattr(ASSERT_PTR(c)->device_dmi, key, ret);
434}
435
436static int get_device_tree_sysattr(Context *c, const char *key, char **ret) {
437 return get_sysattr(ASSERT_PTR(c)->device_tree, key, ret);
438}
439
440static int get_hardware_serial(Context *c, char **ret) {
441 int r;
442
443 assert(c);
444 assert(ret);
445
446 FOREACH_STRING(attr, "product_serial", "board_serial") {
447 r = get_dmi_sysattr(c, attr, ret);
448 if (r >= 0 || !ERRNO_IS_NEG_DEVICE_ABSENT(r))
449 return r;
450 }
451
452 return get_device_tree_sysattr(c, "serial-number", ret);
453}
454
455static int get_firmware_version(Context *c, char **ret) {
456 return get_dmi_sysattr(c, "bios_version", ret);
457}
458
459static int get_firmware_vendor(Context *c, char **ret) {
460 return get_dmi_sysattr(c, "bios_vendor", ret);
461}
462
463static int get_firmware_date(Context *c, usec_t *ret) {
464 _cleanup_free_ char *bios_date = NULL, *month = NULL, *day = NULL, *year = NULL;
465 int r;
466
467 assert(c);
468 assert(ret);
469
470 r = get_dmi_sysattr(c, "bios_date", &bios_date);
471 if (ERRNO_IS_NEG_DEVICE_ABSENT(r)) {
472 *ret = USEC_INFINITY;
473 return 0;
474 }
475 if (r < 0)
476 return r;
477
478 const char *p = bios_date;
479 r = extract_many_words(&p, "/", EXTRACT_DONT_COALESCE_SEPARATORS, &month, &day, &year);
480 if (r < 0)
481 return r;
482 if (r != 3) /* less than three args read? */
483 return -EINVAL;
484 if (!isempty(p)) /* more left in the string? */
485 return -EINVAL;
486
487 unsigned m, d, y;
488 r = safe_atou_full(month, 10 | SAFE_ATO_REFUSE_PLUS_MINUS | SAFE_ATO_REFUSE_LEADING_WHITESPACE, &m);
489 if (r < 0)
490 return r;
491 if (m < 1 || m > 12)
492 return -EINVAL;
493 m -= 1;
494
495 r = safe_atou_full(day, 10 | SAFE_ATO_REFUSE_PLUS_MINUS | SAFE_ATO_REFUSE_LEADING_WHITESPACE, &d);
496 if (r < 0)
497 return r;
498 if (d < 1 || d > 31)
499 return -EINVAL;
500
501 r = safe_atou_full(year, 10 | SAFE_ATO_REFUSE_PLUS_MINUS | SAFE_ATO_REFUSE_LEADING_WHITESPACE, &y);
502 if (r < 0)
503 return r;
504 if (y < 1970 || y > (unsigned) INT_MAX)
505 return -EINVAL;
506 y -= 1900;
507
508 struct tm tm = {
509 .tm_mday = d,
510 .tm_mon = m,
511 .tm_year = y,
512 };
513
514 usec_t v;
515 r = mktime_or_timegm_usec(&tm, /* utc= */ true, &v);
516 if (r < 0)
517 return r;
518 if (tm.tm_mday != (int) d || tm.tm_mon != (int) m || tm.tm_year != (int) y)
519 return -EINVAL; /* date was not normalized? (e.g. "30th of feb") */
520
521 *ret = v;
522 return 0;
523}
524
525static const char* valid_chassis(const char *chassis) {
526 assert(chassis);
527
528 return nulstr_get(
529 "vm\0"
530 "container\0"
531 "desktop\0"
532 "laptop\0"
533 "convertible\0"
534 "server\0"
535 "tablet\0"
536 "handset\0"
537 "watch\0"
538 "embedded\0",
539 chassis);
540}
541
542static bool valid_deployment(const char *deployment) {
543 assert(deployment);
544
545 return in_charset(deployment, VALID_DEPLOYMENT_CHARS);
546}
547
548static const char* fallback_chassis_by_virtualization(void) {
549 Virtualization v = detect_virtualization();
550 if (v < 0) {
551 log_debug_errno(v, "Failed to detect virtualization, ignoring: %m");
552 return NULL;
553 }
554
555 if (VIRTUALIZATION_IS_VM(v))
556 return "vm";
557 if (VIRTUALIZATION_IS_CONTAINER(v))
558 return "container";
559
560 return NULL;
561}
562
563static const char* fallback_chassis_by_dmi(Context *c) {
564 unsigned t;
565 int r;
566
567 assert(c);
568
569 if (!c->device_dmi)
570 return NULL;
571
572 r = device_get_sysattr_unsigned(c->device_dmi, "chassis_type", &t);
573 if (r < 0) {
574 log_debug_errno(r, "Failed to read/parse DMI chassis type, ignoring: %m");
575 return NULL;
576 }
577
578 /* We only list the really obvious cases here. The DMI data is unreliable enough, so let's not do any
579 * additional guesswork on top of that.
580 *
581 * See the SMBIOS Specification 3.5.0 section 7.4.1 for details about the values listed here:
582 *
583 * https://www.dmtf.org/sites/default/files/standards/documents/DSP0134_3.5.0.pdf
584 */
585
586 switch (t) {
587
588 case 0x03: /* Desktop */
589 case 0x04: /* Low Profile Desktop */
590 case 0x06: /* Mini Tower */
591 case 0x07: /* Tower */
592 case 0x0D: /* All in one (i.e. PC built into monitor) */
593 case 0x23: /* Mini PC */
594 case 0x24: /* Stick PC */
595 return "desktop";
596
597 case 0x8: /* Portable */
598 case 0x9: /* Laptop */
599 case 0xA: /* Notebook */
600 case 0xE: /* Sub Notebook */
601 return "laptop";
602
603 case 0xB: /* Hand Held */
604 return "handset";
605
606 case 0x11: /* Main Server Chassis */
607 case 0x1C: /* Blade */
608 case 0x1D: /* Blade Enclosure */
609 return "server";
610
611 case 0x1E: /* Tablet */
612 return "tablet";
613
614 case 0x1F: /* Convertible */
615 case 0x20: /* Detachable */
616 return "convertible";
617
618 case 0x21: /* IoT Gateway */
619 case 0x22: /* Embedded PC */
620 return "embedded";
621
622 default:
623 log_debug("Unhandled DMI chassis type 0x%02x, ignoring.", t);
624 return NULL;
625 }
626}
627
628static const char* fallback_chassis_by_acpi(Context *c) {
629 unsigned t;
630 int r;
631
632 assert(c);
633
634 if (!c->device_acpi)
635 return NULL;
636
637 r = device_get_sysattr_unsigned(c->device_acpi, "pm_profile", &t);
638 if (r < 0) {
639 log_debug_errno(r, "Failed read/parse ACPI PM profile, ignoring: %m");
640 return NULL;
641 }
642
643 /* We only list the really obvious cases here as the ACPI data is not really super reliable.
644 *
645 * See the ACPI 5.0 Spec Section 5.2.9.1 for details:
646 *
647 * http://www.acpi.info/DOWNLOADS/ACPIspec50.pdf
648 */
649
650 switch (t) {
651
652 case 1: /* Desktop */
653 case 3: /* Workstation */
654 case 6: /* Appliance PC */
655 return "desktop";
656
657 case 2: /* Mobile */
658 return "laptop";
659
660 case 4: /* Enterprise Server */
661 case 5: /* SOHO Server */
662 case 7: /* Performance Server */
663 return "server";
664
665 case 8: /* Tablet */
666 return "tablet";
667
668 default:
669 log_debug("Unhandled ACPI PM profile 0x%02x, ignoring.", t);
670 return NULL;
671 }
672}
673
674static const char* fallback_chassis_by_device_tree(Context *c) {
675 const char *type, *chassis;
676 int r;
677
678 assert(c);
679
680 if (!c->device_tree)
681 return NULL;
682
683 r = sd_device_get_sysattr_value(c->device_tree, "chassis-type", &type);
684 if (r < 0) {
685 log_debug_errno(r, "Failed to read device-tree chassis type, ignoring: %m");
686 return NULL;
687 }
688
689 /* Note that the DeviceTree specification uses the very same vocabulary
690 * of chassis types as we do, hence we do not need to translate these types:
691 *
692 * https://github.com/devicetree-org/devicetree-specification/blob/master/source/chapter3-devicenodes.rst */
693
694 chassis = valid_chassis(type);
695 if (!chassis)
696 log_debug("Invalid device-tree chassis type \"%s\", ignoring.", type);
697 return chassis;
698}
699
700static const char* fallback_chassis(Context *c) {
701 assert(c);
702
703 return
704 fallback_chassis_by_virtualization() ?:
705 fallback_chassis_by_dmi(c) ?:
706 fallback_chassis_by_acpi(c) ?:
707 fallback_chassis_by_device_tree(c);
708}
709
710static char* context_get_chassis(Context *c) {
711 const char *fallback;
712 char *dmi;
713
714 assert(c);
715
716 if (!isempty(c->data[PROP_CHASSIS]))
717 return strdup(c->data[PROP_CHASSIS]);
718
719 if (get_dmi_property(c, "ID_CHASSIS", &dmi) >= 0)
720 return dmi;
721
722 fallback = fallback_chassis(c);
723 if (fallback)
724 return strdup(fallback);
725
726 return NULL;
727}
728
729static char* context_fallback_icon_name(Context *c) {
730 _cleanup_free_ char *chassis = NULL;
731
732 assert(c);
733
734 chassis = context_get_chassis(c);
735 if (chassis)
736 return strjoin("computer-", chassis);
737
738 return strdup("computer");
739}
740
741static int context_update_kernel_hostname(
742 Context *c,
743 const char *transient_hostname) {
744
745 _cleanup_free_ char *_hn_free = NULL;
746 const char *hn;
747 HostnameSource hns;
748 int r;
749
750 assert(c);
751
752 /* /etc/hostname has the highest preference ... */
753 if (c->data[PROP_STATIC_HOSTNAME_SUBSTITUTED_WILDCARDS]) {
754 hn = c->data[PROP_STATIC_HOSTNAME_SUBSTITUTED_WILDCARDS];
755 hns = HOSTNAME_STATIC;
756
757 /* ... the transient hostname, (ie: DHCP) comes next ... */
758 } else if (transient_hostname) {
759 hn = transient_hostname;
760 hns = HOSTNAME_TRANSIENT;
761
762 /* ... and the ultimate fallback */
763 } else {
764 hn = _hn_free = get_default_hostname();
765 if (!hn)
766 return log_oom();
767
768 hns = HOSTNAME_DEFAULT;
769 }
770
771 r = sethostname_idempotent(hn);
772 if (r < 0)
773 return log_error_errno(r, "Failed to set hostname: %m");
774
775 if (c->hostname_source != hns) {
776 c->hostname_source = hns;
777 r = 1;
778 }
779
780 if (r == 0)
781 log_debug("Hostname was already set to <%s>.", hn);
782 else {
783 log_info("Hostname set to <%s> (%s)", hn, hostname_source_to_string(hns));
784
785 hostname_update_source_hint(hn, hns);
786 }
787
788 return r; /* 0 if no change, 1 if something was done */
789}
790
791static void unset_statp(struct stat **p) {
792 if (!*p)
793 return;
794
795 **p = (struct stat) {};
796}
797
798static int context_write_data_static_hostname(Context *c) {
799 _cleanup_(unset_statp) struct stat *s = NULL;
800 int r;
801
802 assert(c);
803
804 /* Make sure that if we fail here, we invalidate the cached information, since it was updated
805 * already, even if we can't make it hit the disk. */
806 s = &c->etc_hostname_stat;
807
808 if (isempty(c->data[PROP_STATIC_HOSTNAME])) {
809 if (unlink(etc_hostname()) < 0 && errno != ENOENT)
810 return -errno;
811
812 TAKE_PTR(s);
813 return 0;
814 }
815
816 r = write_string_file(etc_hostname(), c->data[PROP_STATIC_HOSTNAME], WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_ATOMIC|WRITE_STRING_FILE_LABEL);
817 if (r < 0)
818 return r;
819
820 TAKE_PTR(s);
821 return 0;
822}
823
824static int context_write_data_machine_info(Context *c) {
825 _cleanup_(unset_statp) struct stat *s = NULL;
826 static const char * const name[_PROP_MAX] = {
827 [PROP_PRETTY_HOSTNAME] = "PRETTY_HOSTNAME",
828 [PROP_ICON_NAME] = "ICON_NAME",
829 [PROP_CHASSIS] = "CHASSIS",
830 [PROP_DEPLOYMENT] = "DEPLOYMENT",
831 [PROP_LOCATION] = "LOCATION",
832 };
833 _cleanup_strv_free_ char **l = NULL;
834 int r;
835
836 assert(c);
837
838 /* Make sure that if we fail here, we invalidate the cached information, since it was updated
839 * already, even if we can't make it hit the disk. */
840 s = &c->etc_machine_info_stat;
841
842 r = load_env_file(NULL, etc_machine_info(), &l);
843 if (r < 0 && r != -ENOENT)
844 return r;
845
846 for (HostProperty p = PROP_PRETTY_HOSTNAME; p <= PROP_LOCATION; p++) {
847 assert(name[p]);
848
849 r = strv_env_assign(&l, name[p], empty_to_null(c->data[p]));
850 if (r < 0)
851 return r;
852 }
853
854 if (strv_isempty(l)) {
855 if (unlink(etc_machine_info()) < 0 && errno != ENOENT)
856 return -errno;
857
858 TAKE_PTR(s);
859 return 0;
860 }
861
862 r = write_env_file(
863 AT_FDCWD,
864 etc_machine_info(),
865 /* headers= */NULL,
866 l,
867 WRITE_ENV_FILE_LABEL);
868 if (r < 0)
869 return r;
870
871 TAKE_PTR(s);
872 return 0;
873}
874
875static int property_get_hardware_property(
876 sd_bus_message *reply,
877 Context *c,
878 HostProperty prop,
879 int (*getter)(Context *c, char **ret)) {
880
881 _cleanup_free_ char *from_dmi = NULL;
882
883 assert(reply);
884 assert(c);
885 assert(IN_SET(prop, PROP_HARDWARE_VENDOR, PROP_HARDWARE_MODEL,
886 PROP_HARDWARE_SKU, PROP_HARDWARE_VERSION));
887 assert(getter);
888
889 context_read_machine_info(c);
890
891 if (isempty(c->data[prop]))
892 (void) getter(c, &from_dmi);
893
894 return sd_bus_message_append(reply, "s", from_dmi ?: c->data[prop]);
895}
896
897static int property_get_hardware_vendor(
898 sd_bus *bus,
899 const char *path,
900 const char *interface,
901 const char *property,
902 sd_bus_message *reply,
903 void *userdata,
904 sd_bus_error *error) {
905
906 return property_get_hardware_property(reply, userdata, PROP_HARDWARE_VENDOR, get_hardware_vendor);
907}
908
909static int property_get_hardware_model(
910 sd_bus *bus,
911 const char *path,
912 const char *interface,
913 const char *property,
914 sd_bus_message *reply,
915 void *userdata,
916 sd_bus_error *error) {
917
918 return property_get_hardware_property(reply, userdata, PROP_HARDWARE_MODEL, get_hardware_model);
919}
920
921static int property_get_hardware_sku(
922 sd_bus *bus,
923 const char *path,
924 const char *interface,
925 const char *property,
926 sd_bus_message *reply,
927 void *userdata,
928 sd_bus_error *error) {
929
930 return property_get_hardware_property(reply, userdata, PROP_HARDWARE_SKU, get_hardware_sku);
931}
932
933static int property_get_hardware_version(
934 sd_bus *bus,
935 const char *path,
936 const char *interface,
937 const char *property,
938 sd_bus_message *reply,
939 void *userdata,
940 sd_bus_error *error) {
941
942 return property_get_hardware_property(reply, userdata, PROP_HARDWARE_VERSION, get_hardware_version);
943}
944
945static int property_get_firmware_version(
946 sd_bus *bus,
947 const char *path,
948 const char *interface,
949 const char *property,
950 sd_bus_message *reply,
951 void *userdata,
952 sd_bus_error *error) {
953
954 _cleanup_free_ char *firmware_version = NULL;
955 Context *c = ASSERT_PTR(userdata);
956
957 (void) get_firmware_version(c, &firmware_version);
958
959 return sd_bus_message_append(reply, "s", firmware_version);
960}
961
962static int property_get_firmware_vendor(
963 sd_bus *bus,
964 const char *path,
965 const char *interface,
966 const char *property,
967 sd_bus_message *reply,
968 void *userdata,
969 sd_bus_error *error) {
970
971 _cleanup_free_ char *firmware_vendor = NULL;
972 Context *c = ASSERT_PTR(userdata);
973
974 (void) get_firmware_vendor(c, &firmware_vendor);
975
976 return sd_bus_message_append(reply, "s", firmware_vendor);
977}
978
979static int property_get_firmware_date(
980 sd_bus *bus,
981 const char *path,
982 const char *interface,
983 const char *property,
984 sd_bus_message *reply,
985 void *userdata,
986 sd_bus_error *error) {
987
988 usec_t firmware_date = USEC_INFINITY;
989 Context *c = ASSERT_PTR(userdata);
990
991 (void) get_firmware_date(c, &firmware_date);
992
993 return sd_bus_message_append(reply, "t", firmware_date);
994}
995
996static int property_get_chassis_asset_tag(
997 sd_bus *bus,
998 const char *path,
999 const char *interface,
1000 const char *property,
1001 sd_bus_message *reply,
1002 void *userdata,
1003 sd_bus_error *error) {
1004
1005 _cleanup_free_ char *chassis_asset_tag = NULL;
1006 Context *c = ASSERT_PTR(userdata);
1007
1008 (void) get_chassis_asset_tag(c, &chassis_asset_tag);
1009
1010 return sd_bus_message_append(reply, "s", chassis_asset_tag);
1011}
1012
1013static int property_get_hostname(
1014 sd_bus *bus,
1015 const char *path,
1016 const char *interface,
1017 const char *property,
1018 sd_bus_message *reply,
1019 void *userdata,
1020 sd_bus_error *error) {
1021
1022 _cleanup_free_ char *hn = NULL;
1023 int r;
1024
1025 r = gethostname_strict(&hn);
1026 if (r < 0) {
1027 if (r != -ENXIO)
1028 return r;
1029
1030 hn = get_default_hostname();
1031 if (!hn)
1032 return -ENOMEM;
1033 }
1034
1035 return sd_bus_message_append(reply, "s", hn);
1036}
1037
1038static int property_get_static_hostname(
1039 sd_bus *bus,
1040 const char *path,
1041 const char *interface,
1042 const char *property,
1043 sd_bus_message *reply,
1044 void *userdata,
1045 sd_bus_error *error) {
1046
1047 Context *c = ASSERT_PTR(userdata);
1048
1049 context_read_etc_hostname(c);
1050
1051 return sd_bus_message_append(reply, "s", c->data[PROP_STATIC_HOSTNAME_SUBSTITUTED_WILDCARDS]);
1052}
1053
1054static int property_get_default_hostname(
1055 sd_bus *bus,
1056 const char *path,
1057 const char *interface,
1058 const char *property,
1059 sd_bus_message *reply,
1060 void *userdata,
1061 sd_bus_error *error) {
1062
1063 _cleanup_free_ char *hn = NULL;
1064
1065 hn = get_default_hostname();
1066 if (!hn)
1067 return log_oom();
1068
1069 return sd_bus_message_append(reply, "s", hn);
1070}
1071
1072static void context_determine_hostname_source(Context *c) {
1073 _cleanup_free_ char *hostname = NULL;
1074 int r;
1075
1076 assert(c);
1077
1078 if (c->hostname_source >= 0)
1079 return;
1080
1081 (void) gethostname_full(GET_HOSTNAME_ALLOW_LOCALHOST, &hostname);
1082
1083 if (streq_ptr(hostname, c->data[PROP_STATIC_HOSTNAME_SUBSTITUTED_WILDCARDS]))
1084 c->hostname_source = HOSTNAME_STATIC;
1085 else {
1086 _cleanup_free_ char *fallback = NULL;
1087
1088 /* If the hostname was not set by us, try to figure out where it came from. If we set it to
1089 * the default hostname, the file will tell us. We compare the string because it is possible
1090 * that the hostname was set by an older version that had a different fallback, in the initrd
1091 * or before we reexecuted. */
1092
1093 r = read_one_line_file("/run/systemd/default-hostname", &fallback);
1094 if (r < 0 && r != -ENOENT)
1095 log_warning_errno(r, "Failed to read /run/systemd/default-hostname, ignoring: %m");
1096
1097 if (streq_ptr(fallback, hostname))
1098 c->hostname_source = HOSTNAME_DEFAULT;
1099 else
1100 c->hostname_source = HOSTNAME_TRANSIENT;
1101 }
1102}
1103
1104static int property_get_hostname_source(
1105 sd_bus *bus,
1106 const char *path,
1107 const char *interface,
1108 const char *property,
1109 sd_bus_message *reply,
1110 void *userdata,
1111 sd_bus_error *error) {
1112
1113 Context *c = ASSERT_PTR(userdata);
1114
1115 context_read_etc_hostname(c);
1116 context_determine_hostname_source(c);
1117
1118 return sd_bus_message_append(reply, "s", hostname_source_to_string(c->hostname_source));
1119}
1120
1121static int property_get_machine_info_field(
1122 sd_bus *bus,
1123 const char *path,
1124 const char *interface,
1125 const char *property,
1126 sd_bus_message *reply,
1127 void *userdata,
1128 sd_bus_error *error) {
1129
1130 sd_bus_slot *slot;
1131 Context *c;
1132
1133 /* Acquire the context object without this property's userdata offset added. Explanation: we want
1134 * access to two pointers here: a) the main context object we cache all properties in, and b) the
1135 * pointer to the property field inside the context object that we are supposed to update and
1136 * use. The latter (b) we get in the 'userdata' function parameter, and sd-bus calculates that for us
1137 * from the 'userdata' pointer we supplied when the vtable was registered, with the offset we
1138 * specified in the vtable added on top. To get the former (a) we need the 'userdata' pointer from
1139 * the vtable registration directly, without the offset added. Hence we ask sd-bus what the slot
1140 * object is (which encapsulates the vtable registration), and then query the 'userdata' field
1141 * directly off it. */
1142 assert_se(slot = sd_bus_get_current_slot(bus));
1143 assert_se(c = sd_bus_slot_get_userdata(slot));
1144
1145 context_read_machine_info(c);
1146
1147 return sd_bus_message_append(reply, "s", *(char**) userdata);
1148}
1149
1150static int property_get_os_release_field(
1151 sd_bus *bus,
1152 const char *path,
1153 const char *interface,
1154 const char *property,
1155 sd_bus_message *reply,
1156 void *userdata,
1157 sd_bus_error *error) {
1158
1159 sd_bus_slot *slot;
1160 Context *c;
1161
1162 /* As above, acquire the current context without this property's userdata offset added. */
1163 assert_se(slot = sd_bus_get_current_slot(bus));
1164 assert_se(c = sd_bus_slot_get_userdata(slot));
1165
1166 context_read_os_release(c);
1167
1168 return sd_bus_message_append(reply, "s", *(char**) userdata);
1169}
1170
1171static int property_get_os_support_end(
1172 sd_bus *bus,
1173 const char *path,
1174 const char *interface,
1175 const char *property,
1176 sd_bus_message *reply,
1177 void *userdata,
1178 sd_bus_error *error) {
1179
1180 Context *c = userdata;
1181 usec_t eol = USEC_INFINITY;
1182
1183 context_read_os_release(c);
1184
1185 if (c->data[PROP_OS_SUPPORT_END])
1186 (void) os_release_support_ended(c->data[PROP_OS_SUPPORT_END], /* quiet= */ false, &eol);
1187
1188 return sd_bus_message_append(reply, "t", eol);
1189}
1190
1191static int property_get_icon_name(
1192 sd_bus *bus,
1193 const char *path,
1194 const char *interface,
1195 const char *property,
1196 sd_bus_message *reply,
1197 void *userdata,
1198 sd_bus_error *error) {
1199
1200 _cleanup_free_ char *n = NULL;
1201 Context *c = userdata;
1202 const char *name;
1203
1204 context_read_machine_info(c);
1205
1206 if (isempty(c->data[PROP_ICON_NAME]))
1207 name = n = context_fallback_icon_name(c);
1208 else
1209 name = c->data[PROP_ICON_NAME];
1210
1211 if (!name)
1212 return -ENOMEM;
1213
1214 return sd_bus_message_append(reply, "s", name);
1215}
1216
1217static int property_get_chassis(
1218 sd_bus *bus,
1219 const char *path,
1220 const char *interface,
1221 const char *property,
1222 sd_bus_message *reply,
1223 void *userdata,
1224 sd_bus_error *error) {
1225
1226 _cleanup_free_ char *chassis = NULL;
1227 Context *c = userdata;
1228
1229 context_read_machine_info(c);
1230
1231 chassis = context_get_chassis(c);
1232
1233 return sd_bus_message_append(reply, "s", chassis);
1234}
1235
1236static int property_get_uname_field(
1237 sd_bus *bus,
1238 const char *path,
1239 const char *interface,
1240 const char *property,
1241 sd_bus_message *reply,
1242 void *userdata,
1243 sd_bus_error *error) {
1244
1245 struct utsname u;
1246
1247 assert_se(uname(&u) >= 0);
1248
1249 return sd_bus_message_append(reply, "s", (char*) &u + PTR_TO_SIZE(userdata));
1250}
1251
1252static int property_get_machine_id(
1253 sd_bus *bus,
1254 const char *path,
1255 const char *interface,
1256 const char *property,
1257 sd_bus_message *reply,
1258 void *userdata,
1259 sd_bus_error *error) {
1260
1261 sd_id128_t id;
1262 int r;
1263
1264 r = sd_id128_get_machine(&id);
1265 if (r < 0)
1266 return r;
1267
1268 return bus_property_get_id128(bus, path, interface, property, reply, &id, error);
1269}
1270
1271static int property_get_boot_id(
1272 sd_bus *bus,
1273 const char *path,
1274 const char *interface,
1275 const char *property,
1276 sd_bus_message *reply,
1277 void *userdata,
1278 sd_bus_error *error) {
1279
1280 sd_id128_t id;
1281 int r;
1282
1283 r = sd_id128_get_boot(&id);
1284 if (r < 0)
1285 return r;
1286
1287 return bus_property_get_id128(bus, path, interface, property, reply, &id, error);
1288}
1289
1290static int property_get_vsock_cid(
1291 sd_bus *bus,
1292 const char *path,
1293 const char *interface,
1294 const char *property,
1295 sd_bus_message *reply,
1296 void *userdata,
1297 sd_bus_error *error) {
1298
1299 unsigned local_cid = VMADDR_CID_ANY;
1300
1301 (void) vsock_get_local_cid(&local_cid);
1302
1303 return sd_bus_message_append(reply, "u", (uint32_t) local_cid);
1304}
1305
1306static int validate_and_substitute_hostname(const char *name, char **ret_substituted, sd_bus_error *error) {
1307 int r;
1308
1309 assert(ret_substituted);
1310
1311 if (!name) {
1312 *ret_substituted = NULL;
1313 return 0;
1314 }
1315
1316 _cleanup_free_ char *substituted = strdup(name);
1317 if (!substituted)
1318 return log_oom();
1319
1320 r = hostname_substitute_wildcards(substituted);
1321 if (r < 0)
1322 return log_error_errno(r, "Failed to substitute wildcards in hostname: %m");
1323
1324 if (!hostname_is_valid(substituted, 0))
1325 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid hostname '%s'", name);
1326
1327 *ret_substituted = TAKE_PTR(substituted);
1328 return 1;
1329}
1330
1331static int method_set_hostname(sd_bus_message *m, void *userdata, sd_bus_error *error) {
1332 Context *c = ASSERT_PTR(userdata);
1333 const char *name;
1334 int interactive, r;
1335
1336 assert(m);
1337
1338 r = sd_bus_message_read(m, "sb", &name, &interactive);
1339 if (r < 0)
1340 return r;
1341
1342 name = empty_to_null(name);
1343
1344 /* We always go through with the procedure below without comparing to the current hostname, because
1345 * we might want to adjust hostname source information even if the actual hostname is unchanged. */
1346
1347 _cleanup_free_ char *substituted = NULL;
1348 r = validate_and_substitute_hostname(name, &substituted, error);
1349 if (r < 0)
1350 return r;
1351
1352 name = substituted;
1353
1354 r = bus_verify_polkit_async_full(
1355 m,
1356 "org.freedesktop.hostname1.set-hostname",
1357 /* details= */ NULL,
1358 /* good_user= */ UID_INVALID,
1359 interactive ? POLKIT_ALLOW_INTERACTIVE : 0,
1360 &c->polkit_registry,
1361 error);
1362 if (r < 0)
1363 return r;
1364 if (r == 0)
1365 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1366
1367 context_read_etc_hostname(c);
1368
1369 r = context_update_kernel_hostname(c, name);
1370 if (r < 0)
1371 return sd_bus_error_set_errnof(error, r, "Failed to set hostname: %m");
1372 else if (r > 0)
1373 (void) sd_bus_emit_properties_changed(sd_bus_message_get_bus(m),
1374 "/org/freedesktop/hostname1", "org.freedesktop.hostname1",
1375 "Hostname", "HostnameSource", NULL);
1376
1377 return sd_bus_reply_method_return(m, NULL);
1378}
1379
1380static int method_set_static_hostname(sd_bus_message *m, void *userdata, sd_bus_error *error) {
1381 Context *c = ASSERT_PTR(userdata);
1382 const char *name;
1383 int interactive, r;
1384
1385 assert(m);
1386
1387 r = sd_bus_message_read(m, "sb", &name, &interactive);
1388 if (r < 0)
1389 return r;
1390
1391 name = empty_to_null(name);
1392
1393 context_read_etc_hostname(c);
1394
1395 if (streq_ptr(name, c->data[PROP_STATIC_HOSTNAME]))
1396 return sd_bus_reply_method_return(m, NULL);
1397
1398 _cleanup_free_ char *substituted = NULL;
1399 r = validate_and_substitute_hostname(name, &substituted, error);
1400 if (r < 0)
1401 return r;
1402
1403 r = bus_verify_polkit_async_full(
1404 m,
1405 "org.freedesktop.hostname1.set-static-hostname",
1406 /* details= */ NULL,
1407 /* good_user= */ UID_INVALID,
1408 interactive ? POLKIT_ALLOW_INTERACTIVE : 0,
1409 &c->polkit_registry,
1410 error);
1411 if (r < 0)
1412 return r;
1413 if (r == 0)
1414 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1415
1416 r = free_and_strdup_warn(&c->data[PROP_STATIC_HOSTNAME], name);
1417 if (r < 0)
1418 return r;
1419
1420 free_and_replace(c->data[PROP_STATIC_HOSTNAME_SUBSTITUTED_WILDCARDS], substituted);
1421
1422 r = context_write_data_static_hostname(c);
1423 if (r < 0) {
1424 log_error_errno(r, "Failed to write static hostname: %m");
1425 if (ERRNO_IS_PRIVILEGE(r))
1426 return sd_bus_error_set(error, BUS_ERROR_FILE_IS_PROTECTED, "Not allowed to update /etc/hostname.");
1427 if (r == -EROFS)
1428 return sd_bus_error_set(error, BUS_ERROR_READ_ONLY_FILESYSTEM, "/etc/hostname is in a read-only filesystem.");
1429 return sd_bus_error_set_errnof(error, r, "Failed to set static hostname: %m");
1430 }
1431
1432 r = context_update_kernel_hostname(c, /* transient_hostname= */ NULL);
1433 if (r < 0) {
1434 log_error_errno(r, "Failed to set hostname: %m");
1435 return sd_bus_error_set_errnof(error, r, "Failed to set hostname: %m");
1436 }
1437
1438 (void) sd_bus_emit_properties_changed(sd_bus_message_get_bus(m),
1439 "/org/freedesktop/hostname1", "org.freedesktop.hostname1",
1440 "StaticHostname", "Hostname", "HostnameSource", NULL);
1441
1442 return sd_bus_reply_method_return(m, NULL);
1443}
1444
1445static int set_machine_info(Context *c, sd_bus_message *m, int prop, sd_bus_message_handler_t cb, sd_bus_error *error) {
1446 int interactive;
1447 const char *name;
1448 int r;
1449
1450 assert(c);
1451 assert(m);
1452
1453 r = sd_bus_message_read(m, "sb", &name, &interactive);
1454 if (r < 0)
1455 return r;
1456
1457 name = empty_to_null(name);
1458
1459 context_read_machine_info(c);
1460
1461 if (streq_ptr(name, c->data[prop]))
1462 return sd_bus_reply_method_return(m, NULL);
1463
1464 if (!isempty(name)) {
1465 /* The icon name might ultimately be used as file
1466 * name, so better be safe than sorry */
1467
1468 if (prop == PROP_ICON_NAME && !filename_is_valid(name))
1469 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid icon name '%s'", name);
1470 if (prop == PROP_PRETTY_HOSTNAME && string_has_cc(name, NULL))
1471 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid pretty hostname '%s'", name);
1472 if (prop == PROP_CHASSIS && !valid_chassis(name))
1473 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid chassis '%s'", name);
1474 if (prop == PROP_DEPLOYMENT && !valid_deployment(name))
1475 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid deployment '%s'", name);
1476 if (prop == PROP_LOCATION && string_has_cc(name, NULL))
1477 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid location '%s'", name);
1478 }
1479
1480 /* Since the pretty hostname should always be changed at the same time as the static one, use the
1481 * same policy action for both... */
1482
1483 r = bus_verify_polkit_async_full(
1484 m,
1485 prop == PROP_PRETTY_HOSTNAME ? "org.freedesktop.hostname1.set-static-hostname" : "org.freedesktop.hostname1.set-machine-info",
1486 /* details= */ NULL,
1487 /* good_user= */ UID_INVALID,
1488 interactive ? POLKIT_ALLOW_INTERACTIVE : 0,
1489 &c->polkit_registry,
1490 error);
1491 if (r < 0)
1492 return r;
1493 if (r == 0)
1494 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1495
1496 r = free_and_strdup_warn(&c->data[prop], name);
1497 if (r < 0)
1498 return r;
1499
1500 r = context_write_data_machine_info(c);
1501 if (r < 0) {
1502 log_error_errno(r, "Failed to write machine info: %m");
1503 if (ERRNO_IS_PRIVILEGE(r))
1504 return sd_bus_error_set(error, BUS_ERROR_FILE_IS_PROTECTED, "Not allowed to update /etc/machine-info.");
1505 if (r == -EROFS)
1506 return sd_bus_error_set(error, BUS_ERROR_READ_ONLY_FILESYSTEM, "/etc/machine-info is in a read-only filesystem.");
1507 return sd_bus_error_set_errnof(error, r, "Failed to write machine info: %m");
1508 }
1509
1510 log_info("Changed %s to '%s'",
1511 prop == PROP_PRETTY_HOSTNAME ? "pretty hostname" :
1512 prop == PROP_DEPLOYMENT ? "deployment" :
1513 prop == PROP_LOCATION ? "location" :
1514 prop == PROP_CHASSIS ? "chassis" : "icon name", strna(c->data[prop]));
1515
1516 (void) sd_bus_emit_properties_changed(
1517 sd_bus_message_get_bus(m),
1518 "/org/freedesktop/hostname1",
1519 "org.freedesktop.hostname1",
1520 prop == PROP_PRETTY_HOSTNAME ? "PrettyHostname" :
1521 prop == PROP_DEPLOYMENT ? "Deployment" :
1522 prop == PROP_LOCATION ? "Location" :
1523 prop == PROP_CHASSIS ? "Chassis" : "IconName" , NULL);
1524
1525 return sd_bus_reply_method_return(m, NULL);
1526}
1527
1528static int method_set_pretty_hostname(sd_bus_message *m, void *userdata, sd_bus_error *error) {
1529 return set_machine_info(userdata, m, PROP_PRETTY_HOSTNAME, method_set_pretty_hostname, error);
1530}
1531
1532static int method_set_icon_name(sd_bus_message *m, void *userdata, sd_bus_error *error) {
1533 return set_machine_info(userdata, m, PROP_ICON_NAME, method_set_icon_name, error);
1534}
1535
1536static int method_set_chassis(sd_bus_message *m, void *userdata, sd_bus_error *error) {
1537 return set_machine_info(userdata, m, PROP_CHASSIS, method_set_chassis, error);
1538}
1539
1540static int method_set_deployment(sd_bus_message *m, void *userdata, sd_bus_error *error) {
1541 return set_machine_info(userdata, m, PROP_DEPLOYMENT, method_set_deployment, error);
1542}
1543
1544static int method_set_location(sd_bus_message *m, void *userdata, sd_bus_error *error) {
1545 return set_machine_info(userdata, m, PROP_LOCATION, method_set_location, error);
1546}
1547
1548static int method_get_product_uuid(sd_bus_message *m, void *userdata, sd_bus_error *error) {
1549 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1550 Context *c = ASSERT_PTR(userdata);
1551 int interactive, r;
1552 sd_id128_t uuid;
1553
1554 assert(m);
1555
1556 r = sd_bus_message_read(m, "b", &interactive);
1557 if (r < 0)
1558 return r;
1559
1560 r = bus_verify_polkit_async_full(
1561 m,
1562 "org.freedesktop.hostname1.get-product-uuid",
1563 /* details= */ NULL,
1564 /* good_user= */ UID_INVALID,
1565 interactive ? POLKIT_ALLOW_INTERACTIVE : 0,
1566 &c->polkit_registry,
1567 error);
1568 if (r < 0)
1569 return r;
1570 if (r == 0)
1571 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1572
1573 r = id128_get_product(&uuid);
1574 if (r < 0) {
1575 if (r == -EADDRNOTAVAIL)
1576 log_debug_errno(r, "DMI product UUID is all 0x00 or all 0xFF, ignoring.");
1577 else
1578 log_full_errno(r == -ENOENT ? LOG_DEBUG : LOG_WARNING, r,
1579 "Failed to read product UUID, ignoring: %m");
1580
1581 return sd_bus_error_set(error, BUS_ERROR_NO_PRODUCT_UUID,
1582 "Failed to read product UUID from firmware.");
1583 }
1584
1585 r = sd_bus_message_new_method_return(m, &reply);
1586 if (r < 0)
1587 return r;
1588
1589 r = sd_bus_message_append_array(reply, 'y', uuid.bytes, sizeof(uuid.bytes));
1590 if (r < 0)
1591 return r;
1592
1593 return sd_bus_message_send(reply);
1594}
1595
1596static int method_get_hardware_serial(sd_bus_message *m, void *userdata, sd_bus_error *error) {
1597 _cleanup_free_ char *serial = NULL;
1598 Context *c = ASSERT_PTR(userdata);
1599 int r;
1600
1601 assert(m);
1602
1603 r = bus_verify_polkit_async(
1604 m,
1605 "org.freedesktop.hostname1.get-hardware-serial",
1606 /* details= */ NULL,
1607 &c->polkit_registry,
1608 error);
1609 if (r < 0)
1610 return r;
1611 if (r == 0)
1612 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1613
1614 r = get_hardware_serial(c, &serial);
1615 if (r < 0)
1616 return sd_bus_error_set(error, BUS_ERROR_NO_HARDWARE_SERIAL,
1617 "Failed to read hardware serial from firmware.");
1618
1619 return sd_bus_reply_method_return(m, "s", serial);
1620}
1621
1622static int build_describe_response(Context *c, bool privileged, sd_json_variant **ret) {
1623 _cleanup_free_ char *hn = NULL, *dhn = NULL, *in = NULL,
1624 *chassis = NULL, *vendor = NULL, *model = NULL, *serial = NULL, *firmware_version = NULL,
1625 *firmware_vendor = NULL, *chassis_asset_tag = NULL, *sku = NULL, *hardware_version = NULL;
1626 _cleanup_strv_free_ char **os_release_pairs = NULL, **machine_info_pairs = NULL;
1627 usec_t firmware_date = USEC_INFINITY, eol = USEC_INFINITY;
1628 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
1629 sd_id128_t machine_id, boot_id, product_uuid = SD_ID128_NULL;
1630 unsigned local_cid = VMADDR_CID_ANY;
1631 struct utsname u;
1632 int r;
1633
1634 assert(c);
1635 assert(ret);
1636
1637 context_read_etc_hostname(c);
1638 context_read_machine_info(c);
1639 context_read_os_release(c);
1640 context_determine_hostname_source(c);
1641
1642 dhn = get_default_hostname();
1643 if (!dhn)
1644 return log_oom();
1645
1646 r = gethostname_strict(&hn);
1647 if (r < 0 && r != -ENXIO)
1648 return log_error_errno(r, "Failed to read local host name: %m");
1649
1650 if (isempty(c->data[PROP_ICON_NAME]))
1651 in = context_fallback_icon_name(c);
1652
1653 chassis = context_get_chassis(c);
1654
1655 assert_se(uname(&u) >= 0);
1656
1657 if (isempty(c->data[PROP_HARDWARE_VENDOR]))
1658 (void) get_hardware_vendor(c, &vendor);
1659 if (isempty(c->data[PROP_HARDWARE_MODEL]))
1660 (void) get_hardware_model(c, &model);
1661 if (isempty(c->data[PROP_HARDWARE_SKU]))
1662 (void) get_hardware_sku(c, &sku);
1663 if (isempty(c->data[PROP_HARDWARE_VERSION]))
1664 (void) get_hardware_version(c, &hardware_version);
1665
1666 if (privileged) {
1667 /* The product UUID and hardware serial is only available to privileged clients */
1668 (void) id128_get_product(&product_uuid);
1669 (void) get_hardware_serial(c, &serial);
1670 }
1671 (void) get_firmware_version(c, &firmware_version);
1672 (void) get_firmware_vendor(c, &firmware_vendor);
1673 (void) get_firmware_date(c, &firmware_date);
1674 (void) get_chassis_asset_tag(c, &chassis_asset_tag);
1675
1676 if (c->data[PROP_OS_SUPPORT_END])
1677 (void) os_release_support_ended(c->data[PROP_OS_SUPPORT_END], /* quiet= */ false, &eol);
1678
1679 r = sd_id128_get_machine(&machine_id);
1680 if (r < 0)
1681 return log_error_errno(r, "Failed to get machine ID: %m");
1682
1683 r = sd_id128_get_boot(&boot_id);
1684 if (r < 0)
1685 return log_error_errno(r, "Failed to get boot ID: %m");
1686
1687 (void) vsock_get_local_cid(&local_cid);
1688
1689 (void) load_os_release_pairs(/* root= */ NULL, &os_release_pairs);
1690 (void) load_env_file_pairs(/* f=*/ NULL, etc_machine_info(), &machine_info_pairs);
1691
1692 r = sd_json_buildo(
1693 &v,
1694 SD_JSON_BUILD_PAIR_STRING("Hostname", hn ?: dhn),
1695 SD_JSON_BUILD_PAIR_STRING("StaticHostname", c->data[PROP_STATIC_HOSTNAME_SUBSTITUTED_WILDCARDS]),
1696 SD_JSON_BUILD_PAIR_STRING("PrettyHostname", c->data[PROP_PRETTY_HOSTNAME]),
1697 SD_JSON_BUILD_PAIR_STRING("DefaultHostname", dhn),
1698 SD_JSON_BUILD_PAIR_STRING("HostnameSource", hostname_source_to_string(c->hostname_source)),
1699 SD_JSON_BUILD_PAIR_STRING("IconName", in ?: c->data[PROP_ICON_NAME]),
1700 SD_JSON_BUILD_PAIR_STRING("Chassis", chassis),
1701 SD_JSON_BUILD_PAIR_STRING("ChassisAssetTag", chassis_asset_tag),
1702 SD_JSON_BUILD_PAIR_STRING("Deployment", c->data[PROP_DEPLOYMENT]),
1703 SD_JSON_BUILD_PAIR_STRING("Location", c->data[PROP_LOCATION]),
1704 SD_JSON_BUILD_PAIR_STRING("KernelName", u.sysname),
1705 SD_JSON_BUILD_PAIR_STRING("KernelRelease", u.release),
1706 SD_JSON_BUILD_PAIR_STRING("KernelVersion", u.version),
1707 SD_JSON_BUILD_PAIR_STRING("OperatingSystemPrettyName", c->data[PROP_OS_PRETTY_NAME]),
1708 SD_JSON_BUILD_PAIR_STRING("OperatingSystemCPEName", c->data[PROP_OS_CPE_NAME]),
1709 SD_JSON_BUILD_PAIR_STRING("OperatingSystemHomeURL", c->data[PROP_OS_HOME_URL]),
1710 JSON_BUILD_PAIR_FINITE_USEC("OperatingSystemSupportEnd", eol),
1711 SD_JSON_BUILD_PAIR("OperatingSystemReleaseData", JSON_BUILD_STRV_ENV_PAIR(os_release_pairs)),
1712 SD_JSON_BUILD_PAIR_STRING("OperatingSystemImageID", c->data[PROP_OS_IMAGE_ID]),
1713 SD_JSON_BUILD_PAIR_STRING("OperatingSystemImageVersion", c->data[PROP_OS_IMAGE_VERSION]),
1714 SD_JSON_BUILD_PAIR("MachineInformationData", JSON_BUILD_STRV_ENV_PAIR(machine_info_pairs)),
1715 SD_JSON_BUILD_PAIR_STRING("HardwareVendor", vendor ?: c->data[PROP_HARDWARE_VENDOR]),
1716 SD_JSON_BUILD_PAIR_STRING("HardwareModel", model ?: c->data[PROP_HARDWARE_MODEL]),
1717 SD_JSON_BUILD_PAIR_STRING("HardwareSerial", serial),
1718 SD_JSON_BUILD_PAIR_STRING("HardwareSKU", sku ?: c->data[PROP_HARDWARE_SKU]),
1719 SD_JSON_BUILD_PAIR_STRING("HardwareVersion", hardware_version ?: c->data[PROP_HARDWARE_VERSION]),
1720 SD_JSON_BUILD_PAIR_STRING("FirmwareVersion", firmware_version),
1721 SD_JSON_BUILD_PAIR_STRING("FirmwareVendor", firmware_vendor),
1722 JSON_BUILD_PAIR_FINITE_USEC("FirmwareDate", firmware_date),
1723 SD_JSON_BUILD_PAIR_ID128("MachineID", machine_id),
1724 SD_JSON_BUILD_PAIR_ID128("BootID", boot_id),
1725 SD_JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(product_uuid), "ProductUUID", SD_JSON_BUILD_ID128(product_uuid)),
1726 SD_JSON_BUILD_PAIR_CONDITION(sd_id128_is_null(product_uuid), "ProductUUID", SD_JSON_BUILD_NULL),
1727 SD_JSON_BUILD_PAIR_CONDITION(local_cid != VMADDR_CID_ANY, "VSockCID", SD_JSON_BUILD_UNSIGNED(local_cid)),
1728 SD_JSON_BUILD_PAIR_CONDITION(local_cid == VMADDR_CID_ANY, "VSockCID", SD_JSON_BUILD_NULL));
1729 if (r < 0)
1730 return log_error_errno(r, "Failed to build JSON data: %m");
1731
1732 *ret = TAKE_PTR(v);
1733 return 0;
1734}
1735
1736static int method_describe(sd_bus_message *m, void *userdata, sd_bus_error *error) {
1737 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
1738 Context *c = ASSERT_PTR(userdata);
1739 _cleanup_free_ char *text = NULL;
1740 bool privileged;
1741 int r;
1742
1743 assert(m);
1744
1745 r = bus_verify_polkit_async(
1746 m,
1747 "org.freedesktop.hostname1.get-description",
1748 /* details= */ NULL,
1749 &c->polkit_registry,
1750 error);
1751 if (r == 0)
1752 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1753
1754 /* We ignore all authentication errors here, since most data is unprivileged, the one exception being
1755 * the product ID which we'll check explicitly. */
1756 privileged = r > 0;
1757
1758 r = build_describe_response(c, privileged, &v);
1759 if (r < 0)
1760 return r;
1761
1762 r = sd_json_variant_format(v, 0, &text);
1763 if (r < 0)
1764 return log_error_errno(r, "Failed to format JSON data: %m");
1765
1766 return sd_bus_reply_method_return(m, "s", text);
1767}
1768
1769static const sd_bus_vtable hostname_vtable[] = {
1770 SD_BUS_VTABLE_START(0),
1771 SD_BUS_PROPERTY("Hostname", "s", property_get_hostname, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1772 SD_BUS_PROPERTY("StaticHostname", "s", property_get_static_hostname, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1773 SD_BUS_PROPERTY("PrettyHostname", "s", property_get_machine_info_field, offsetof(Context, data[PROP_PRETTY_HOSTNAME]), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1774 SD_BUS_PROPERTY("DefaultHostname", "s", property_get_default_hostname, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1775 SD_BUS_PROPERTY("HostnameSource", "s", property_get_hostname_source, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1776 SD_BUS_PROPERTY("IconName", "s", property_get_icon_name, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1777 SD_BUS_PROPERTY("Chassis", "s", property_get_chassis, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1778 SD_BUS_PROPERTY("Deployment", "s", property_get_machine_info_field, offsetof(Context, data[PROP_DEPLOYMENT]), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1779 SD_BUS_PROPERTY("Location", "s", property_get_machine_info_field, offsetof(Context, data[PROP_LOCATION]), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1780 SD_BUS_PROPERTY("KernelName", "s", property_get_uname_field, offsetof(struct utsname, sysname), SD_BUS_VTABLE_ABSOLUTE_OFFSET|SD_BUS_VTABLE_PROPERTY_CONST),
1781 SD_BUS_PROPERTY("KernelRelease", "s", property_get_uname_field, offsetof(struct utsname, release), SD_BUS_VTABLE_ABSOLUTE_OFFSET|SD_BUS_VTABLE_PROPERTY_CONST),
1782 SD_BUS_PROPERTY("KernelVersion", "s", property_get_uname_field, offsetof(struct utsname, version), SD_BUS_VTABLE_ABSOLUTE_OFFSET|SD_BUS_VTABLE_PROPERTY_CONST),
1783 SD_BUS_PROPERTY("OperatingSystemPrettyName", "s", property_get_os_release_field, offsetof(Context, data[PROP_OS_PRETTY_NAME]), SD_BUS_VTABLE_PROPERTY_CONST),
1784 SD_BUS_PROPERTY("OperatingSystemCPEName", "s", property_get_os_release_field, offsetof(Context, data[PROP_OS_CPE_NAME]), SD_BUS_VTABLE_PROPERTY_CONST),
1785 SD_BUS_PROPERTY("OperatingSystemSupportEnd", "t", property_get_os_support_end, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1786 SD_BUS_PROPERTY("HomeURL", "s", property_get_os_release_field, offsetof(Context, data[PROP_OS_HOME_URL]), SD_BUS_VTABLE_PROPERTY_CONST),
1787 SD_BUS_PROPERTY("OperatingSystemImageID", "s", property_get_os_release_field, offsetof(Context, data[PROP_OS_IMAGE_ID]), SD_BUS_VTABLE_PROPERTY_CONST),
1788 SD_BUS_PROPERTY("OperatingSystemImageVersion", "s", property_get_os_release_field, offsetof(Context, data[PROP_OS_IMAGE_VERSION]), SD_BUS_VTABLE_PROPERTY_CONST),
1789 SD_BUS_PROPERTY("HardwareVendor", "s", property_get_hardware_vendor, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1790 SD_BUS_PROPERTY("HardwareModel", "s", property_get_hardware_model, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1791 SD_BUS_PROPERTY("HardwareSKU", "s", property_get_hardware_sku, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1792 SD_BUS_PROPERTY("HardwareVersion", "s", property_get_hardware_version, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1793 SD_BUS_PROPERTY("FirmwareVersion", "s", property_get_firmware_version, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1794 SD_BUS_PROPERTY("FirmwareVendor", "s", property_get_firmware_vendor, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1795 SD_BUS_PROPERTY("FirmwareDate", "t", property_get_firmware_date, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1796 SD_BUS_PROPERTY("MachineID", "ay", property_get_machine_id, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1797 SD_BUS_PROPERTY("BootID", "ay", property_get_boot_id, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1798 SD_BUS_PROPERTY("VSockCID", "u", property_get_vsock_cid, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1799 SD_BUS_PROPERTY("ChassisAssetTag", "s", property_get_chassis_asset_tag, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1800
1801 SD_BUS_METHOD_WITH_ARGS("SetHostname",
1802 SD_BUS_ARGS("s", hostname, "b", interactive),
1803 SD_BUS_NO_RESULT,
1804 method_set_hostname,
1805 SD_BUS_VTABLE_UNPRIVILEGED),
1806 SD_BUS_METHOD_WITH_ARGS("SetStaticHostname",
1807 SD_BUS_ARGS("s", hostname, "b", interactive),
1808 SD_BUS_NO_RESULT,
1809 method_set_static_hostname,
1810 SD_BUS_VTABLE_UNPRIVILEGED),
1811 SD_BUS_METHOD_WITH_ARGS("SetPrettyHostname",
1812 SD_BUS_ARGS("s", hostname, "b", interactive),
1813 SD_BUS_NO_RESULT,
1814 method_set_pretty_hostname,
1815 SD_BUS_VTABLE_UNPRIVILEGED),
1816 SD_BUS_METHOD_WITH_ARGS("SetIconName",
1817 SD_BUS_ARGS("s", icon, "b", interactive),
1818 SD_BUS_NO_RESULT,
1819 method_set_icon_name,
1820 SD_BUS_VTABLE_UNPRIVILEGED),
1821 SD_BUS_METHOD_WITH_ARGS("SetChassis",
1822 SD_BUS_ARGS("s", chassis, "b", interactive),
1823 SD_BUS_NO_RESULT,
1824 method_set_chassis,
1825 SD_BUS_VTABLE_UNPRIVILEGED),
1826 SD_BUS_METHOD_WITH_ARGS("SetDeployment",
1827 SD_BUS_ARGS("s", deployment, "b", interactive),
1828 SD_BUS_NO_RESULT,
1829 method_set_deployment,
1830 SD_BUS_VTABLE_UNPRIVILEGED),
1831 SD_BUS_METHOD_WITH_ARGS("SetLocation",
1832 SD_BUS_ARGS("s", location, "b", interactive),
1833 SD_BUS_NO_RESULT,
1834 method_set_location,
1835 SD_BUS_VTABLE_UNPRIVILEGED),
1836 SD_BUS_METHOD_WITH_ARGS("GetProductUUID",
1837 SD_BUS_ARGS("b", interactive),
1838 SD_BUS_RESULT("ay", uuid),
1839 method_get_product_uuid,
1840 SD_BUS_VTABLE_UNPRIVILEGED),
1841 SD_BUS_METHOD_WITH_ARGS("GetHardwareSerial",
1842 SD_BUS_NO_ARGS,
1843 SD_BUS_RESULT("s", serial),
1844 method_get_hardware_serial,
1845 SD_BUS_VTABLE_UNPRIVILEGED),
1846 SD_BUS_METHOD_WITH_ARGS("Describe",
1847 SD_BUS_NO_ARGS,
1848 SD_BUS_RESULT("s", json),
1849 method_describe,
1850 SD_BUS_VTABLE_UNPRIVILEGED),
1851
1852 SD_BUS_VTABLE_END,
1853};
1854
1855static const BusObjectImplementation manager_object = {
1856 "/org/freedesktop/hostname1",
1857 "org.freedesktop.hostname1",
1858 .vtables = BUS_VTABLES(hostname_vtable),
1859};
1860
1861static int connect_bus(Context *c) {
1862 int r;
1863
1864 assert(c);
1865 assert(c->event);
1866 assert(!c->bus);
1867
1868 r = sd_bus_default_system(&c->bus);
1869 if (r < 0)
1870 return log_error_errno(r, "Failed to get system bus connection: %m");
1871
1872 r = bus_add_implementation(c->bus, &manager_object, c);
1873 if (r < 0)
1874 return r;
1875
1876 r = bus_log_control_api_register(c->bus);
1877 if (r < 0)
1878 return r;
1879
1880 r = sd_bus_request_name_async(c->bus, NULL, "org.freedesktop.hostname1", 0, NULL, NULL);
1881 if (r < 0)
1882 return log_error_errno(r, "Failed to request name: %m");
1883
1884 r = sd_bus_attach_event(c->bus, c->event, 0);
1885 if (r < 0)
1886 return log_error_errno(r, "Failed to attach bus to event loop: %m");
1887
1888 return 0;
1889}
1890
1891static int vl_method_describe(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
1892 Context *c = ASSERT_PTR(userdata);
1893 bool privileged;
1894 int r;
1895
1896 assert(link);
1897 assert(parameters);
1898
1899 r = sd_varlink_dispatch(link, parameters, dispatch_table_polkit_only, /* userdata= */ NULL);
1900 if (r != 0)
1901 return r;
1902
1903 r = varlink_verify_polkit_async_full(
1904 link,
1905 c->bus,
1906 "org.freedesktop.hostname1.get-hardware-serial",
1907 /* details= */ NULL,
1908 UID_INVALID,
1909 POLKIT_DONT_REPLY,
1910 &c->polkit_registry);
1911 if (r == 0)
1912 return 0; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1913
1914 /* We ignore all authentication errors here, since most data is unprivileged, the one exception being
1915 * the product ID which we'll check explicitly. */
1916 privileged = r > 0;
1917
1918 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
1919 r = build_describe_response(c, privileged, &v);
1920 if (r < 0)
1921 return r;
1922
1923 return sd_varlink_reply(link, v);
1924}
1925
1926static int connect_varlink(Context *c) {
1927 int r;
1928
1929 assert(c);
1930 assert(c->event);
1931 assert(!c->varlink_server);
1932
1933 r = varlink_server_new(
1934 &c->varlink_server,
1935 SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA,
1936 c);
1937 if (r < 0)
1938 return log_error_errno(r, "Failed to allocate Varlink server: %m");
1939
1940 r = sd_varlink_server_add_interface_many(
1941 c->varlink_server,
1942 &vl_interface_io_systemd_Hostname,
1943 &vl_interface_io_systemd_service);
1944 if (r < 0)
1945 return log_error_errno(r, "Failed to add Hostname interface to Varlink server: %m");
1946
1947 r = sd_varlink_server_bind_method_many(
1948 c->varlink_server,
1949 "io.systemd.Hostname.Describe", vl_method_describe,
1950 "io.systemd.service.Ping", varlink_method_ping,
1951 "io.systemd.service.SetLogLevel", varlink_method_set_log_level,
1952 "io.systemd.service.GetEnvironment", varlink_method_get_environment);
1953 if (r < 0)
1954 return log_error_errno(r, "Failed to bind Varlink method calls: %m");
1955
1956 r = sd_varlink_server_attach_event(c->varlink_server, c->event, SD_EVENT_PRIORITY_NORMAL);
1957 if (r < 0)
1958 return log_error_errno(r, "Failed to attach Varlink server to event loop: %m");
1959
1960 r = sd_varlink_server_listen_auto(c->varlink_server);
1961 if (r < 0)
1962 return log_error_errno(r, "Failed to bind to passed Varlink sockets: %m");
1963 if (r == 0) {
1964 r = sd_varlink_server_listen_address(c->varlink_server, "/run/systemd/io.systemd.Hostname", 0666);
1965 if (r < 0)
1966 return log_error_errno(r, "Failed to bind to Varlink socket: %m");
1967 }
1968
1969 return 0;
1970}
1971
1972static bool context_check_idle(void *userdata) {
1973 Context *c = ASSERT_PTR(userdata);
1974
1975 return sd_varlink_server_current_connections(c->varlink_server) == 0 &&
1976 hashmap_isempty(c->polkit_registry);
1977}
1978
1979static int run(int argc, char *argv[]) {
1980 _cleanup_(context_destroy) Context context = {
1981 .hostname_source = _HOSTNAME_INVALID, /* appropriate value will be set later */
1982 };
1983 int r;
1984
1985 log_setup();
1986
1987 r = service_parse_argv("systemd-hostnamed.service",
1988 "Manage the system hostname and related metadata.",
1989 BUS_IMPLEMENTATIONS(&manager_object,
1990 &log_control_object),
1991 argc, argv);
1992 if (r <= 0)
1993 return r;
1994
1995 umask(0022);
1996
1997 r = mac_init();
1998 if (r < 0)
1999 return r;
2000
2001 r = context_acquire_dmi_device(&context);
2002 if (r < 0)
2003 return r;
2004
2005 r = context_acquire_acpi_device(&context);
2006 if (r < 0)
2007 return r;
2008
2009 r = context_acquire_device_tree(&context);
2010 if (r < 0)
2011 return r;
2012
2013 r = sd_event_default(&context.event);
2014 if (r < 0)
2015 return log_error_errno(r, "Failed to allocate event loop: %m");
2016
2017 (void) sd_event_set_watchdog(context.event, true);
2018
2019 r = sd_event_set_signal_exit(context.event, true);
2020 if (r < 0)
2021 return log_error_errno(r, "Failed to install SIGINT/SIGTERM handlers: %m");
2022
2023 r = connect_bus(&context);
2024 if (r < 0)
2025 return r;
2026
2027 r = connect_varlink(&context);
2028 if (r < 0)
2029 return r;
2030
2031 r = sd_notify(false, NOTIFY_READY_MESSAGE);
2032 if (r < 0)
2033 log_warning_errno(r, "Failed to send readiness notification, ignoring: %m");
2034
2035 r = bus_event_loop_with_idle(
2036 context.event,
2037 context.bus,
2038 "org.freedesktop.hostname1",
2039 DEFAULT_EXIT_USEC,
2040 context_check_idle,
2041 &context);
2042 if (r < 0)
2043 return log_error_errno(r, "Failed to run event loop: %m");
2044
2045 return 0;
2046}
2047
2048DEFINE_MAIN_FUNCTION(run);
Unnamed repository; edit this file 'description' to name the repository.