]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/shared/bus-util.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #9417 from Conan-Kudo/rpm-environmentdir-typo
[thirdparty/systemd.git] / src / shared / bus-util.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2
3 #include <errno.h>
4 #include <fcntl.h>
5 #include <inttypes.h>
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <sys/ioctl.h>
10 #include <sys/resource.h>
11 #include <sys/socket.h>
12 #include <unistd.h>
13
14 #include "sd-bus-protocol.h"
15 #include "sd-bus.h"
16 #include "sd-daemon.h"
17 #include "sd-event.h"
18 #include "sd-id128.h"
19
20 #include "alloc-util.h"
21 #include "bus-internal.h"
22 #include "bus-label.h"
23 #include "bus-message.h"
24 #include "bus-util.h"
25 #include "cap-list.h"
26 #include "cgroup-util.h"
27 #include "def.h"
28 #include "escape.h"
29 #include "fd-util.h"
30 #include "missing.h"
31 #include "mount-util.h"
32 #include "nsflags.h"
33 #include "parse-util.h"
34 #include "proc-cmdline.h"
35 #include "rlimit-util.h"
36 #include "stdio-util.h"
37 #include "strv.h"
38 #include "user-util.h"
39
40 static int name_owner_change_callback(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
41 sd_event *e = userdata;
42
43 assert(m);
44 assert(e);
45
46 sd_bus_close(sd_bus_message_get_bus(m));
47 sd_event_exit(e, 0);
48
49 return 1;
50 }
51
52 int bus_async_unregister_and_exit(sd_event *e, sd_bus *bus, const char *name) {
53 const char *match;
54 const char *unique;
55 int r;
56
57 assert(e);
58 assert(bus);
59 assert(name);
60
61 /* We unregister the name here and then wait for the
62 * NameOwnerChanged signal for this event to arrive before we
63 * quit. We do this in order to make sure that any queued
64 * requests are still processed before we really exit. */
65
66 r = sd_bus_get_unique_name(bus, &unique);
67 if (r < 0)
68 return r;
69
70 match = strjoina(
71 "sender='org.freedesktop.DBus',"
72 "type='signal',"
73 "interface='org.freedesktop.DBus',"
74 "member='NameOwnerChanged',"
75 "path='/org/freedesktop/DBus',"
76 "arg0='", name, "',",
77 "arg1='", unique, "',",
78 "arg2=''");
79
80 r = sd_bus_add_match_async(bus, NULL, match, name_owner_change_callback, NULL, e);
81 if (r < 0)
82 return r;
83
84 r = sd_bus_release_name_async(bus, NULL, name, NULL, NULL);
85 if (r < 0)
86 return r;
87
88 return 0;
89 }
90
91 int bus_event_loop_with_idle(
92 sd_event *e,
93 sd_bus *bus,
94 const char *name,
95 usec_t timeout,
96 check_idle_t check_idle,
97 void *userdata) {
98 bool exiting = false;
99 int r, code;
100
101 assert(e);
102 assert(bus);
103 assert(name);
104
105 for (;;) {
106 bool idle;
107
108 r = sd_event_get_state(e);
109 if (r < 0)
110 return r;
111 if (r == SD_EVENT_FINISHED)
112 break;
113
114 if (check_idle)
115 idle = check_idle(userdata);
116 else
117 idle = true;
118
119 r = sd_event_run(e, exiting || !idle ? (uint64_t) -1 : timeout);
120 if (r < 0)
121 return r;
122
123 if (r == 0 && !exiting && idle) {
124
125 r = sd_bus_try_close(bus);
126 if (r == -EBUSY)
127 continue;
128
129 /* Fallback for dbus1 connections: we
130 * unregister the name and wait for the
131 * response to come through for it */
132 if (r == -EOPNOTSUPP) {
133
134 /* Inform the service manager that we
135 * are going down, so that it will
136 * queue all further start requests,
137 * instead of assuming we are already
138 * running. */
139 sd_notify(false, "STOPPING=1");
140
141 r = bus_async_unregister_and_exit(e, bus, name);
142 if (r < 0)
143 return r;
144
145 exiting = true;
146 continue;
147 }
148
149 if (r < 0)
150 return r;
151
152 sd_event_exit(e, 0);
153 break;
154 }
155 }
156
157 r = sd_event_get_exit_code(e, &code);
158 if (r < 0)
159 return r;
160
161 return code;
162 }
163
164 int bus_name_has_owner(sd_bus *c, const char *name, sd_bus_error *error) {
165 _cleanup_(sd_bus_message_unrefp) sd_bus_message *rep = NULL;
166 int r, has_owner = 0;
167
168 assert(c);
169 assert(name);
170
171 r = sd_bus_call_method(c,
172 "org.freedesktop.DBus",
173 "/org/freedesktop/dbus",
174 "org.freedesktop.DBus",
175 "NameHasOwner",
176 error,
177 &rep,
178 "s",
179 name);
180 if (r < 0)
181 return r;
182
183 r = sd_bus_message_read_basic(rep, 'b', &has_owner);
184 if (r < 0)
185 return sd_bus_error_set_errno(error, r);
186
187 return has_owner;
188 }
189
190 static int check_good_user(sd_bus_message *m, uid_t good_user) {
191 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
192 uid_t sender_uid;
193 int r;
194
195 assert(m);
196
197 if (good_user == UID_INVALID)
198 return 0;
199
200 r = sd_bus_query_sender_creds(m, SD_BUS_CREDS_EUID, &creds);
201 if (r < 0)
202 return r;
203
204 /* Don't trust augmented credentials for authorization */
205 assert_return((sd_bus_creds_get_augmented_mask(creds) & SD_BUS_CREDS_EUID) == 0, -EPERM);
206
207 r = sd_bus_creds_get_euid(creds, &sender_uid);
208 if (r < 0)
209 return r;
210
211 return sender_uid == good_user;
212 }
213
214 int bus_test_polkit(
215 sd_bus_message *call,
216 int capability,
217 const char *action,
218 const char **details,
219 uid_t good_user,
220 bool *_challenge,
221 sd_bus_error *e) {
222
223 int r;
224
225 assert(call);
226 assert(action);
227
228 /* Tests non-interactively! */
229
230 r = check_good_user(call, good_user);
231 if (r != 0)
232 return r;
233
234 r = sd_bus_query_sender_privilege(call, capability);
235 if (r < 0)
236 return r;
237 else if (r > 0)
238 return 1;
239 #if ENABLE_POLKIT
240 else {
241 _cleanup_(sd_bus_message_unrefp) sd_bus_message *request = NULL;
242 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
243 int authorized = false, challenge = false;
244 const char *sender, **k, **v;
245
246 sender = sd_bus_message_get_sender(call);
247 if (!sender)
248 return -EBADMSG;
249
250 r = sd_bus_message_new_method_call(
251 call->bus,
252 &request,
253 "org.freedesktop.PolicyKit1",
254 "/org/freedesktop/PolicyKit1/Authority",
255 "org.freedesktop.PolicyKit1.Authority",
256 "CheckAuthorization");
257 if (r < 0)
258 return r;
259
260 r = sd_bus_message_append(
261 request,
262 "(sa{sv})s",
263 "system-bus-name", 1, "name", "s", sender,
264 action);
265 if (r < 0)
266 return r;
267
268 r = sd_bus_message_open_container(request, 'a', "{ss}");
269 if (r < 0)
270 return r;
271
272 STRV_FOREACH_PAIR(k, v, details) {
273 r = sd_bus_message_append(request, "{ss}", *k, *v);
274 if (r < 0)
275 return r;
276 }
277
278 r = sd_bus_message_close_container(request);
279 if (r < 0)
280 return r;
281
282 r = sd_bus_message_append(request, "us", 0, NULL);
283 if (r < 0)
284 return r;
285
286 r = sd_bus_call(call->bus, request, 0, e, &reply);
287 if (r < 0) {
288 /* Treat no PK available as access denied */
289 if (sd_bus_error_has_name(e, SD_BUS_ERROR_SERVICE_UNKNOWN)) {
290 sd_bus_error_free(e);
291 return -EACCES;
292 }
293
294 return r;
295 }
296
297 r = sd_bus_message_enter_container(reply, 'r', "bba{ss}");
298 if (r < 0)
299 return r;
300
301 r = sd_bus_message_read(reply, "bb", &authorized, &challenge);
302 if (r < 0)
303 return r;
304
305 if (authorized)
306 return 1;
307
308 if (_challenge) {
309 *_challenge = challenge;
310 return 0;
311 }
312 }
313 #endif
314
315 return -EACCES;
316 }
317
318 #if ENABLE_POLKIT
319
320 typedef struct AsyncPolkitQuery {
321 sd_bus_message *request, *reply;
322 sd_bus_message_handler_t callback;
323 void *userdata;
324 sd_bus_slot *slot;
325 Hashmap *registry;
326 } AsyncPolkitQuery;
327
328 static void async_polkit_query_free(AsyncPolkitQuery *q) {
329
330 if (!q)
331 return;
332
333 sd_bus_slot_unref(q->slot);
334
335 if (q->registry && q->request)
336 hashmap_remove(q->registry, q->request);
337
338 sd_bus_message_unref(q->request);
339 sd_bus_message_unref(q->reply);
340
341 free(q);
342 }
343
344 static int async_polkit_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
345 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
346 AsyncPolkitQuery *q = userdata;
347 int r;
348
349 assert(reply);
350 assert(q);
351
352 q->slot = sd_bus_slot_unref(q->slot);
353 q->reply = sd_bus_message_ref(reply);
354
355 r = sd_bus_message_rewind(q->request, true);
356 if (r < 0) {
357 r = sd_bus_reply_method_errno(q->request, r, NULL);
358 goto finish;
359 }
360
361 r = q->callback(q->request, q->userdata, &error_buffer);
362 r = bus_maybe_reply_error(q->request, r, &error_buffer);
363
364 finish:
365 async_polkit_query_free(q);
366
367 return r;
368 }
369
370 #endif
371
372 int bus_verify_polkit_async(
373 sd_bus_message *call,
374 int capability,
375 const char *action,
376 const char **details,
377 bool interactive,
378 uid_t good_user,
379 Hashmap **registry,
380 sd_bus_error *error) {
381
382 #if ENABLE_POLKIT
383 _cleanup_(sd_bus_message_unrefp) sd_bus_message *pk = NULL;
384 AsyncPolkitQuery *q;
385 const char *sender, **k, **v;
386 sd_bus_message_handler_t callback;
387 void *userdata;
388 int c;
389 #endif
390 int r;
391
392 assert(call);
393 assert(action);
394 assert(registry);
395
396 r = check_good_user(call, good_user);
397 if (r != 0)
398 return r;
399
400 #if ENABLE_POLKIT
401 q = hashmap_get(*registry, call);
402 if (q) {
403 int authorized, challenge;
404
405 /* This is the second invocation of this function, and
406 * there's already a response from polkit, let's
407 * process it */
408 assert(q->reply);
409
410 if (sd_bus_message_is_method_error(q->reply, NULL)) {
411 const sd_bus_error *e;
412
413 /* Copy error from polkit reply */
414 e = sd_bus_message_get_error(q->reply);
415 sd_bus_error_copy(error, e);
416
417 /* Treat no PK available as access denied */
418 if (sd_bus_error_has_name(e, SD_BUS_ERROR_SERVICE_UNKNOWN))
419 return -EACCES;
420
421 return -sd_bus_error_get_errno(e);
422 }
423
424 r = sd_bus_message_enter_container(q->reply, 'r', "bba{ss}");
425 if (r >= 0)
426 r = sd_bus_message_read(q->reply, "bb", &authorized, &challenge);
427
428 if (r < 0)
429 return r;
430
431 if (authorized)
432 return 1;
433
434 if (challenge)
435 return sd_bus_error_set(error, SD_BUS_ERROR_INTERACTIVE_AUTHORIZATION_REQUIRED, "Interactive authentication required.");
436
437 return -EACCES;
438 }
439 #endif
440
441 r = sd_bus_query_sender_privilege(call, capability);
442 if (r < 0)
443 return r;
444 else if (r > 0)
445 return 1;
446
447 #if ENABLE_POLKIT
448 if (sd_bus_get_current_message(call->bus) != call)
449 return -EINVAL;
450
451 callback = sd_bus_get_current_handler(call->bus);
452 if (!callback)
453 return -EINVAL;
454
455 userdata = sd_bus_get_current_userdata(call->bus);
456
457 sender = sd_bus_message_get_sender(call);
458 if (!sender)
459 return -EBADMSG;
460
461 c = sd_bus_message_get_allow_interactive_authorization(call);
462 if (c < 0)
463 return c;
464 if (c > 0)
465 interactive = true;
466
467 r = hashmap_ensure_allocated(registry, NULL);
468 if (r < 0)
469 return r;
470
471 r = sd_bus_message_new_method_call(
472 call->bus,
473 &pk,
474 "org.freedesktop.PolicyKit1",
475 "/org/freedesktop/PolicyKit1/Authority",
476 "org.freedesktop.PolicyKit1.Authority",
477 "CheckAuthorization");
478 if (r < 0)
479 return r;
480
481 r = sd_bus_message_append(
482 pk,
483 "(sa{sv})s",
484 "system-bus-name", 1, "name", "s", sender,
485 action);
486 if (r < 0)
487 return r;
488
489 r = sd_bus_message_open_container(pk, 'a', "{ss}");
490 if (r < 0)
491 return r;
492
493 STRV_FOREACH_PAIR(k, v, details) {
494 r = sd_bus_message_append(pk, "{ss}", *k, *v);
495 if (r < 0)
496 return r;
497 }
498
499 r = sd_bus_message_close_container(pk);
500 if (r < 0)
501 return r;
502
503 r = sd_bus_message_append(pk, "us", interactive, NULL);
504 if (r < 0)
505 return r;
506
507 q = new0(AsyncPolkitQuery, 1);
508 if (!q)
509 return -ENOMEM;
510
511 q->request = sd_bus_message_ref(call);
512 q->callback = callback;
513 q->userdata = userdata;
514
515 r = hashmap_put(*registry, call, q);
516 if (r < 0) {
517 async_polkit_query_free(q);
518 return r;
519 }
520
521 q->registry = *registry;
522
523 r = sd_bus_call_async(call->bus, &q->slot, pk, async_polkit_callback, q, 0);
524 if (r < 0) {
525 async_polkit_query_free(q);
526 return r;
527 }
528
529 return 0;
530 #endif
531
532 return -EACCES;
533 }
534
535 void bus_verify_polkit_async_registry_free(Hashmap *registry) {
536 #if ENABLE_POLKIT
537 hashmap_free_with_destructor(registry, async_polkit_query_free);
538 #endif
539 }
540
541 int bus_check_peercred(sd_bus *c) {
542 struct ucred ucred;
543 int fd, r;
544
545 assert(c);
546
547 fd = sd_bus_get_fd(c);
548 if (fd < 0)
549 return fd;
550
551 r = getpeercred(fd, &ucred);
552 if (r < 0)
553 return r;
554
555 if (ucred.uid != 0 && ucred.uid != geteuid())
556 return -EPERM;
557
558 return 1;
559 }
560
561 int bus_connect_system_systemd(sd_bus **_bus) {
562 _cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
563 int r;
564
565 assert(_bus);
566
567 if (geteuid() != 0)
568 return sd_bus_default_system(_bus);
569
570 /* If we are root then let's talk directly to the system
571 * instance, instead of going via the bus */
572
573 r = sd_bus_new(&bus);
574 if (r < 0)
575 return r;
576
577 r = sd_bus_set_address(bus, "unix:path=/run/systemd/private");
578 if (r < 0)
579 return r;
580
581 r = sd_bus_start(bus);
582 if (r < 0)
583 return sd_bus_default_system(_bus);
584
585 r = bus_check_peercred(bus);
586 if (r < 0)
587 return r;
588
589 *_bus = TAKE_PTR(bus);
590
591 return 0;
592 }
593
594 int bus_connect_user_systemd(sd_bus **_bus) {
595 _cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
596 _cleanup_free_ char *ee = NULL;
597 const char *e;
598 int r;
599
600 assert(_bus);
601
602 e = secure_getenv("XDG_RUNTIME_DIR");
603 if (!e)
604 return sd_bus_default_user(_bus);
605
606 ee = bus_address_escape(e);
607 if (!ee)
608 return -ENOMEM;
609
610 r = sd_bus_new(&bus);
611 if (r < 0)
612 return r;
613
614 bus->address = strjoin("unix:path=", ee, "/systemd/private");
615 if (!bus->address)
616 return -ENOMEM;
617
618 r = sd_bus_start(bus);
619 if (r < 0)
620 return sd_bus_default_user(_bus);
621
622 r = bus_check_peercred(bus);
623 if (r < 0)
624 return r;
625
626 *_bus = TAKE_PTR(bus);
627
628 return 0;
629 }
630
631 #define print_property(name, fmt, ...) \
632 do { \
633 if (value) \
634 printf(fmt "\n", __VA_ARGS__); \
635 else \
636 printf("%s=" fmt "\n", name, __VA_ARGS__); \
637 } while (0)
638
639 int bus_print_property(const char *name, sd_bus_message *m, bool value, bool all) {
640 char type;
641 const char *contents;
642 int r;
643
644 assert(name);
645 assert(m);
646
647 r = sd_bus_message_peek_type(m, &type, &contents);
648 if (r < 0)
649 return r;
650
651 switch (type) {
652
653 case SD_BUS_TYPE_STRING: {
654 const char *s;
655
656 r = sd_bus_message_read_basic(m, type, &s);
657 if (r < 0)
658 return r;
659
660 if (all || !isempty(s)) {
661 bool good;
662
663 /* This property has a single value, so we need to take
664 * care not to print a new line, everything else is OK. */
665 good = !strchr(s, '\n');
666 print_property(name, "%s", good ? s : "[unprintable]");
667 }
668
669 return 1;
670 }
671
672 case SD_BUS_TYPE_BOOLEAN: {
673 int b;
674
675 r = sd_bus_message_read_basic(m, type, &b);
676 if (r < 0)
677 return r;
678
679 print_property(name, "%s", yes_no(b));
680
681 return 1;
682 }
683
684 case SD_BUS_TYPE_UINT64: {
685 uint64_t u;
686
687 r = sd_bus_message_read_basic(m, type, &u);
688 if (r < 0)
689 return r;
690
691 /* Yes, heuristics! But we can change this check
692 * should it turn out to not be sufficient */
693
694 if (endswith(name, "Timestamp") ||
695 STR_IN_SET(name, "NextElapseUSecRealtime", "LastTriggerUSec", "TimeUSec", "RTCTimeUSec")) {
696 char timestamp[FORMAT_TIMESTAMP_MAX];
697 const char *t;
698
699 t = format_timestamp(timestamp, sizeof(timestamp), u);
700 if (t || all)
701 print_property(name, "%s", strempty(t));
702
703 } else if (strstr(name, "USec")) {
704 char timespan[FORMAT_TIMESPAN_MAX];
705
706 print_property(name, "%s", format_timespan(timespan, sizeof(timespan), u, 0));
707 } else if (streq(name, "RestrictNamespaces")) {
708 _cleanup_free_ char *s = NULL;
709 const char *result;
710
711 if ((u & NAMESPACE_FLAGS_ALL) == 0)
712 result = "yes";
713 else if ((u & NAMESPACE_FLAGS_ALL) == NAMESPACE_FLAGS_ALL)
714 result = "no";
715 else {
716 r = namespace_flags_to_string(u, &s);
717 if (r < 0)
718 return r;
719
720 result = s;
721 }
722
723 print_property(name, "%s", result);
724
725 } else if (streq(name, "MountFlags")) {
726 const char *result;
727
728 result = mount_propagation_flags_to_string(u);
729 if (!result)
730 return -EINVAL;
731
732 print_property(name, "%s", result);
733
734 } else if (STR_IN_SET(name, "CapabilityBoundingSet", "AmbientCapabilities")) {
735 _cleanup_free_ char *s = NULL;
736
737 r = capability_set_to_string_alloc(u, &s);
738 if (r < 0)
739 return r;
740
741 print_property(name, "%s", s);
742
743 } else if ((STR_IN_SET(name, "CPUWeight", "StartupCPUWeight", "IOWeight", "StartupIOWeight") && u == CGROUP_WEIGHT_INVALID) ||
744 (STR_IN_SET(name, "CPUShares", "StartupCPUShares") && u == CGROUP_CPU_SHARES_INVALID) ||
745 (STR_IN_SET(name, "BlockIOWeight", "StartupBlockIOWeight") && u == CGROUP_BLKIO_WEIGHT_INVALID) ||
746 (STR_IN_SET(name, "MemoryCurrent", "TasksCurrent") && u == (uint64_t) -1) ||
747 (endswith(name, "NSec") && u == (uint64_t) -1))
748
749 print_property(name, "%s", "[not set]");
750
751 else if ((STR_IN_SET(name, "MemoryLow", "MemoryHigh", "MemoryMax", "MemorySwapMax", "MemoryLimit") && u == CGROUP_LIMIT_MAX) ||
752 (STR_IN_SET(name, "TasksMax", "DefaultTasksMax") && u == (uint64_t) -1) ||
753 (startswith(name, "Limit") && u == (uint64_t) -1) ||
754 (startswith(name, "DefaultLimit") && u == (uint64_t) -1))
755
756 print_property(name, "%s", "infinity");
757 else
758 print_property(name, "%"PRIu64, u);
759
760 return 1;
761 }
762
763 case SD_BUS_TYPE_INT64: {
764 int64_t i;
765
766 r = sd_bus_message_read_basic(m, type, &i);
767 if (r < 0)
768 return r;
769
770 print_property(name, "%"PRIi64, i);
771
772 return 1;
773 }
774
775 case SD_BUS_TYPE_UINT32: {
776 uint32_t u;
777
778 r = sd_bus_message_read_basic(m, type, &u);
779 if (r < 0)
780 return r;
781
782 if (strstr(name, "UMask") || strstr(name, "Mode"))
783 print_property(name, "%04o", u);
784 else if (streq(name, "UID")) {
785 if (u == UID_INVALID)
786 print_property(name, "%s", "[not set]");
787 else
788 print_property(name, "%"PRIu32, u);
789 } else if (streq(name, "GID")) {
790 if (u == GID_INVALID)
791 print_property(name, "%s", "[not set]");
792 else
793 print_property(name, "%"PRIu32, u);
794 } else
795 print_property(name, "%"PRIu32, u);
796
797 return 1;
798 }
799
800 case SD_BUS_TYPE_INT32: {
801 int32_t i;
802
803 r = sd_bus_message_read_basic(m, type, &i);
804 if (r < 0)
805 return r;
806
807 print_property(name, "%"PRIi32, i);
808 return 1;
809 }
810
811 case SD_BUS_TYPE_DOUBLE: {
812 double d;
813
814 r = sd_bus_message_read_basic(m, type, &d);
815 if (r < 0)
816 return r;
817
818 print_property(name, "%g", d);
819 return 1;
820 }
821
822 case SD_BUS_TYPE_ARRAY:
823 if (streq(contents, "s")) {
824 bool first = true;
825 const char *str;
826
827 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, contents);
828 if (r < 0)
829 return r;
830
831 while ((r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &str)) > 0) {
832 bool good;
833
834 if (first && !value)
835 printf("%s=", name);
836
837 /* This property has multiple space-separated values, so
838 * neither spaces nor newlines can be allowed in a value. */
839 good = str[strcspn(str, " \n")] == '\0';
840
841 printf("%s%s", first ? "" : " ", good ? str : "[unprintable]");
842
843 first = false;
844 }
845 if (r < 0)
846 return r;
847
848 if (first && all && !value)
849 printf("%s=", name);
850 if (!first || all)
851 puts("");
852
853 r = sd_bus_message_exit_container(m);
854 if (r < 0)
855 return r;
856
857 return 1;
858
859 } else if (streq(contents, "y")) {
860 const uint8_t *u;
861 size_t n;
862
863 r = sd_bus_message_read_array(m, SD_BUS_TYPE_BYTE, (const void**) &u, &n);
864 if (r < 0)
865 return r;
866
867 if (all || n > 0) {
868 unsigned int i;
869
870 if (!value)
871 printf("%s=", name);
872
873 for (i = 0; i < n; i++)
874 printf("%02x", u[i]);
875
876 puts("");
877 }
878
879 return 1;
880
881 } else if (streq(contents, "u")) {
882 uint32_t *u;
883 size_t n;
884
885 r = sd_bus_message_read_array(m, SD_BUS_TYPE_UINT32, (const void**) &u, &n);
886 if (r < 0)
887 return r;
888
889 if (all || n > 0) {
890 unsigned int i;
891
892 if (!value)
893 printf("%s=", name);
894
895 for (i = 0; i < n; i++)
896 printf("%08x", u[i]);
897
898 puts("");
899 }
900
901 return 1;
902 }
903
904 break;
905 }
906
907 return 0;
908 }
909
910 int bus_message_print_all_properties(
911 sd_bus_message *m,
912 bus_message_print_t func,
913 char **filter,
914 bool value,
915 bool all,
916 Set **found_properties) {
917
918 int r;
919
920 assert(m);
921
922 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "{sv}");
923 if (r < 0)
924 return r;
925
926 while ((r = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
927 const char *name;
928 const char *contents;
929
930 r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &name);
931 if (r < 0)
932 return r;
933
934 if (found_properties) {
935 r = set_ensure_allocated(found_properties, &string_hash_ops);
936 if (r < 0)
937 return log_oom();
938
939 r = set_put(*found_properties, name);
940 if (r < 0 && r != -EEXIST)
941 return log_oom();
942 }
943
944 if (!filter || strv_find(filter, name)) {
945 r = sd_bus_message_peek_type(m, NULL, &contents);
946 if (r < 0)
947 return r;
948
949 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, contents);
950 if (r < 0)
951 return r;
952
953 if (func)
954 r = func(name, m, value, all);
955 if (!func || r == 0)
956 r = bus_print_property(name, m, value, all);
957 if (r < 0)
958 return r;
959 if (r == 0) {
960 if (all)
961 printf("%s=[unprintable]\n", name);
962 /* skip what we didn't read */
963 r = sd_bus_message_skip(m, contents);
964 if (r < 0)
965 return r;
966 }
967
968 r = sd_bus_message_exit_container(m);
969 if (r < 0)
970 return r;
971 } else {
972 r = sd_bus_message_skip(m, "v");
973 if (r < 0)
974 return r;
975 }
976
977 r = sd_bus_message_exit_container(m);
978 if (r < 0)
979 return r;
980 }
981 if (r < 0)
982 return r;
983
984 r = sd_bus_message_exit_container(m);
985 if (r < 0)
986 return r;
987
988 return 0;
989 }
990
991 int bus_print_all_properties(
992 sd_bus *bus,
993 const char *dest,
994 const char *path,
995 bus_message_print_t func,
996 char **filter,
997 bool value,
998 bool all,
999 Set **found_properties) {
1000
1001 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1002 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1003 int r;
1004
1005 assert(bus);
1006 assert(path);
1007
1008 r = sd_bus_call_method(bus,
1009 dest,
1010 path,
1011 "org.freedesktop.DBus.Properties",
1012 "GetAll",
1013 &error,
1014 &reply,
1015 "s", "");
1016 if (r < 0)
1017 return r;
1018
1019 return bus_message_print_all_properties(reply, func, filter, value, all, found_properties);
1020 }
1021
1022 int bus_map_id128(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
1023 sd_id128_t *p = userdata;
1024 const void *v;
1025 size_t n;
1026 int r;
1027
1028 r = sd_bus_message_read_array(m, SD_BUS_TYPE_BYTE, &v, &n);
1029 if (r < 0)
1030 return r;
1031
1032 if (n == 0)
1033 *p = SD_ID128_NULL;
1034 else if (n == 16)
1035 memcpy((*p).bytes, v, n);
1036 else
1037 return -EINVAL;
1038
1039 return 0;
1040 }
1041
1042 static int map_basic(sd_bus *bus, const char *member, sd_bus_message *m, unsigned flags, sd_bus_error *error, void *userdata) {
1043 char type;
1044 int r;
1045
1046 r = sd_bus_message_peek_type(m, &type, NULL);
1047 if (r < 0)
1048 return r;
1049
1050 switch (type) {
1051
1052 case SD_BUS_TYPE_STRING: {
1053 const char **p = userdata;
1054 const char *s;
1055
1056 r = sd_bus_message_read_basic(m, type, &s);
1057 if (r < 0)
1058 return r;
1059
1060 if (isempty(s))
1061 s = NULL;
1062
1063 if (flags & BUS_MAP_STRDUP)
1064 return free_and_strdup((char **) userdata, s);
1065
1066 *p = s;
1067 return 0;
1068 }
1069
1070 case SD_BUS_TYPE_ARRAY: {
1071 _cleanup_strv_free_ char **l = NULL;
1072 char ***p = userdata;
1073
1074 r = bus_message_read_strv_extend(m, &l);
1075 if (r < 0)
1076 return r;
1077
1078 return strv_free_and_replace(*p, l);
1079 }
1080
1081 case SD_BUS_TYPE_BOOLEAN: {
1082 int b;
1083
1084 r = sd_bus_message_read_basic(m, type, &b);
1085 if (r < 0)
1086 return r;
1087
1088 if (flags & BUS_MAP_BOOLEAN_AS_BOOL)
1089 *(bool*) userdata = b;
1090 else
1091 *(int*) userdata = b;
1092
1093 return 0;
1094 }
1095
1096 case SD_BUS_TYPE_INT32:
1097 case SD_BUS_TYPE_UINT32: {
1098 uint32_t u, *p = userdata;
1099
1100 r = sd_bus_message_read_basic(m, type, &u);
1101 if (r < 0)
1102 return r;
1103
1104 *p = u;
1105 return 0;
1106 }
1107
1108 case SD_BUS_TYPE_INT64:
1109 case SD_BUS_TYPE_UINT64: {
1110 uint64_t t, *p = userdata;
1111
1112 r = sd_bus_message_read_basic(m, type, &t);
1113 if (r < 0)
1114 return r;
1115
1116 *p = t;
1117 return 0;
1118 }
1119
1120 case SD_BUS_TYPE_DOUBLE: {
1121 double d, *p = userdata;
1122
1123 r = sd_bus_message_read_basic(m, type, &d);
1124 if (r < 0)
1125 return r;
1126
1127 *p = d;
1128 return 0;
1129 }}
1130
1131 return -EOPNOTSUPP;
1132 }
1133
1134 int bus_message_map_all_properties(
1135 sd_bus_message *m,
1136 const struct bus_properties_map *map,
1137 unsigned flags,
1138 sd_bus_error *error,
1139 void *userdata) {
1140
1141 int r;
1142
1143 assert(m);
1144 assert(map);
1145
1146 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "{sv}");
1147 if (r < 0)
1148 return r;
1149
1150 while ((r = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
1151 const struct bus_properties_map *prop;
1152 const char *member;
1153 const char *contents;
1154 void *v;
1155 unsigned i;
1156
1157 r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &member);
1158 if (r < 0)
1159 return r;
1160
1161 for (i = 0, prop = NULL; map[i].member; i++)
1162 if (streq(map[i].member, member)) {
1163 prop = &map[i];
1164 break;
1165 }
1166
1167 if (prop) {
1168 r = sd_bus_message_peek_type(m, NULL, &contents);
1169 if (r < 0)
1170 return r;
1171
1172 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, contents);
1173 if (r < 0)
1174 return r;
1175
1176 v = (uint8_t *)userdata + prop->offset;
1177 if (map[i].set)
1178 r = prop->set(sd_bus_message_get_bus(m), member, m, error, v);
1179 else
1180 r = map_basic(sd_bus_message_get_bus(m), member, m, flags, error, v);
1181 if (r < 0)
1182 return r;
1183
1184 r = sd_bus_message_exit_container(m);
1185 if (r < 0)
1186 return r;
1187 } else {
1188 r = sd_bus_message_skip(m, "v");
1189 if (r < 0)
1190 return r;
1191 }
1192
1193 r = sd_bus_message_exit_container(m);
1194 if (r < 0)
1195 return r;
1196 }
1197 if (r < 0)
1198 return r;
1199
1200 return sd_bus_message_exit_container(m);
1201 }
1202
1203 int bus_message_map_properties_changed(
1204 sd_bus_message *m,
1205 const struct bus_properties_map *map,
1206 unsigned flags,
1207 sd_bus_error *error,
1208 void *userdata) {
1209
1210 const char *member;
1211 int r, invalidated, i;
1212
1213 assert(m);
1214 assert(map);
1215
1216 r = bus_message_map_all_properties(m, map, flags, error, userdata);
1217 if (r < 0)
1218 return r;
1219
1220 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "s");
1221 if (r < 0)
1222 return r;
1223
1224 invalidated = 0;
1225 while ((r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &member)) > 0)
1226 for (i = 0; map[i].member; i++)
1227 if (streq(map[i].member, member)) {
1228 ++invalidated;
1229 break;
1230 }
1231 if (r < 0)
1232 return r;
1233
1234 r = sd_bus_message_exit_container(m);
1235 if (r < 0)
1236 return r;
1237
1238 return invalidated;
1239 }
1240
1241 int bus_map_all_properties(
1242 sd_bus *bus,
1243 const char *destination,
1244 const char *path,
1245 const struct bus_properties_map *map,
1246 unsigned flags,
1247 sd_bus_error *error,
1248 sd_bus_message **reply,
1249 void *userdata) {
1250
1251 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
1252 int r;
1253
1254 assert(bus);
1255 assert(destination);
1256 assert(path);
1257 assert(map);
1258 assert(reply || (flags & BUS_MAP_STRDUP));
1259
1260 r = sd_bus_call_method(
1261 bus,
1262 destination,
1263 path,
1264 "org.freedesktop.DBus.Properties",
1265 "GetAll",
1266 error,
1267 &m,
1268 "s", "");
1269 if (r < 0)
1270 return r;
1271
1272 r = bus_message_map_all_properties(m, map, flags, error, userdata);
1273 if (r < 0)
1274 return r;
1275
1276 if (reply)
1277 *reply = sd_bus_message_ref(m);
1278
1279 return r;
1280 }
1281
1282 int bus_connect_transport(BusTransport transport, const char *host, bool user, sd_bus **ret) {
1283 _cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
1284 int r;
1285
1286 assert(transport >= 0);
1287 assert(transport < _BUS_TRANSPORT_MAX);
1288 assert(ret);
1289
1290 assert_return((transport == BUS_TRANSPORT_LOCAL) == !host, -EINVAL);
1291 assert_return(transport == BUS_TRANSPORT_LOCAL || !user, -EOPNOTSUPP);
1292
1293 switch (transport) {
1294
1295 case BUS_TRANSPORT_LOCAL:
1296 if (user)
1297 r = sd_bus_default_user(&bus);
1298 else {
1299 if (sd_booted() <= 0) {
1300 /* Print a friendly message when the local system is actually not running systemd as PID 1. */
1301 log_error("System has not been booted with systemd as init system (PID 1). Can't operate.");
1302
1303 return -EHOSTDOWN;
1304 }
1305 r = sd_bus_default_system(&bus);
1306 }
1307 break;
1308
1309 case BUS_TRANSPORT_REMOTE:
1310 r = sd_bus_open_system_remote(&bus, host);
1311 break;
1312
1313 case BUS_TRANSPORT_MACHINE:
1314 r = sd_bus_open_system_machine(&bus, host);
1315 break;
1316
1317 default:
1318 assert_not_reached("Hmm, unknown transport type.");
1319 }
1320 if (r < 0)
1321 return r;
1322
1323 r = sd_bus_set_exit_on_disconnect(bus, true);
1324 if (r < 0)
1325 return r;
1326
1327 *ret = TAKE_PTR(bus);
1328
1329 return 0;
1330 }
1331
1332 int bus_connect_transport_systemd(BusTransport transport, const char *host, bool user, sd_bus **bus) {
1333 int r;
1334
1335 assert(transport >= 0);
1336 assert(transport < _BUS_TRANSPORT_MAX);
1337 assert(bus);
1338
1339 assert_return((transport == BUS_TRANSPORT_LOCAL) == !host, -EINVAL);
1340 assert_return(transport == BUS_TRANSPORT_LOCAL || !user, -EOPNOTSUPP);
1341
1342 switch (transport) {
1343
1344 case BUS_TRANSPORT_LOCAL:
1345 if (user)
1346 r = bus_connect_user_systemd(bus);
1347 else {
1348 if (sd_booted() <= 0) {
1349 /* Print a friendly message when the local system is actually not running systemd as PID 1. */
1350 log_error("System has not been booted with systemd as init system (PID 1). Can't operate.");
1351
1352 return -EHOSTDOWN;
1353 }
1354 r = bus_connect_system_systemd(bus);
1355 }
1356 break;
1357
1358 case BUS_TRANSPORT_REMOTE:
1359 r = sd_bus_open_system_remote(bus, host);
1360 break;
1361
1362 case BUS_TRANSPORT_MACHINE:
1363 r = sd_bus_open_system_machine(bus, host);
1364 break;
1365
1366 default:
1367 assert_not_reached("Hmm, unknown transport type.");
1368 }
1369
1370 return r;
1371 }
1372
1373 int bus_property_get_bool(
1374 sd_bus *bus,
1375 const char *path,
1376 const char *interface,
1377 const char *property,
1378 sd_bus_message *reply,
1379 void *userdata,
1380 sd_bus_error *error) {
1381
1382 int b = *(bool*) userdata;
1383
1384 return sd_bus_message_append_basic(reply, 'b', &b);
1385 }
1386
1387 int bus_property_set_bool(
1388 sd_bus *bus,
1389 const char *path,
1390 const char *interface,
1391 const char *property,
1392 sd_bus_message *value,
1393 void *userdata,
1394 sd_bus_error *error) {
1395
1396 int b, r;
1397
1398 r = sd_bus_message_read(value, "b", &b);
1399 if (r < 0)
1400 return r;
1401
1402 *(bool*) userdata = b;
1403 return 0;
1404 }
1405
1406 int bus_property_get_id128(
1407 sd_bus *bus,
1408 const char *path,
1409 const char *interface,
1410 const char *property,
1411 sd_bus_message *reply,
1412 void *userdata,
1413 sd_bus_error *error) {
1414
1415 sd_id128_t *id = userdata;
1416
1417 if (sd_id128_is_null(*id)) /* Add an empty array if the ID is zero */
1418 return sd_bus_message_append(reply, "ay", 0);
1419 else
1420 return sd_bus_message_append_array(reply, 'y', id->bytes, 16);
1421 }
1422
1423 #if __SIZEOF_SIZE_T__ != 8
1424 int bus_property_get_size(
1425 sd_bus *bus,
1426 const char *path,
1427 const char *interface,
1428 const char *property,
1429 sd_bus_message *reply,
1430 void *userdata,
1431 sd_bus_error *error) {
1432
1433 uint64_t sz = *(size_t*) userdata;
1434
1435 return sd_bus_message_append_basic(reply, 't', &sz);
1436 }
1437 #endif
1438
1439 #if __SIZEOF_LONG__ != 8
1440 int bus_property_get_long(
1441 sd_bus *bus,
1442 const char *path,
1443 const char *interface,
1444 const char *property,
1445 sd_bus_message *reply,
1446 void *userdata,
1447 sd_bus_error *error) {
1448
1449 int64_t l = *(long*) userdata;
1450
1451 return sd_bus_message_append_basic(reply, 'x', &l);
1452 }
1453
1454 int bus_property_get_ulong(
1455 sd_bus *bus,
1456 const char *path,
1457 const char *interface,
1458 const char *property,
1459 sd_bus_message *reply,
1460 void *userdata,
1461 sd_bus_error *error) {
1462
1463 uint64_t ul = *(unsigned long*) userdata;
1464
1465 return sd_bus_message_append_basic(reply, 't', &ul);
1466 }
1467 #endif
1468
1469 int bus_log_parse_error(int r) {
1470 return log_error_errno(r, "Failed to parse bus message: %m");
1471 }
1472
1473 int bus_log_create_error(int r) {
1474 return log_error_errno(r, "Failed to create bus message: %m");
1475 }
1476
1477 /**
1478 * bus_path_encode_unique() - encode unique object path
1479 * @b: bus connection or NULL
1480 * @prefix: object path prefix
1481 * @sender_id: unique-name of client, or NULL
1482 * @external_id: external ID to be chosen by client, or NULL
1483 * @ret_path: storage for encoded object path pointer
1484 *
1485 * Whenever we provide a bus API that allows clients to create and manage
1486 * server-side objects, we need to provide a unique name for these objects. If
1487 * we let the server choose the name, we suffer from a race condition: If a
1488 * client creates an object asynchronously, it cannot destroy that object until
1489 * it received the method reply. It cannot know the name of the new object,
1490 * thus, it cannot destroy it. Furthermore, it enforces a round-trip.
1491 *
1492 * Therefore, many APIs allow the client to choose the unique name for newly
1493 * created objects. There're two problems to solve, though:
1494 * 1) Object names are usually defined via dbus object paths, which are
1495 * usually globally namespaced. Therefore, multiple clients must be able
1496 * to choose unique object names without interference.
1497 * 2) If multiple libraries share the same bus connection, they must be
1498 * able to choose unique object names without interference.
1499 * The first problem is solved easily by prefixing a name with the
1500 * unique-bus-name of a connection. The server side must enforce this and
1501 * reject any other name. The second problem is solved by providing unique
1502 * suffixes from within sd-bus.
1503 *
1504 * This helper allows clients to create unique object-paths. It uses the
1505 * template '/prefix/sender_id/external_id' and returns the new path in
1506 * @ret_path (must be freed by the caller).
1507 * If @sender_id is NULL, the unique-name of @b is used. If @external_id is
1508 * NULL, this function allocates a unique suffix via @b (by requesting a new
1509 * cookie). If both @sender_id and @external_id are given, @b can be passed as
1510 * NULL.
1511 *
1512 * Returns: 0 on success, negative error code on failure.
1513 */
1514 int bus_path_encode_unique(sd_bus *b, const char *prefix, const char *sender_id, const char *external_id, char **ret_path) {
1515 _cleanup_free_ char *sender_label = NULL, *external_label = NULL;
1516 char external_buf[DECIMAL_STR_MAX(uint64_t)], *p;
1517 int r;
1518
1519 assert_return(b || (sender_id && external_id), -EINVAL);
1520 assert_return(object_path_is_valid(prefix), -EINVAL);
1521 assert_return(ret_path, -EINVAL);
1522
1523 if (!sender_id) {
1524 r = sd_bus_get_unique_name(b, &sender_id);
1525 if (r < 0)
1526 return r;
1527 }
1528
1529 if (!external_id) {
1530 xsprintf(external_buf, "%"PRIu64, ++b->cookie);
1531 external_id = external_buf;
1532 }
1533
1534 sender_label = bus_label_escape(sender_id);
1535 if (!sender_label)
1536 return -ENOMEM;
1537
1538 external_label = bus_label_escape(external_id);
1539 if (!external_label)
1540 return -ENOMEM;
1541
1542 p = strjoin(prefix, "/", sender_label, "/", external_label);
1543 if (!p)
1544 return -ENOMEM;
1545
1546 *ret_path = p;
1547 return 0;
1548 }
1549
1550 /**
1551 * bus_path_decode_unique() - decode unique object path
1552 * @path: object path to decode
1553 * @prefix: object path prefix
1554 * @ret_sender: output parameter for sender-id label
1555 * @ret_external: output parameter for external-id label
1556 *
1557 * This does the reverse of bus_path_encode_unique() (see its description for
1558 * details). Both trailing labels, sender-id and external-id, are unescaped and
1559 * returned in the given output parameters (the caller must free them).
1560 *
1561 * Note that this function returns 0 if the path does not match the template
1562 * (see bus_path_encode_unique()), 1 if it matched.
1563 *
1564 * Returns: Negative error code on failure, 0 if the given object path does not
1565 * match the template (return parameters are set to NULL), 1 if it was
1566 * parsed successfully (return parameters contain allocated labels).
1567 */
1568 int bus_path_decode_unique(const char *path, const char *prefix, char **ret_sender, char **ret_external) {
1569 const char *p, *q;
1570 char *sender, *external;
1571
1572 assert(object_path_is_valid(path));
1573 assert(object_path_is_valid(prefix));
1574 assert(ret_sender);
1575 assert(ret_external);
1576
1577 p = object_path_startswith(path, prefix);
1578 if (!p) {
1579 *ret_sender = NULL;
1580 *ret_external = NULL;
1581 return 0;
1582 }
1583
1584 q = strchr(p, '/');
1585 if (!q) {
1586 *ret_sender = NULL;
1587 *ret_external = NULL;
1588 return 0;
1589 }
1590
1591 sender = bus_label_unescape_n(p, q - p);
1592 external = bus_label_unescape(q + 1);
1593 if (!sender || !external) {
1594 free(sender);
1595 free(external);
1596 return -ENOMEM;
1597 }
1598
1599 *ret_sender = sender;
1600 *ret_external = external;
1601 return 1;
1602 }
1603
1604 int bus_property_get_rlimit(
1605 sd_bus *bus,
1606 const char *path,
1607 const char *interface,
1608 const char *property,
1609 sd_bus_message *reply,
1610 void *userdata,
1611 sd_bus_error *error) {
1612
1613 const char *is_soft;
1614 struct rlimit *rl;
1615 uint64_t u;
1616 rlim_t x;
1617
1618 assert(bus);
1619 assert(reply);
1620 assert(userdata);
1621
1622 is_soft = endswith(property, "Soft");
1623
1624 rl = *(struct rlimit**) userdata;
1625 if (rl)
1626 x = is_soft ? rl->rlim_cur : rl->rlim_max;
1627 else {
1628 struct rlimit buf = {};
1629 const char *s, *p;
1630 int z;
1631
1632 /* Chop off "Soft" suffix */
1633 s = is_soft ? strndupa(property, is_soft - property) : property;
1634
1635 /* Skip over any prefix, such as "Default" */
1636 assert_se(p = strstr(s, "Limit"));
1637
1638 z = rlimit_from_string(p + 5);
1639 assert(z >= 0);
1640
1641 (void) getrlimit(z, &buf);
1642 x = is_soft ? buf.rlim_cur : buf.rlim_max;
1643 }
1644
1645 /* rlim_t might have different sizes, let's map RLIMIT_INFINITY to (uint64_t) -1, so that it is the same on all
1646 * archs */
1647 u = x == RLIM_INFINITY ? (uint64_t) -1 : (uint64_t) x;
1648
1649 return sd_bus_message_append(reply, "t", u);
1650 }
1651
1652 int bus_track_add_name_many(sd_bus_track *t, char **l) {
1653 int r = 0;
1654 char **i;
1655
1656 assert(t);
1657
1658 /* Continues adding after failure, and returns the first failure. */
1659
1660 STRV_FOREACH(i, l) {
1661 int k;
1662
1663 k = sd_bus_track_add_name(t, *i);
1664 if (k < 0 && r >= 0)
1665 r = k;
1666 }
1667
1668 return r;
1669 }
1670
1671 int bus_open_system_watch_bind_with_description(sd_bus **ret, const char *description) {
1672 _cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
1673 const char *e;
1674 int r;
1675
1676 assert(ret);
1677
1678 /* Match like sd_bus_open_system(), but with the "watch_bind" feature and the Connected() signal turned on. */
1679
1680 r = sd_bus_new(&bus);
1681 if (r < 0)
1682 return r;
1683
1684 if (description) {
1685 r = sd_bus_set_description(bus, description);
1686 if (r < 0)
1687 return r;
1688 }
1689
1690 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1691 if (!e)
1692 e = DEFAULT_SYSTEM_BUS_ADDRESS;
1693
1694 r = sd_bus_set_address(bus, e);
1695 if (r < 0)
1696 return r;
1697
1698 r = sd_bus_set_bus_client(bus, true);
1699 if (r < 0)
1700 return r;
1701
1702 r = sd_bus_set_trusted(bus, true);
1703 if (r < 0)
1704 return r;
1705
1706 r = sd_bus_negotiate_creds(bus, true, SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_EFFECTIVE_CAPS);
1707 if (r < 0)
1708 return r;
1709
1710 r = sd_bus_set_watch_bind(bus, true);
1711 if (r < 0)
1712 return r;
1713
1714 r = sd_bus_set_connected_signal(bus, true);
1715 if (r < 0)
1716 return r;
1717
1718 r = sd_bus_start(bus);
1719 if (r < 0)
1720 return r;
1721
1722 *ret = TAKE_PTR(bus);
1723
1724 return 0;
1725 }
1726
1727 struct request_name_data {
1728 unsigned n_ref;
1729
1730 const char *name;
1731 uint64_t flags;
1732 void *userdata;
1733 };
1734
1735 static void request_name_destroy_callback(void *userdata) {
1736 struct request_name_data *data = userdata;
1737
1738 assert(data);
1739 assert(data->n_ref > 0);
1740
1741 log_debug("%s n_ref=%u", __func__, data->n_ref);
1742
1743 data->n_ref--;
1744 if (data->n_ref == 0)
1745 free(data);
1746 }
1747
1748 static int reload_dbus_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
1749 struct request_name_data *data = userdata;
1750 const sd_bus_error *e;
1751 int r;
1752
1753 assert(data);
1754 assert(data->name);
1755 assert(data->n_ref > 0);
1756
1757 e = sd_bus_message_get_error(m);
1758 if (e) {
1759 log_error_errno(sd_bus_error_get_errno(e), "Failed to reload DBus configuration: %s", e->message);
1760 return 1;
1761 }
1762
1763 /* Here, use the default request name handler to avoid an infinite loop of reloading and requesting. */
1764 r = sd_bus_request_name_async(sd_bus_message_get_bus(m), NULL, data->name, data->flags, NULL, data->userdata);
1765 if (r < 0)
1766 log_error_errno(r, "Failed to request name: %m");
1767
1768 return 1;
1769 }
1770
1771 static int request_name_handler_may_reload_dbus(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
1772 struct request_name_data *data = userdata;
1773 uint32_t ret;
1774 int r;
1775
1776 assert(m);
1777 assert(data);
1778
1779 if (sd_bus_message_is_method_error(m, NULL)) {
1780 const sd_bus_error *e = sd_bus_message_get_error(m);
1781 _cleanup_(sd_bus_slot_unrefp) sd_bus_slot *slot = NULL;
1782
1783 if (!sd_bus_error_has_name(e, SD_BUS_ERROR_ACCESS_DENIED)) {
1784 log_debug_errno(sd_bus_error_get_errno(e),
1785 "Unable to request name, failing connection: %s",
1786 e->message);
1787
1788 bus_enter_closing(sd_bus_message_get_bus(m));
1789 return 1;
1790 }
1791
1792 log_debug_errno(sd_bus_error_get_errno(e),
1793 "Unable to request name, will retry after reloading DBus configuration: %s",
1794 e->message);
1795
1796 /* If a service enables DynamicUser= and dbus.service started before the dynamic user is realized,
1797 * then the DBus policy about the service has not been enabled yet. So, let's try to reload DBus
1798 * configuration, and after that request the name again. Note that it seems that no privileges are
1799 * necessary to call the following method. */
1800
1801 r = sd_bus_call_method_async(
1802 sd_bus_message_get_bus(m),
1803 &slot,
1804 "org.freedesktop.DBus",
1805 "/org/freedesktop/DBus",
1806 "org.freedesktop.DBus",
1807 "ReloadConfig",
1808 reload_dbus_handler,
1809 data, NULL);
1810 if (r < 0) {
1811 log_error_errno(r, "Failed to reload DBus configuration: %m");
1812 bus_enter_closing(sd_bus_message_get_bus(m));
1813 return 1;
1814 }
1815
1816 data->n_ref ++;
1817 assert_se(sd_bus_slot_set_destroy_callback(slot, request_name_destroy_callback) >= 0);
1818
1819 r = sd_bus_slot_set_floating(slot, true);
1820 if (r < 0)
1821 return r;
1822
1823 return 1;
1824 }
1825
1826 r = sd_bus_message_read(m, "u", &ret);
1827 if (r < 0)
1828 return r;
1829
1830 switch (ret) {
1831
1832 case BUS_NAME_ALREADY_OWNER:
1833 log_debug("Already owner of requested service name, ignoring.");
1834 return 1;
1835
1836 case BUS_NAME_IN_QUEUE:
1837 log_debug("In queue for requested service name.");
1838 return 1;
1839
1840 case BUS_NAME_PRIMARY_OWNER:
1841 log_debug("Successfully acquired requested service name.");
1842 return 1;
1843
1844 case BUS_NAME_EXISTS:
1845 log_debug("Requested service name already owned, failing connection.");
1846 bus_enter_closing(sd_bus_message_get_bus(m));
1847 return 1;
1848 }
1849
1850 log_debug("Unexpected response from RequestName(), failing connection.");
1851 bus_enter_closing(sd_bus_message_get_bus(m));
1852 return 1;
1853 }
1854
1855 int bus_request_name_async_may_reload_dbus(sd_bus *bus, sd_bus_slot **ret_slot, const char *name, uint64_t flags, void *userdata) {
1856 _cleanup_free_ struct request_name_data *data = NULL;
1857 _cleanup_(sd_bus_slot_unrefp) sd_bus_slot *slot = NULL;
1858 int r;
1859
1860 data = new(struct request_name_data, 1);
1861 if (!data)
1862 return -ENOMEM;
1863
1864 *data = (struct request_name_data) {
1865 .n_ref = 1,
1866 .name = name,
1867 .flags = flags,
1868 .userdata = userdata,
1869 };
1870
1871 r = sd_bus_request_name_async(bus, &slot, name, flags, request_name_handler_may_reload_dbus, data);
1872 if (r < 0)
1873 return r;
1874
1875 assert_se(sd_bus_slot_set_destroy_callback(slot, request_name_destroy_callback) >= 0);
1876 TAKE_PTR(data);
1877
1878 if (ret_slot)
1879 *ret_slot = TAKE_PTR(slot);
1880 else {
1881 r = sd_bus_slot_set_floating(slot, true);
1882 if (r < 0)
1883 return r;
1884 }
1885
1886 return 0;
1887 }
1888
1889 int bus_reply_pair_array(sd_bus_message *m, char **l) {
1890 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1891 char **k, **v;
1892 int r;
1893
1894 assert(m);
1895
1896 /* Reply to the specified message with a message containing a dictionary put together from the specified
1897 * strv */
1898
1899 r = sd_bus_message_new_method_return(m, &reply);
1900 if (r < 0)
1901 return r;
1902
1903 r = sd_bus_message_open_container(reply, 'a', "{ss}");
1904 if (r < 0)
1905 return r;
1906
1907 STRV_FOREACH_PAIR(k, v, l) {
1908 r = sd_bus_message_append(reply, "{ss}", *k, *v);
1909 if (r < 0)
1910 return r;
1911 }
1912
1913 r = sd_bus_message_close_container(reply);
1914 if (r < 0)
1915 return r;
1916
1917 return sd_bus_send(NULL, reply, NULL);
1918 }
Unnamed repository; edit this file 'description' to name the repository.