]> git.proxmox.com Git - systemd.git/blob - src/libsystemd/sd-bus/sd-bus.c
projects / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
New upstream version 236
[systemd.git] / src / libsystemd / sd-bus / sd-bus.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2 /***
3 This file is part of systemd.
4
5 Copyright 2013 Lennart Poettering
6
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
11
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
16
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
19 ***/
20
21 #include <endian.h>
22 #include <netdb.h>
23 #include <poll.h>
24 #include <pthread.h>
25 #include <stdlib.h>
26 #include <sys/mman.h>
27 #include <unistd.h>
28
29 #include "sd-bus.h"
30
31 #include "alloc-util.h"
32 #include "bus-container.h"
33 #include "bus-control.h"
34 #include "bus-internal.h"
35 #include "bus-kernel.h"
36 #include "bus-label.h"
37 #include "bus-message.h"
38 #include "bus-objects.h"
39 #include "bus-protocol.h"
40 #include "bus-slot.h"
41 #include "bus-socket.h"
42 #include "bus-track.h"
43 #include "bus-type.h"
44 #include "bus-util.h"
45 #include "cgroup-util.h"
46 #include "def.h"
47 #include "fd-util.h"
48 #include "hexdecoct.h"
49 #include "hostname-util.h"
50 #include "macro.h"
51 #include "missing.h"
52 #include "parse-util.h"
53 #include "string-util.h"
54 #include "strv.h"
55 #include "util.h"
56
57 #define log_debug_bus_message(m) \
58 do { \
59 sd_bus_message *_mm = (m); \
60 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error-name=%s error-message=%s", \
61 bus_message_type_to_string(_mm->header->type), \
62 strna(sd_bus_message_get_sender(_mm)), \
63 strna(sd_bus_message_get_destination(_mm)), \
64 strna(sd_bus_message_get_path(_mm)), \
65 strna(sd_bus_message_get_interface(_mm)), \
66 strna(sd_bus_message_get_member(_mm)), \
67 BUS_MESSAGE_COOKIE(_mm), \
68 _mm->reply_cookie, \
69 strna(_mm->error.name), \
70 strna(_mm->error.message)); \
71 } while (false)
72
73 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
74 static int attach_io_events(sd_bus *b);
75 static void detach_io_events(sd_bus *b);
76
77 static thread_local sd_bus *default_system_bus = NULL;
78 static thread_local sd_bus *default_user_bus = NULL;
79 static thread_local sd_bus *default_starter_bus = NULL;
80
81 static void bus_close_fds(sd_bus *b) {
82 assert(b);
83
84 detach_io_events(b);
85
86 if (b->input_fd != b->output_fd)
87 safe_close(b->output_fd);
88 b->output_fd = b->input_fd = safe_close(b->input_fd);
89 }
90
91 static void bus_reset_queues(sd_bus *b) {
92 assert(b);
93
94 while (b->rqueue_size > 0)
95 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
96
97 b->rqueue = mfree(b->rqueue);
98 b->rqueue_allocated = 0;
99
100 while (b->wqueue_size > 0)
101 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
102
103 b->wqueue = mfree(b->wqueue);
104 b->wqueue_allocated = 0;
105 }
106
107 static void bus_free(sd_bus *b) {
108 sd_bus_slot *s;
109
110 assert(b);
111 assert(!b->track_queue);
112 assert(!b->tracks);
113
114 b->state = BUS_CLOSED;
115
116 sd_bus_detach_event(b);
117
118 while ((s = b->slots)) {
119 /* At this point only floating slots can still be
120 * around, because the non-floating ones keep a
121 * reference to the bus, and we thus couldn't be
122 * destructing right now... We forcibly disconnect the
123 * slots here, so that they still can be referenced by
124 * apps, but are dead. */
125
126 assert(s->floating);
127 bus_slot_disconnect(s);
128 sd_bus_slot_unref(s);
129 }
130
131 if (b->default_bus_ptr)
132 *b->default_bus_ptr = NULL;
133
134 bus_close_fds(b);
135
136 free(b->label);
137 free(b->rbuffer);
138 free(b->unique_name);
139 free(b->auth_buffer);
140 free(b->address);
141 free(b->machine);
142 free(b->cgroup_root);
143 free(b->description);
144
145 free(b->exec_path);
146 strv_free(b->exec_argv);
147
148 close_many(b->fds, b->n_fds);
149 free(b->fds);
150
151 bus_reset_queues(b);
152
153 ordered_hashmap_free_free(b->reply_callbacks);
154 prioq_free(b->reply_callbacks_prioq);
155
156 assert(b->match_callbacks.type == BUS_MATCH_ROOT);
157 bus_match_free(&b->match_callbacks);
158
159 hashmap_free_free(b->vtable_methods);
160 hashmap_free_free(b->vtable_properties);
161
162 assert(hashmap_isempty(b->nodes));
163 hashmap_free(b->nodes);
164
165 bus_flush_memfd(b);
166
167 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
168
169 free(b);
170 }
171
172 _public_ int sd_bus_new(sd_bus **ret) {
173 sd_bus *r;
174
175 assert_return(ret, -EINVAL);
176
177 r = new0(sd_bus, 1);
178 if (!r)
179 return -ENOMEM;
180
181 r->n_ref = REFCNT_INIT;
182 r->input_fd = r->output_fd = -1;
183 r->message_version = 1;
184 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
185 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
186 r->attach_flags |= KDBUS_ATTACH_NAMES;
187 r->original_pid = getpid_cached();
188
189 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
190
191 /* We guarantee that wqueue always has space for at least one
192 * entry */
193 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
194 free(r);
195 return -ENOMEM;
196 }
197
198 *ret = r;
199 return 0;
200 }
201
202 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
203 char *a;
204
205 assert_return(bus, -EINVAL);
206 assert_return(bus->state == BUS_UNSET, -EPERM);
207 assert_return(address, -EINVAL);
208 assert_return(!bus_pid_changed(bus), -ECHILD);
209
210 a = strdup(address);
211 if (!a)
212 return -ENOMEM;
213
214 free(bus->address);
215 bus->address = a;
216
217 return 0;
218 }
219
220 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
221 assert_return(bus, -EINVAL);
222 assert_return(bus->state == BUS_UNSET, -EPERM);
223 assert_return(input_fd >= 0, -EBADF);
224 assert_return(output_fd >= 0, -EBADF);
225 assert_return(!bus_pid_changed(bus), -ECHILD);
226
227 bus->input_fd = input_fd;
228 bus->output_fd = output_fd;
229 return 0;
230 }
231
232 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
233 char *p, **a;
234
235 assert_return(bus, -EINVAL);
236 assert_return(bus->state == BUS_UNSET, -EPERM);
237 assert_return(path, -EINVAL);
238 assert_return(!strv_isempty(argv), -EINVAL);
239 assert_return(!bus_pid_changed(bus), -ECHILD);
240
241 p = strdup(path);
242 if (!p)
243 return -ENOMEM;
244
245 a = strv_copy(argv);
246 if (!a) {
247 free(p);
248 return -ENOMEM;
249 }
250
251 free(bus->exec_path);
252 strv_free(bus->exec_argv);
253
254 bus->exec_path = p;
255 bus->exec_argv = a;
256
257 return 0;
258 }
259
260 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
261 assert_return(bus, -EINVAL);
262 assert_return(bus->state == BUS_UNSET, -EPERM);
263 assert_return(!bus_pid_changed(bus), -ECHILD);
264
265 bus->bus_client = !!b;
266 return 0;
267 }
268
269 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
270 assert_return(bus, -EINVAL);
271 assert_return(bus->state == BUS_UNSET, -EPERM);
272 assert_return(!bus_pid_changed(bus), -ECHILD);
273
274 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
275 return 0;
276 }
277
278 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
279 assert_return(bus, -EINVAL);
280 assert_return(bus->state == BUS_UNSET, -EPERM);
281 assert_return(!bus_pid_changed(bus), -ECHILD);
282
283 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
284 return 0;
285 }
286
287 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
288 uint64_t new_flags;
289 assert_return(bus, -EINVAL);
290 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
291 assert_return(!bus_pid_changed(bus), -ECHILD);
292
293 new_flags = bus->attach_flags;
294 SET_FLAG(new_flags, KDBUS_ATTACH_TIMESTAMP, b);
295
296 if (bus->attach_flags == new_flags)
297 return 0;
298
299 bus->attach_flags = new_flags;
300
301 return 0;
302 }
303
304 _public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) {
305 uint64_t new_flags;
306
307 assert_return(bus, -EINVAL);
308 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
309 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
310 assert_return(!bus_pid_changed(bus), -ECHILD);
311
312 SET_FLAG(bus->creds_mask, mask, b);
313
314 /* The well knowns we need unconditionally, so that matches can work */
315 bus->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
316
317 /* Make sure we don't lose the timestamp flag */
318 new_flags = (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) | attach_flags_to_kdbus(bus->creds_mask);
319 if (bus->attach_flags == new_flags)
320 return 0;
321
322 bus->attach_flags = new_flags;
323
324 return 0;
325 }
326
327 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
328 assert_return(bus, -EINVAL);
329 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
330 assert_return(bus->state == BUS_UNSET, -EPERM);
331 assert_return(!bus_pid_changed(bus), -ECHILD);
332
333 bus->is_server = !!b;
334 bus->server_id = server_id;
335 return 0;
336 }
337
338 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
339 assert_return(bus, -EINVAL);
340 assert_return(bus->state == BUS_UNSET, -EPERM);
341 assert_return(!bus_pid_changed(bus), -ECHILD);
342
343 bus->anonymous_auth = !!b;
344 return 0;
345 }
346
347 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
348 assert_return(bus, -EINVAL);
349 assert_return(bus->state == BUS_UNSET, -EPERM);
350 assert_return(!bus_pid_changed(bus), -ECHILD);
351
352 bus->trusted = !!b;
353 return 0;
354 }
355
356 _public_ int sd_bus_set_description(sd_bus *bus, const char *description) {
357 assert_return(bus, -EINVAL);
358 assert_return(bus->state == BUS_UNSET, -EPERM);
359 assert_return(!bus_pid_changed(bus), -ECHILD);
360
361 return free_and_strdup(&bus->description, description);
362 }
363
364 _public_ int sd_bus_set_allow_interactive_authorization(sd_bus *bus, int b) {
365 assert_return(bus, -EINVAL);
366 assert_return(!bus_pid_changed(bus), -ECHILD);
367
368 bus->allow_interactive_authorization = !!b;
369 return 0;
370 }
371
372 _public_ int sd_bus_get_allow_interactive_authorization(sd_bus *bus) {
373 assert_return(bus, -EINVAL);
374 assert_return(!bus_pid_changed(bus), -ECHILD);
375
376 return bus->allow_interactive_authorization;
377 }
378
379 static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
380 const char *s;
381 sd_bus *bus;
382 int r;
383
384 assert(reply);
385 bus = reply->bus;
386 assert(bus);
387 assert(IN_SET(bus->state, BUS_HELLO, BUS_CLOSING));
388
389 r = sd_bus_message_get_errno(reply);
390 if (r > 0)
391 return -r;
392
393 r = sd_bus_message_read(reply, "s", &s);
394 if (r < 0)
395 return r;
396
397 if (!service_name_is_valid(s) || s[0] != ':')
398 return -EBADMSG;
399
400 bus->unique_name = strdup(s);
401 if (!bus->unique_name)
402 return -ENOMEM;
403
404 if (bus->state == BUS_HELLO)
405 bus->state = BUS_RUNNING;
406
407 return 1;
408 }
409
410 static int bus_send_hello(sd_bus *bus) {
411 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
412 int r;
413
414 assert(bus);
415
416 if (!bus->bus_client)
417 return 0;
418
419 r = sd_bus_message_new_method_call(
420 bus,
421 &m,
422 "org.freedesktop.DBus",
423 "/org/freedesktop/DBus",
424 "org.freedesktop.DBus",
425 "Hello");
426 if (r < 0)
427 return r;
428
429 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
430 }
431
432 int bus_start_running(sd_bus *bus) {
433 assert(bus);
434
435 if (bus->bus_client) {
436 bus->state = BUS_HELLO;
437 return 1;
438 }
439
440 bus->state = BUS_RUNNING;
441 return 1;
442 }
443
444 static int parse_address_key(const char **p, const char *key, char **value) {
445 size_t l, n = 0, allocated = 0;
446 const char *a;
447 char *r = NULL;
448
449 assert(p);
450 assert(*p);
451 assert(value);
452
453 if (key) {
454 l = strlen(key);
455 if (strncmp(*p, key, l) != 0)
456 return 0;
457
458 if ((*p)[l] != '=')
459 return 0;
460
461 if (*value)
462 return -EINVAL;
463
464 a = *p + l + 1;
465 } else
466 a = *p;
467
468 while (!IN_SET(*a, ';', ',', 0)) {
469 char c;
470
471 if (*a == '%') {
472 int x, y;
473
474 x = unhexchar(a[1]);
475 if (x < 0) {
476 free(r);
477 return x;
478 }
479
480 y = unhexchar(a[2]);
481 if (y < 0) {
482 free(r);
483 return y;
484 }
485
486 c = (char) ((x << 4) | y);
487 a += 3;
488 } else {
489 c = *a;
490 a++;
491 }
492
493 if (!GREEDY_REALLOC(r, allocated, n + 2))
494 return -ENOMEM;
495
496 r[n++] = c;
497 }
498
499 if (!r) {
500 r = strdup("");
501 if (!r)
502 return -ENOMEM;
503 } else
504 r[n] = 0;
505
506 if (*a == ',')
507 a++;
508
509 *p = a;
510
511 free(*value);
512 *value = r;
513
514 return 1;
515 }
516
517 static void skip_address_key(const char **p) {
518 assert(p);
519 assert(*p);
520
521 *p += strcspn(*p, ",");
522
523 if (**p == ',')
524 (*p)++;
525 }
526
527 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
528 _cleanup_free_ char *path = NULL, *abstract = NULL;
529 size_t l;
530 int r;
531
532 assert(b);
533 assert(p);
534 assert(*p);
535 assert(guid);
536
537 while (!IN_SET(**p, 0, ';')) {
538 r = parse_address_key(p, "guid", guid);
539 if (r < 0)
540 return r;
541 else if (r > 0)
542 continue;
543
544 r = parse_address_key(p, "path", &path);
545 if (r < 0)
546 return r;
547 else if (r > 0)
548 continue;
549
550 r = parse_address_key(p, "abstract", &abstract);
551 if (r < 0)
552 return r;
553 else if (r > 0)
554 continue;
555
556 skip_address_key(p);
557 }
558
559 if (!path && !abstract)
560 return -EINVAL;
561
562 if (path && abstract)
563 return -EINVAL;
564
565 if (path) {
566 l = strlen(path);
567 if (l > sizeof(b->sockaddr.un.sun_path))
568 return -E2BIG;
569
570 b->sockaddr.un.sun_family = AF_UNIX;
571 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
572 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
573 } else if (abstract) {
574 l = strlen(abstract);
575 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
576 return -E2BIG;
577
578 b->sockaddr.un.sun_family = AF_UNIX;
579 b->sockaddr.un.sun_path[0] = 0;
580 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
581 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
582 }
583
584 b->is_local = true;
585
586 return 0;
587 }
588
589 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
590 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
591 int r;
592 struct addrinfo *result, hints = {
593 .ai_socktype = SOCK_STREAM,
594 .ai_flags = AI_ADDRCONFIG,
595 };
596
597 assert(b);
598 assert(p);
599 assert(*p);
600 assert(guid);
601
602 while (!IN_SET(**p, 0, ';')) {
603 r = parse_address_key(p, "guid", guid);
604 if (r < 0)
605 return r;
606 else if (r > 0)
607 continue;
608
609 r = parse_address_key(p, "host", &host);
610 if (r < 0)
611 return r;
612 else if (r > 0)
613 continue;
614
615 r = parse_address_key(p, "port", &port);
616 if (r < 0)
617 return r;
618 else if (r > 0)
619 continue;
620
621 r = parse_address_key(p, "family", &family);
622 if (r < 0)
623 return r;
624 else if (r > 0)
625 continue;
626
627 skip_address_key(p);
628 }
629
630 if (!host || !port)
631 return -EINVAL;
632
633 if (family) {
634 if (streq(family, "ipv4"))
635 hints.ai_family = AF_INET;
636 else if (streq(family, "ipv6"))
637 hints.ai_family = AF_INET6;
638 else
639 return -EINVAL;
640 }
641
642 r = getaddrinfo(host, port, &hints, &result);
643 if (r == EAI_SYSTEM)
644 return -errno;
645 else if (r != 0)
646 return -EADDRNOTAVAIL;
647
648 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
649 b->sockaddr_size = result->ai_addrlen;
650
651 freeaddrinfo(result);
652
653 b->is_local = false;
654
655 return 0;
656 }
657
658 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
659 char *path = NULL;
660 unsigned n_argv = 0, j;
661 char **argv = NULL;
662 size_t allocated = 0;
663 int r;
664
665 assert(b);
666 assert(p);
667 assert(*p);
668 assert(guid);
669
670 while (!IN_SET(**p, 0, ';')) {
671 r = parse_address_key(p, "guid", guid);
672 if (r < 0)
673 goto fail;
674 else if (r > 0)
675 continue;
676
677 r = parse_address_key(p, "path", &path);
678 if (r < 0)
679 goto fail;
680 else if (r > 0)
681 continue;
682
683 if (startswith(*p, "argv")) {
684 unsigned ul;
685
686 errno = 0;
687 ul = strtoul(*p + 4, (char**) p, 10);
688 if (errno > 0 || **p != '=' || ul > 256) {
689 r = -EINVAL;
690 goto fail;
691 }
692
693 (*p)++;
694
695 if (ul >= n_argv) {
696 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
697 r = -ENOMEM;
698 goto fail;
699 }
700
701 n_argv = ul + 1;
702 }
703
704 r = parse_address_key(p, NULL, argv + ul);
705 if (r < 0)
706 goto fail;
707
708 continue;
709 }
710
711 skip_address_key(p);
712 }
713
714 if (!path) {
715 r = -EINVAL;
716 goto fail;
717 }
718
719 /* Make sure there are no holes in the array, with the
720 * exception of argv[0] */
721 for (j = 1; j < n_argv; j++)
722 if (!argv[j]) {
723 r = -EINVAL;
724 goto fail;
725 }
726
727 if (argv && argv[0] == NULL) {
728 argv[0] = strdup(path);
729 if (!argv[0]) {
730 r = -ENOMEM;
731 goto fail;
732 }
733 }
734
735 b->exec_path = path;
736 b->exec_argv = argv;
737
738 b->is_local = false;
739
740 return 0;
741
742 fail:
743 for (j = 0; j < n_argv; j++)
744 free(argv[j]);
745
746 free(argv);
747 free(path);
748 return r;
749 }
750
751 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
752 _cleanup_free_ char *machine = NULL, *pid = NULL;
753 int r;
754
755 assert(b);
756 assert(p);
757 assert(*p);
758 assert(guid);
759
760 while (!IN_SET(**p, 0, ';')) {
761 r = parse_address_key(p, "guid", guid);
762 if (r < 0)
763 return r;
764 else if (r > 0)
765 continue;
766
767 r = parse_address_key(p, "machine", &machine);
768 if (r < 0)
769 return r;
770 else if (r > 0)
771 continue;
772
773 r = parse_address_key(p, "pid", &pid);
774 if (r < 0)
775 return r;
776 else if (r > 0)
777 continue;
778
779 skip_address_key(p);
780 }
781
782 if (!machine == !pid)
783 return -EINVAL;
784
785 if (machine) {
786 if (!machine_name_is_valid(machine))
787 return -EINVAL;
788
789 free_and_replace(b->machine, machine);
790 } else {
791 b->machine = mfree(b->machine);
792 }
793
794 if (pid) {
795 r = parse_pid(pid, &b->nspid);
796 if (r < 0)
797 return r;
798 } else
799 b->nspid = 0;
800
801 b->sockaddr.un.sun_family = AF_UNIX;
802 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
803 b->sockaddr_size = SOCKADDR_UN_LEN(b->sockaddr.un);
804 b->is_local = false;
805
806 return 0;
807 }
808
809 static void bus_reset_parsed_address(sd_bus *b) {
810 assert(b);
811
812 zero(b->sockaddr);
813 b->sockaddr_size = 0;
814 b->exec_argv = strv_free(b->exec_argv);
815 b->exec_path = mfree(b->exec_path);
816 b->server_id = SD_ID128_NULL;
817 b->machine = mfree(b->machine);
818 b->nspid = 0;
819 }
820
821 static int bus_parse_next_address(sd_bus *b) {
822 _cleanup_free_ char *guid = NULL;
823 const char *a;
824 int r;
825
826 assert(b);
827
828 if (!b->address)
829 return 0;
830 if (b->address[b->address_index] == 0)
831 return 0;
832
833 bus_reset_parsed_address(b);
834
835 a = b->address + b->address_index;
836
837 while (*a != 0) {
838
839 if (*a == ';') {
840 a++;
841 continue;
842 }
843
844 if (startswith(a, "unix:")) {
845 a += 5;
846
847 r = parse_unix_address(b, &a, &guid);
848 if (r < 0)
849 return r;
850 break;
851
852 } else if (startswith(a, "tcp:")) {
853
854 a += 4;
855 r = parse_tcp_address(b, &a, &guid);
856 if (r < 0)
857 return r;
858
859 break;
860
861 } else if (startswith(a, "unixexec:")) {
862
863 a += 9;
864 r = parse_exec_address(b, &a, &guid);
865 if (r < 0)
866 return r;
867
868 break;
869
870 } else if (startswith(a, "x-machine-unix:")) {
871
872 a += 15;
873 r = parse_container_unix_address(b, &a, &guid);
874 if (r < 0)
875 return r;
876
877 break;
878 }
879
880 a = strchr(a, ';');
881 if (!a)
882 return 0;
883 }
884
885 if (guid) {
886 r = sd_id128_from_string(guid, &b->server_id);
887 if (r < 0)
888 return r;
889 }
890
891 b->address_index = a - b->address;
892 return 1;
893 }
894
895 static int bus_start_address(sd_bus *b) {
896 int r;
897
898 assert(b);
899
900 for (;;) {
901 bus_close_fds(b);
902
903 /* If you provide multiple different bus-addresses, we
904 * try all of them in order and use the first one that
905 * succeeds. */
906
907 if (b->exec_path)
908 r = bus_socket_exec(b);
909
910 else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC)
911 r = bus_container_connect_socket(b);
912
913 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
914 r = bus_socket_connect(b);
915
916 else
917 goto next;
918
919 if (r >= 0) {
920 r = attach_io_events(b);
921 if (r >= 0)
922 return r;
923 }
924
925 b->last_connect_error = -r;
926
927 next:
928 r = bus_parse_next_address(b);
929 if (r < 0)
930 return r;
931 if (r == 0)
932 return b->last_connect_error > 0 ? -b->last_connect_error : -ECONNREFUSED;
933 }
934 }
935
936 int bus_next_address(sd_bus *b) {
937 assert(b);
938
939 bus_reset_parsed_address(b);
940 return bus_start_address(b);
941 }
942
943 static int bus_start_fd(sd_bus *b) {
944 struct stat st;
945 int r;
946
947 assert(b);
948 assert(b->input_fd >= 0);
949 assert(b->output_fd >= 0);
950
951 r = fd_nonblock(b->input_fd, true);
952 if (r < 0)
953 return r;
954
955 r = fd_cloexec(b->input_fd, true);
956 if (r < 0)
957 return r;
958
959 if (b->input_fd != b->output_fd) {
960 r = fd_nonblock(b->output_fd, true);
961 if (r < 0)
962 return r;
963
964 r = fd_cloexec(b->output_fd, true);
965 if (r < 0)
966 return r;
967 }
968
969 if (fstat(b->input_fd, &st) < 0)
970 return -errno;
971
972 return bus_socket_take_fd(b);
973 }
974
975 _public_ int sd_bus_start(sd_bus *bus) {
976 int r;
977
978 assert_return(bus, -EINVAL);
979 assert_return(bus->state == BUS_UNSET, -EPERM);
980 assert_return(!bus_pid_changed(bus), -ECHILD);
981
982 bus->state = BUS_OPENING;
983
984 if (bus->is_server && bus->bus_client)
985 return -EINVAL;
986
987 if (bus->input_fd >= 0)
988 r = bus_start_fd(bus);
989 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->machine)
990 r = bus_start_address(bus);
991 else
992 return -EINVAL;
993
994 if (r < 0) {
995 sd_bus_close(bus);
996 return r;
997 }
998
999 return bus_send_hello(bus);
1000 }
1001
1002 _public_ int sd_bus_open(sd_bus **ret) {
1003 const char *e;
1004 sd_bus *b;
1005 int r;
1006
1007 assert_return(ret, -EINVAL);
1008
1009 /* Let's connect to the starter bus if it is set, and
1010 * otherwise to the bus that is appropropriate for the scope
1011 * we are running in */
1012
1013 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1014 if (e) {
1015 if (streq(e, "system"))
1016 return sd_bus_open_system(ret);
1017 else if (STR_IN_SET(e, "session", "user"))
1018 return sd_bus_open_user(ret);
1019 }
1020
1021 e = secure_getenv("DBUS_STARTER_ADDRESS");
1022 if (!e) {
1023 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1024 return sd_bus_open_user(ret);
1025 else
1026 return sd_bus_open_system(ret);
1027 }
1028
1029 r = sd_bus_new(&b);
1030 if (r < 0)
1031 return r;
1032
1033 r = sd_bus_set_address(b, e);
1034 if (r < 0)
1035 goto fail;
1036
1037 b->bus_client = true;
1038
1039 /* We don't know whether the bus is trusted or not, so better
1040 * be safe, and authenticate everything */
1041 b->trusted = false;
1042 b->is_local = false;
1043 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1044 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1045
1046 r = sd_bus_start(b);
1047 if (r < 0)
1048 goto fail;
1049
1050 *ret = b;
1051 return 0;
1052
1053 fail:
1054 bus_free(b);
1055 return r;
1056 }
1057
1058 int bus_set_address_system(sd_bus *b) {
1059 const char *e;
1060 assert(b);
1061
1062 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1063 if (e)
1064 return sd_bus_set_address(b, e);
1065
1066 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1067 }
1068
1069 _public_ int sd_bus_open_system(sd_bus **ret) {
1070 sd_bus *b;
1071 int r;
1072
1073 assert_return(ret, -EINVAL);
1074
1075 r = sd_bus_new(&b);
1076 if (r < 0)
1077 return r;
1078
1079 r = bus_set_address_system(b);
1080 if (r < 0)
1081 goto fail;
1082
1083 b->bus_client = true;
1084 b->is_system = true;
1085
1086 /* Let's do per-method access control on the system bus. We
1087 * need the caller's UID and capability set for that. */
1088 b->trusted = false;
1089 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1090 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1091 b->is_local = true;
1092
1093 r = sd_bus_start(b);
1094 if (r < 0)
1095 goto fail;
1096
1097 *ret = b;
1098 return 0;
1099
1100 fail:
1101 bus_free(b);
1102 return r;
1103 }
1104
1105 int bus_set_address_user(sd_bus *b) {
1106 const char *e;
1107 _cleanup_free_ char *ee = NULL, *s = NULL;
1108
1109 assert(b);
1110
1111 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1112 if (e)
1113 return sd_bus_set_address(b, e);
1114
1115 e = secure_getenv("XDG_RUNTIME_DIR");
1116 if (!e)
1117 return -ENOENT;
1118
1119 ee = bus_address_escape(e);
1120 if (!ee)
1121 return -ENOMEM;
1122
1123 if (asprintf(&s, UNIX_USER_BUS_ADDRESS_FMT, ee) < 0)
1124 return -ENOMEM;
1125
1126 b->address = s;
1127 s = NULL;
1128
1129 return 0;
1130 }
1131
1132 _public_ int sd_bus_open_user(sd_bus **ret) {
1133 sd_bus *b;
1134 int r;
1135
1136 assert_return(ret, -EINVAL);
1137
1138 r = sd_bus_new(&b);
1139 if (r < 0)
1140 return r;
1141
1142 r = bus_set_address_user(b);
1143 if (r < 0)
1144 goto fail;
1145
1146 b->bus_client = true;
1147 b->is_user = true;
1148
1149 /* We don't do any per-method access control on the user
1150 * bus. */
1151 b->trusted = true;
1152 b->is_local = true;
1153
1154 r = sd_bus_start(b);
1155 if (r < 0)
1156 goto fail;
1157
1158 *ret = b;
1159 return 0;
1160
1161 fail:
1162 bus_free(b);
1163 return r;
1164 }
1165
1166 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1167 _cleanup_free_ char *e = NULL;
1168 char *m = NULL, *c = NULL;
1169
1170 assert(b);
1171 assert(host);
1172
1173 /* Let's see if we shall enter some container */
1174 m = strchr(host, ':');
1175 if (m) {
1176 m++;
1177
1178 /* Let's make sure this is not a port of some kind,
1179 * and is a valid machine name. */
1180 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1181 char *t;
1182
1183 /* Cut out the host part */
1184 t = strndupa(host, m - host - 1);
1185 e = bus_address_escape(t);
1186 if (!e)
1187 return -ENOMEM;
1188
1189 c = strjoina(",argv5=--machine=", m);
1190 }
1191 }
1192
1193 if (!e) {
1194 e = bus_address_escape(host);
1195 if (!e)
1196 return -ENOMEM;
1197 }
1198
1199 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=--,argv3=", e, ",argv4=systemd-stdio-bridge", c);
1200 if (!b->address)
1201 return -ENOMEM;
1202
1203 return 0;
1204 }
1205
1206 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1207 sd_bus *bus;
1208 int r;
1209
1210 assert_return(host, -EINVAL);
1211 assert_return(ret, -EINVAL);
1212
1213 r = sd_bus_new(&bus);
1214 if (r < 0)
1215 return r;
1216
1217 r = bus_set_address_system_remote(bus, host);
1218 if (r < 0)
1219 goto fail;
1220
1221 bus->bus_client = true;
1222 bus->trusted = false;
1223 bus->is_system = true;
1224 bus->is_local = false;
1225
1226 r = sd_bus_start(bus);
1227 if (r < 0)
1228 goto fail;
1229
1230 *ret = bus;
1231 return 0;
1232
1233 fail:
1234 bus_free(bus);
1235 return r;
1236 }
1237
1238 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1239 _cleanup_free_ char *e = NULL;
1240
1241 assert(b);
1242 assert(machine);
1243
1244 e = bus_address_escape(machine);
1245 if (!e)
1246 return -ENOMEM;
1247
1248 b->address = strjoin("x-machine-unix:machine=", e);
1249 if (!b->address)
1250 return -ENOMEM;
1251
1252 return 0;
1253 }
1254
1255 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1256 sd_bus *bus;
1257 int r;
1258
1259 assert_return(machine, -EINVAL);
1260 assert_return(ret, -EINVAL);
1261 assert_return(machine_name_is_valid(machine), -EINVAL);
1262
1263 r = sd_bus_new(&bus);
1264 if (r < 0)
1265 return r;
1266
1267 r = bus_set_address_system_machine(bus, machine);
1268 if (r < 0)
1269 goto fail;
1270
1271 bus->bus_client = true;
1272 bus->trusted = false;
1273 bus->is_system = true;
1274 bus->is_local = false;
1275
1276 r = sd_bus_start(bus);
1277 if (r < 0)
1278 goto fail;
1279
1280 *ret = bus;
1281 return 0;
1282
1283 fail:
1284 bus_free(bus);
1285 return r;
1286 }
1287
1288 _public_ void sd_bus_close(sd_bus *bus) {
1289
1290 if (!bus)
1291 return;
1292 if (bus->state == BUS_CLOSED)
1293 return;
1294 if (bus_pid_changed(bus))
1295 return;
1296
1297 bus->state = BUS_CLOSED;
1298
1299 sd_bus_detach_event(bus);
1300
1301 /* Drop all queued messages so that they drop references to
1302 * the bus object and the bus may be freed */
1303 bus_reset_queues(bus);
1304
1305 bus_close_fds(bus);
1306 }
1307
1308 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1309
1310 if (!bus)
1311 return NULL;
1312
1313 sd_bus_flush(bus);
1314 sd_bus_close(bus);
1315
1316 return sd_bus_unref(bus);
1317 }
1318
1319 static void bus_enter_closing(sd_bus *bus) {
1320 assert(bus);
1321
1322 if (!IN_SET(bus->state, BUS_OPENING, BUS_AUTHENTICATING, BUS_HELLO, BUS_RUNNING))
1323 return;
1324
1325 bus->state = BUS_CLOSING;
1326 }
1327
1328 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1329
1330 if (!bus)
1331 return NULL;
1332
1333 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1334
1335 return bus;
1336 }
1337
1338 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1339 unsigned i;
1340
1341 if (!bus)
1342 return NULL;
1343
1344 i = REFCNT_DEC(bus->n_ref);
1345 if (i > 0)
1346 return NULL;
1347
1348 bus_free(bus);
1349 return NULL;
1350 }
1351
1352 _public_ int sd_bus_is_open(sd_bus *bus) {
1353
1354 assert_return(bus, -EINVAL);
1355 assert_return(!bus_pid_changed(bus), -ECHILD);
1356
1357 return BUS_IS_OPEN(bus->state);
1358 }
1359
1360 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1361 int r;
1362
1363 assert_return(bus, -EINVAL);
1364 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1365 assert_return(!bus_pid_changed(bus), -ECHILD);
1366
1367 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1368 return 0;
1369
1370 if (type == SD_BUS_TYPE_UNIX_FD) {
1371 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1372 return 0;
1373
1374 r = bus_ensure_running(bus);
1375 if (r < 0)
1376 return r;
1377
1378 return bus->can_fds;
1379 }
1380
1381 return bus_type_is_valid(type);
1382 }
1383
1384 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1385 int r;
1386
1387 assert_return(bus, -EINVAL);
1388 assert_return(id, -EINVAL);
1389 assert_return(!bus_pid_changed(bus), -ECHILD);
1390
1391 r = bus_ensure_running(bus);
1392 if (r < 0)
1393 return r;
1394
1395 *id = bus->server_id;
1396 return 0;
1397 }
1398
1399 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1400 assert(b);
1401 assert(m);
1402
1403 if (m->sealed) {
1404 /* If we copy the same message to multiple
1405 * destinations, avoid using the same cookie
1406 * numbers. */
1407 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1408 return 0;
1409 }
1410
1411 if (timeout == 0)
1412 timeout = BUS_DEFAULT_TIMEOUT;
1413
1414 return sd_bus_message_seal(m, ++b->cookie, timeout);
1415 }
1416
1417 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1418 bool remarshal = false;
1419
1420 assert(b);
1421
1422 /* wrong packet version */
1423 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1424 remarshal = true;
1425
1426 /* wrong packet endianness */
1427 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1428 remarshal = true;
1429
1430 return remarshal ? bus_message_remarshal(b, m) : 0;
1431 }
1432
1433 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1434 assert(b);
1435 assert(m);
1436
1437 /* Fake some timestamps, if they were requested, and not
1438 * already initialized */
1439 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1440 if (m->realtime <= 0)
1441 m->realtime = now(CLOCK_REALTIME);
1442
1443 if (m->monotonic <= 0)
1444 m->monotonic = now(CLOCK_MONOTONIC);
1445 }
1446
1447 /* The bus specification says the serial number cannot be 0,
1448 * hence let's fill something in for synthetic messages. Since
1449 * synthetic messages might have a fake sender and we don't
1450 * want to interfere with the real sender's serial numbers we
1451 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1452 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1453 * even though kdbus can do 64bit. */
1454 return sd_bus_message_seal(m, 0xFFFFFFFFULL, 0);
1455 }
1456
1457 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1458 int r;
1459
1460 assert(bus);
1461 assert(m);
1462
1463 r = bus_socket_write_message(bus, m, idx);
1464 if (r <= 0)
1465 return r;
1466
1467 if (*idx >= BUS_MESSAGE_SIZE(m))
1468 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error-name=%s error-message=%s",
1469 bus_message_type_to_string(m->header->type),
1470 strna(sd_bus_message_get_sender(m)),
1471 strna(sd_bus_message_get_destination(m)),
1472 strna(sd_bus_message_get_path(m)),
1473 strna(sd_bus_message_get_interface(m)),
1474 strna(sd_bus_message_get_member(m)),
1475 BUS_MESSAGE_COOKIE(m),
1476 m->reply_cookie,
1477 strna(m->error.name),
1478 strna(m->error.message));
1479
1480 return r;
1481 }
1482
1483 static int dispatch_wqueue(sd_bus *bus) {
1484 int r, ret = 0;
1485
1486 assert(bus);
1487 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1488
1489 while (bus->wqueue_size > 0) {
1490
1491 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1492 if (r < 0)
1493 return r;
1494 else if (r == 0)
1495 /* Didn't do anything this time */
1496 return ret;
1497 else if (bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1498 /* Fully written. Let's drop the entry from
1499 * the queue.
1500 *
1501 * This isn't particularly optimized, but
1502 * well, this is supposed to be our worst-case
1503 * buffer only, and the socket buffer is
1504 * supposed to be our primary buffer, and if
1505 * it got full, then all bets are off
1506 * anyway. */
1507
1508 bus->wqueue_size--;
1509 sd_bus_message_unref(bus->wqueue[0]);
1510 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1511 bus->windex = 0;
1512
1513 ret = 1;
1514 }
1515 }
1516
1517 return ret;
1518 }
1519
1520 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1521 assert(bus);
1522
1523 return bus_socket_read_message(bus);
1524 }
1525
1526 int bus_rqueue_make_room(sd_bus *bus) {
1527 assert(bus);
1528
1529 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1530 return -ENOBUFS;
1531
1532 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1533 return -ENOMEM;
1534
1535 return 0;
1536 }
1537
1538 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1539 int r, ret = 0;
1540
1541 assert(bus);
1542 assert(m);
1543 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1544
1545 /* Note that the priority logic is only available on kdbus,
1546 * where the rqueue is unused. We check the rqueue here
1547 * anyway, because it's simple... */
1548
1549 for (;;) {
1550 if (bus->rqueue_size > 0) {
1551 /* Dispatch a queued message */
1552
1553 *m = bus->rqueue[0];
1554 bus->rqueue_size--;
1555 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1556 return 1;
1557 }
1558
1559 /* Try to read a new message */
1560 r = bus_read_message(bus, hint_priority, priority);
1561 if (r < 0)
1562 return r;
1563 if (r == 0)
1564 return ret;
1565
1566 ret = 1;
1567 }
1568 }
1569
1570 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1571 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1572 int r;
1573
1574 assert_return(m, -EINVAL);
1575
1576 if (!bus)
1577 bus = m->bus;
1578
1579 assert_return(!bus_pid_changed(bus), -ECHILD);
1580
1581 if (!BUS_IS_OPEN(bus->state))
1582 return -ENOTCONN;
1583
1584 if (m->n_fds > 0) {
1585 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1586 if (r < 0)
1587 return r;
1588 if (r == 0)
1589 return -EOPNOTSUPP;
1590 }
1591
1592 /* If the cookie number isn't kept, then we know that no reply
1593 * is expected */
1594 if (!cookie && !m->sealed)
1595 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1596
1597 r = bus_seal_message(bus, m, 0);
1598 if (r < 0)
1599 return r;
1600
1601 /* Remarshall if we have to. This will possibly unref the
1602 * message and place a replacement in m */
1603 r = bus_remarshal_message(bus, &m);
1604 if (r < 0)
1605 return r;
1606
1607 /* If this is a reply and no reply was requested, then let's
1608 * suppress this, if we can */
1609 if (m->dont_send)
1610 goto finish;
1611
1612 if (IN_SET(bus->state, BUS_RUNNING, BUS_HELLO) && bus->wqueue_size <= 0) {
1613 size_t idx = 0;
1614
1615 r = bus_write_message(bus, m, hint_sync_call, &idx);
1616 if (r < 0) {
1617 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
1618 bus_enter_closing(bus);
1619 return -ECONNRESET;
1620 }
1621
1622 return r;
1623 }
1624
1625 if (idx < BUS_MESSAGE_SIZE(m)) {
1626 /* Wasn't fully written. So let's remember how
1627 * much was written. Note that the first entry
1628 * of the wqueue array is always allocated so
1629 * that we always can remember how much was
1630 * written. */
1631 bus->wqueue[0] = sd_bus_message_ref(m);
1632 bus->wqueue_size = 1;
1633 bus->windex = idx;
1634 }
1635
1636 } else {
1637 /* Just append it to the queue. */
1638
1639 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1640 return -ENOBUFS;
1641
1642 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1643 return -ENOMEM;
1644
1645 bus->wqueue[bus->wqueue_size++] = sd_bus_message_ref(m);
1646 }
1647
1648 finish:
1649 if (cookie)
1650 *cookie = BUS_MESSAGE_COOKIE(m);
1651
1652 return 1;
1653 }
1654
1655 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1656 return bus_send_internal(bus, m, cookie, false);
1657 }
1658
1659 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1660 int r;
1661
1662 assert_return(m, -EINVAL);
1663
1664 if (!bus)
1665 bus = m->bus;
1666
1667 assert_return(!bus_pid_changed(bus), -ECHILD);
1668
1669 if (!BUS_IS_OPEN(bus->state))
1670 return -ENOTCONN;
1671
1672 if (!streq_ptr(m->destination, destination)) {
1673
1674 if (!destination)
1675 return -EEXIST;
1676
1677 r = sd_bus_message_set_destination(m, destination);
1678 if (r < 0)
1679 return r;
1680 }
1681
1682 return sd_bus_send(bus, m, cookie);
1683 }
1684
1685 static usec_t calc_elapse(uint64_t usec) {
1686 if (usec == (uint64_t) -1)
1687 return 0;
1688
1689 return now(CLOCK_MONOTONIC) + usec;
1690 }
1691
1692 static int timeout_compare(const void *a, const void *b) {
1693 const struct reply_callback *x = a, *y = b;
1694
1695 if (x->timeout != 0 && y->timeout == 0)
1696 return -1;
1697
1698 if (x->timeout == 0 && y->timeout != 0)
1699 return 1;
1700
1701 if (x->timeout < y->timeout)
1702 return -1;
1703
1704 if (x->timeout > y->timeout)
1705 return 1;
1706
1707 return 0;
1708 }
1709
1710 _public_ int sd_bus_call_async(
1711 sd_bus *bus,
1712 sd_bus_slot **slot,
1713 sd_bus_message *_m,
1714 sd_bus_message_handler_t callback,
1715 void *userdata,
1716 uint64_t usec) {
1717
1718 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1719 _cleanup_(sd_bus_slot_unrefp) sd_bus_slot *s = NULL;
1720 int r;
1721
1722 assert_return(m, -EINVAL);
1723 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1724 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1725 assert_return(callback, -EINVAL);
1726
1727 if (!bus)
1728 bus = m->bus;
1729
1730 assert_return(!bus_pid_changed(bus), -ECHILD);
1731
1732 if (!BUS_IS_OPEN(bus->state))
1733 return -ENOTCONN;
1734
1735 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1736 if (r < 0)
1737 return r;
1738
1739 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1740 if (r < 0)
1741 return r;
1742
1743 r = bus_seal_message(bus, m, usec);
1744 if (r < 0)
1745 return r;
1746
1747 r = bus_remarshal_message(bus, &m);
1748 if (r < 0)
1749 return r;
1750
1751 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1752 if (!s)
1753 return -ENOMEM;
1754
1755 s->reply_callback.callback = callback;
1756
1757 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1758 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1759 if (r < 0) {
1760 s->reply_callback.cookie = 0;
1761 return r;
1762 }
1763
1764 s->reply_callback.timeout = calc_elapse(m->timeout);
1765 if (s->reply_callback.timeout != 0) {
1766 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1767 if (r < 0) {
1768 s->reply_callback.timeout = 0;
1769 return r;
1770 }
1771 }
1772
1773 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1774 if (r < 0)
1775 return r;
1776
1777 if (slot)
1778 *slot = s;
1779 s = NULL;
1780
1781 return r;
1782 }
1783
1784 int bus_ensure_running(sd_bus *bus) {
1785 int r;
1786
1787 assert(bus);
1788
1789 if (IN_SET(bus->state, BUS_UNSET, BUS_CLOSED, BUS_CLOSING))
1790 return -ENOTCONN;
1791 if (bus->state == BUS_RUNNING)
1792 return 1;
1793
1794 for (;;) {
1795 r = sd_bus_process(bus, NULL);
1796 if (r < 0)
1797 return r;
1798 if (bus->state == BUS_RUNNING)
1799 return 1;
1800 if (r > 0)
1801 continue;
1802
1803 r = sd_bus_wait(bus, (uint64_t) -1);
1804 if (r < 0)
1805 return r;
1806 }
1807 }
1808
1809 _public_ int sd_bus_call(
1810 sd_bus *bus,
1811 sd_bus_message *_m,
1812 uint64_t usec,
1813 sd_bus_error *error,
1814 sd_bus_message **reply) {
1815
1816 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1817 usec_t timeout;
1818 uint64_t cookie;
1819 unsigned i;
1820 int r;
1821
1822 bus_assert_return(m, -EINVAL, error);
1823 bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
1824 bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
1825 bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
1826
1827 if (!bus)
1828 bus = m->bus;
1829
1830 bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
1831
1832 if (!BUS_IS_OPEN(bus->state)) {
1833 r = -ENOTCONN;
1834 goto fail;
1835 }
1836
1837 r = bus_ensure_running(bus);
1838 if (r < 0)
1839 goto fail;
1840
1841 i = bus->rqueue_size;
1842
1843 r = bus_seal_message(bus, m, usec);
1844 if (r < 0)
1845 goto fail;
1846
1847 r = bus_remarshal_message(bus, &m);
1848 if (r < 0)
1849 goto fail;
1850
1851 r = bus_send_internal(bus, m, &cookie, true);
1852 if (r < 0)
1853 goto fail;
1854
1855 timeout = calc_elapse(m->timeout);
1856
1857 for (;;) {
1858 usec_t left;
1859
1860 while (i < bus->rqueue_size) {
1861 sd_bus_message *incoming = NULL;
1862
1863 incoming = bus->rqueue[i];
1864
1865 if (incoming->reply_cookie == cookie) {
1866 /* Found a match! */
1867
1868 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1869 bus->rqueue_size--;
1870 log_debug_bus_message(incoming);
1871
1872 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1873
1874 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1875 if (reply)
1876 *reply = incoming;
1877 else
1878 sd_bus_message_unref(incoming);
1879
1880 return 1;
1881 }
1882
1883 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1884 sd_bus_message_unref(incoming);
1885 return r;
1886
1887 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
1888 r = sd_bus_error_copy(error, &incoming->error);
1889 sd_bus_message_unref(incoming);
1890 return r;
1891 } else {
1892 r = -EIO;
1893 goto fail;
1894 }
1895
1896 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1897 bus->unique_name &&
1898 incoming->sender &&
1899 streq(bus->unique_name, incoming->sender)) {
1900
1901 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1902 bus->rqueue_size--;
1903
1904 /* Our own message? Somebody is trying
1905 * to send its own client a message,
1906 * let's not dead-lock, let's fail
1907 * immediately. */
1908
1909 sd_bus_message_unref(incoming);
1910 r = -ELOOP;
1911 goto fail;
1912 }
1913
1914 /* Try to read more, right-away */
1915 i++;
1916 }
1917
1918 r = bus_read_message(bus, false, 0);
1919 if (r < 0) {
1920 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
1921 bus_enter_closing(bus);
1922 r = -ECONNRESET;
1923 }
1924
1925 goto fail;
1926 }
1927 if (r > 0)
1928 continue;
1929
1930 if (timeout > 0) {
1931 usec_t n;
1932
1933 n = now(CLOCK_MONOTONIC);
1934 if (n >= timeout) {
1935 r = -ETIMEDOUT;
1936 goto fail;
1937 }
1938
1939 left = timeout - n;
1940 } else
1941 left = (uint64_t) -1;
1942
1943 r = bus_poll(bus, true, left);
1944 if (r < 0)
1945 goto fail;
1946 if (r == 0) {
1947 r = -ETIMEDOUT;
1948 goto fail;
1949 }
1950
1951 r = dispatch_wqueue(bus);
1952 if (r < 0) {
1953 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
1954 bus_enter_closing(bus);
1955 r = -ECONNRESET;
1956 }
1957
1958 goto fail;
1959 }
1960 }
1961
1962 fail:
1963 return sd_bus_error_set_errno(error, r);
1964 }
1965
1966 _public_ int sd_bus_get_fd(sd_bus *bus) {
1967
1968 assert_return(bus, -EINVAL);
1969 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1970 assert_return(!bus_pid_changed(bus), -ECHILD);
1971
1972 return bus->input_fd;
1973 }
1974
1975 _public_ int sd_bus_get_events(sd_bus *bus) {
1976 int flags = 0;
1977
1978 assert_return(bus, -EINVAL);
1979 assert_return(!bus_pid_changed(bus), -ECHILD);
1980
1981 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
1982 return -ENOTCONN;
1983
1984 if (bus->state == BUS_OPENING)
1985 flags |= POLLOUT;
1986 else if (bus->state == BUS_AUTHENTICATING) {
1987
1988 if (bus_socket_auth_needs_write(bus))
1989 flags |= POLLOUT;
1990
1991 flags |= POLLIN;
1992
1993 } else if (IN_SET(bus->state, BUS_RUNNING, BUS_HELLO)) {
1994 if (bus->rqueue_size <= 0)
1995 flags |= POLLIN;
1996 if (bus->wqueue_size > 0)
1997 flags |= POLLOUT;
1998 }
1999
2000 return flags;
2001 }
2002
2003 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2004 struct reply_callback *c;
2005
2006 assert_return(bus, -EINVAL);
2007 assert_return(timeout_usec, -EINVAL);
2008 assert_return(!bus_pid_changed(bus), -ECHILD);
2009
2010 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2011 return -ENOTCONN;
2012
2013 if (bus->track_queue) {
2014 *timeout_usec = 0;
2015 return 1;
2016 }
2017
2018 if (bus->state == BUS_CLOSING) {
2019 *timeout_usec = 0;
2020 return 1;
2021 }
2022
2023 if (bus->state == BUS_AUTHENTICATING) {
2024 *timeout_usec = bus->auth_timeout;
2025 return 1;
2026 }
2027
2028 if (!IN_SET(bus->state, BUS_RUNNING, BUS_HELLO)) {
2029 *timeout_usec = (uint64_t) -1;
2030 return 0;
2031 }
2032
2033 if (bus->rqueue_size > 0) {
2034 *timeout_usec = 0;
2035 return 1;
2036 }
2037
2038 c = prioq_peek(bus->reply_callbacks_prioq);
2039 if (!c) {
2040 *timeout_usec = (uint64_t) -1;
2041 return 0;
2042 }
2043
2044 if (c->timeout == 0) {
2045 *timeout_usec = (uint64_t) -1;
2046 return 0;
2047 }
2048
2049 *timeout_usec = c->timeout;
2050 return 1;
2051 }
2052
2053 static int process_timeout(sd_bus *bus) {
2054 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2055 _cleanup_(sd_bus_message_unrefp) sd_bus_message* m = NULL;
2056 struct reply_callback *c;
2057 sd_bus_slot *slot;
2058 usec_t n;
2059 int r;
2060
2061 assert(bus);
2062
2063 c = prioq_peek(bus->reply_callbacks_prioq);
2064 if (!c)
2065 return 0;
2066
2067 n = now(CLOCK_MONOTONIC);
2068 if (c->timeout > n)
2069 return 0;
2070
2071 r = bus_message_new_synthetic_error(
2072 bus,
2073 c->cookie,
2074 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2075 &m);
2076 if (r < 0)
2077 return r;
2078
2079 r = bus_seal_synthetic_message(bus, m);
2080 if (r < 0)
2081 return r;
2082
2083 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2084 c->timeout = 0;
2085
2086 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2087 c->cookie = 0;
2088
2089 slot = container_of(c, sd_bus_slot, reply_callback);
2090
2091 bus->iteration_counter++;
2092
2093 bus->current_message = m;
2094 bus->current_slot = sd_bus_slot_ref(slot);
2095 bus->current_handler = c->callback;
2096 bus->current_userdata = slot->userdata;
2097 r = c->callback(m, slot->userdata, &error_buffer);
2098 bus->current_userdata = NULL;
2099 bus->current_handler = NULL;
2100 bus->current_slot = NULL;
2101 bus->current_message = NULL;
2102
2103 if (slot->floating) {
2104 bus_slot_disconnect(slot);
2105 sd_bus_slot_unref(slot);
2106 }
2107
2108 sd_bus_slot_unref(slot);
2109
2110 return bus_maybe_reply_error(m, r, &error_buffer);
2111 }
2112
2113 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2114 assert(bus);
2115 assert(m);
2116
2117 if (bus->state != BUS_HELLO)
2118 return 0;
2119
2120 /* Let's make sure the first message on the bus is the HELLO
2121 * reply. But note that we don't actually parse the message
2122 * here (we leave that to the usual handling), we just verify
2123 * we don't let any earlier msg through. */
2124
2125 if (!IN_SET(m->header->type, SD_BUS_MESSAGE_METHOD_RETURN, SD_BUS_MESSAGE_METHOD_ERROR))
2126 return -EIO;
2127
2128 if (m->reply_cookie != 1)
2129 return -EIO;
2130
2131 return 0;
2132 }
2133
2134 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2135 _cleanup_(sd_bus_message_unrefp) sd_bus_message *synthetic_reply = NULL;
2136 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2137 struct reply_callback *c;
2138 sd_bus_slot *slot;
2139 int r;
2140
2141 assert(bus);
2142 assert(m);
2143
2144 if (!IN_SET(m->header->type, SD_BUS_MESSAGE_METHOD_RETURN, SD_BUS_MESSAGE_METHOD_ERROR))
2145 return 0;
2146
2147 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2148 return 0;
2149
2150 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2151 if (!c)
2152 return 0;
2153
2154 c->cookie = 0;
2155
2156 slot = container_of(c, sd_bus_slot, reply_callback);
2157
2158 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2159
2160 /* If the reply contained a file descriptor which we
2161 * didn't want we pass an error instead. */
2162
2163 r = bus_message_new_synthetic_error(
2164 bus,
2165 m->reply_cookie,
2166 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2167 &synthetic_reply);
2168 if (r < 0)
2169 return r;
2170
2171 /* Copy over original timestamp */
2172 synthetic_reply->realtime = m->realtime;
2173 synthetic_reply->monotonic = m->monotonic;
2174 synthetic_reply->seqnum = m->seqnum;
2175
2176 r = bus_seal_synthetic_message(bus, synthetic_reply);
2177 if (r < 0)
2178 return r;
2179
2180 m = synthetic_reply;
2181 } else {
2182 r = sd_bus_message_rewind(m, true);
2183 if (r < 0)
2184 return r;
2185 }
2186
2187 if (c->timeout != 0) {
2188 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2189 c->timeout = 0;
2190 }
2191
2192 bus->current_slot = sd_bus_slot_ref(slot);
2193 bus->current_handler = c->callback;
2194 bus->current_userdata = slot->userdata;
2195 r = c->callback(m, slot->userdata, &error_buffer);
2196 bus->current_userdata = NULL;
2197 bus->current_handler = NULL;
2198 bus->current_slot = NULL;
2199
2200 if (slot->floating) {
2201 bus_slot_disconnect(slot);
2202 sd_bus_slot_unref(slot);
2203 }
2204
2205 sd_bus_slot_unref(slot);
2206
2207 return bus_maybe_reply_error(m, r, &error_buffer);
2208 }
2209
2210 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2211 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2212 struct filter_callback *l;
2213 int r;
2214
2215 assert(bus);
2216 assert(m);
2217
2218 do {
2219 bus->filter_callbacks_modified = false;
2220
2221 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2222 sd_bus_slot *slot;
2223
2224 if (bus->filter_callbacks_modified)
2225 break;
2226
2227 /* Don't run this more than once per iteration */
2228 if (l->last_iteration == bus->iteration_counter)
2229 continue;
2230
2231 l->last_iteration = bus->iteration_counter;
2232
2233 r = sd_bus_message_rewind(m, true);
2234 if (r < 0)
2235 return r;
2236
2237 slot = container_of(l, sd_bus_slot, filter_callback);
2238
2239 bus->current_slot = sd_bus_slot_ref(slot);
2240 bus->current_handler = l->callback;
2241 bus->current_userdata = slot->userdata;
2242 r = l->callback(m, slot->userdata, &error_buffer);
2243 bus->current_userdata = NULL;
2244 bus->current_handler = NULL;
2245 bus->current_slot = sd_bus_slot_unref(slot);
2246
2247 r = bus_maybe_reply_error(m, r, &error_buffer);
2248 if (r != 0)
2249 return r;
2250
2251 }
2252
2253 } while (bus->filter_callbacks_modified);
2254
2255 return 0;
2256 }
2257
2258 static int process_match(sd_bus *bus, sd_bus_message *m) {
2259 int r;
2260
2261 assert(bus);
2262 assert(m);
2263
2264 do {
2265 bus->match_callbacks_modified = false;
2266
2267 r = bus_match_run(bus, &bus->match_callbacks, m);
2268 if (r != 0)
2269 return r;
2270
2271 } while (bus->match_callbacks_modified);
2272
2273 return 0;
2274 }
2275
2276 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2277 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2278 int r;
2279
2280 assert(bus);
2281 assert(m);
2282
2283 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2284 return 0;
2285
2286 if (bus->manual_peer_interface)
2287 return 0;
2288
2289 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2290 return 0;
2291
2292 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2293 return 0;
2294
2295 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2296 return 1;
2297
2298 if (streq_ptr(m->member, "Ping"))
2299 r = sd_bus_message_new_method_return(m, &reply);
2300 else if (streq_ptr(m->member, "GetMachineId")) {
2301 sd_id128_t id;
2302 char sid[33];
2303
2304 r = sd_id128_get_machine(&id);
2305 if (r < 0)
2306 return r;
2307
2308 r = sd_bus_message_new_method_return(m, &reply);
2309 if (r < 0)
2310 return r;
2311
2312 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2313 } else {
2314 r = sd_bus_message_new_method_errorf(
2315 m, &reply,
2316 SD_BUS_ERROR_UNKNOWN_METHOD,
2317 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2318 }
2319
2320 if (r < 0)
2321 return r;
2322
2323 r = sd_bus_send(bus, reply, NULL);
2324 if (r < 0)
2325 return r;
2326
2327 return 1;
2328 }
2329
2330 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2331 assert(bus);
2332 assert(m);
2333
2334 /* If we got a message with a file descriptor which we didn't
2335 * want to accept, then let's drop it. How can this even
2336 * happen? For example, when the kernel queues a message into
2337 * an activatable names's queue which allows fds, and then is
2338 * delivered to us later even though we ourselves did not
2339 * negotiate it. */
2340
2341 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2342 return 0;
2343
2344 if (m->n_fds <= 0)
2345 return 0;
2346
2347 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2348 return 0;
2349
2350 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2351 return 1; /* just eat it up */
2352
2353 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2354 }
2355
2356 static int process_message(sd_bus *bus, sd_bus_message *m) {
2357 int r;
2358
2359 assert(bus);
2360 assert(m);
2361
2362 bus->current_message = m;
2363 bus->iteration_counter++;
2364
2365 log_debug_bus_message(m);
2366
2367 r = process_hello(bus, m);
2368 if (r != 0)
2369 goto finish;
2370
2371 r = process_reply(bus, m);
2372 if (r != 0)
2373 goto finish;
2374
2375 r = process_fd_check(bus, m);
2376 if (r != 0)
2377 goto finish;
2378
2379 r = process_filter(bus, m);
2380 if (r != 0)
2381 goto finish;
2382
2383 r = process_match(bus, m);
2384 if (r != 0)
2385 goto finish;
2386
2387 r = process_builtin(bus, m);
2388 if (r != 0)
2389 goto finish;
2390
2391 r = bus_process_object(bus, m);
2392
2393 finish:
2394 bus->current_message = NULL;
2395 return r;
2396 }
2397
2398 static int dispatch_track(sd_bus *bus) {
2399 assert(bus);
2400
2401 if (!bus->track_queue)
2402 return 0;
2403
2404 bus_track_dispatch(bus->track_queue);
2405 return 1;
2406 }
2407
2408 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2409 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2410 int r;
2411
2412 assert(bus);
2413 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
2414
2415 r = process_timeout(bus);
2416 if (r != 0)
2417 goto null_message;
2418
2419 r = dispatch_wqueue(bus);
2420 if (r != 0)
2421 goto null_message;
2422
2423 r = dispatch_track(bus);
2424 if (r != 0)
2425 goto null_message;
2426
2427 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2428 if (r < 0)
2429 return r;
2430 if (!m)
2431 goto null_message;
2432
2433 r = process_message(bus, m);
2434 if (r != 0)
2435 goto null_message;
2436
2437 if (ret) {
2438 r = sd_bus_message_rewind(m, true);
2439 if (r < 0)
2440 return r;
2441
2442 *ret = m;
2443 m = NULL;
2444 return 1;
2445 }
2446
2447 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2448
2449 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2450 strna(sd_bus_message_get_sender(m)),
2451 strna(sd_bus_message_get_path(m)),
2452 strna(sd_bus_message_get_interface(m)),
2453 strna(sd_bus_message_get_member(m)));
2454
2455 r = sd_bus_reply_method_errorf(
2456 m,
2457 SD_BUS_ERROR_UNKNOWN_OBJECT,
2458 "Unknown object '%s'.", m->path);
2459 if (r < 0)
2460 return r;
2461 }
2462
2463 return 1;
2464
2465 null_message:
2466 if (r >= 0 && ret)
2467 *ret = NULL;
2468
2469 return r;
2470 }
2471
2472 static int bus_exit_now(sd_bus *bus) {
2473 assert(bus);
2474
2475 /* Exit due to close, if this is requested. If this is bus object is attached to an event source, invokes
2476 * sd_event_exit(), otherwise invokes libc exit(). */
2477
2478 if (bus->exited) /* did we already exit? */
2479 return 0;
2480 if (!bus->exit_triggered) /* was the exit condition triggered? */
2481 return 0;
2482 if (!bus->exit_on_disconnect) /* Shall we actually exit on disconnection? */
2483 return 0;
2484
2485 bus->exited = true; /* never exit more than once */
2486
2487 log_debug("Bus connection disconnected, exiting.");
2488
2489 if (bus->event)
2490 return sd_event_exit(bus->event, EXIT_FAILURE);
2491 else
2492 exit(EXIT_FAILURE);
2493
2494 assert_not_reached("exit() didn't exit?");
2495 }
2496
2497 static int process_closing_reply_callback(sd_bus *bus, struct reply_callback *c) {
2498 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2499 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2500 sd_bus_slot *slot;
2501 int r;
2502
2503 assert(bus);
2504 assert(c);
2505
2506 r = bus_message_new_synthetic_error(
2507 bus,
2508 c->cookie,
2509 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2510 &m);
2511 if (r < 0)
2512 return r;
2513
2514 r = bus_seal_synthetic_message(bus, m);
2515 if (r < 0)
2516 return r;
2517
2518 if (c->timeout != 0) {
2519 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2520 c->timeout = 0;
2521 }
2522
2523 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2524 c->cookie = 0;
2525
2526 slot = container_of(c, sd_bus_slot, reply_callback);
2527
2528 bus->iteration_counter++;
2529
2530 bus->current_message = m;
2531 bus->current_slot = sd_bus_slot_ref(slot);
2532 bus->current_handler = c->callback;
2533 bus->current_userdata = slot->userdata;
2534 r = c->callback(m, slot->userdata, &error_buffer);
2535 bus->current_userdata = NULL;
2536 bus->current_handler = NULL;
2537 bus->current_slot = NULL;
2538 bus->current_message = NULL;
2539
2540 if (slot->floating) {
2541 bus_slot_disconnect(slot);
2542 sd_bus_slot_unref(slot);
2543 }
2544
2545 sd_bus_slot_unref(slot);
2546
2547 return bus_maybe_reply_error(m, r, &error_buffer);
2548 }
2549
2550 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2551 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2552 struct reply_callback *c;
2553 int r;
2554
2555 assert(bus);
2556 assert(bus->state == BUS_CLOSING);
2557
2558 /* First, fail all outstanding method calls */
2559 c = ordered_hashmap_first(bus->reply_callbacks);
2560 if (c)
2561 return process_closing_reply_callback(bus, c);
2562
2563 /* Then, fake-drop all remaining bus tracking references */
2564 if (bus->tracks) {
2565 bus_track_close(bus->tracks);
2566 return 1;
2567 }
2568
2569 /* Then, synthesize a Disconnected message */
2570 r = sd_bus_message_new_signal(
2571 bus,
2572 &m,
2573 "/org/freedesktop/DBus/Local",
2574 "org.freedesktop.DBus.Local",
2575 "Disconnected");
2576 if (r < 0)
2577 return r;
2578
2579 bus_message_set_sender_local(bus, m);
2580
2581 r = bus_seal_synthetic_message(bus, m);
2582 if (r < 0)
2583 return r;
2584
2585 sd_bus_close(bus);
2586
2587 bus->current_message = m;
2588 bus->iteration_counter++;
2589
2590 r = process_filter(bus, m);
2591 if (r != 0)
2592 goto finish;
2593
2594 r = process_match(bus, m);
2595 if (r != 0)
2596 goto finish;
2597
2598 /* Nothing else to do, exit now, if the condition holds */
2599 bus->exit_triggered = true;
2600 (void) bus_exit_now(bus);
2601
2602 if (ret) {
2603 *ret = m;
2604 m = NULL;
2605 }
2606
2607 r = 1;
2608
2609 finish:
2610 bus->current_message = NULL;
2611
2612 return r;
2613 }
2614
2615 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2616 BUS_DONT_DESTROY(bus);
2617 int r;
2618
2619 /* Returns 0 when we didn't do anything. This should cause the
2620 * caller to invoke sd_bus_wait() before returning the next
2621 * time. Returns > 0 when we did something, which possibly
2622 * means *ret is filled in with an unprocessed message. */
2623
2624 assert_return(bus, -EINVAL);
2625 assert_return(!bus_pid_changed(bus), -ECHILD);
2626
2627 /* We don't allow recursively invoking sd_bus_process(). */
2628 assert_return(!bus->current_message, -EBUSY);
2629 assert(!bus->current_slot);
2630
2631 switch (bus->state) {
2632
2633 case BUS_UNSET:
2634 return -ENOTCONN;
2635
2636 case BUS_CLOSED:
2637 return -ECONNRESET;
2638
2639 case BUS_OPENING:
2640 r = bus_socket_process_opening(bus);
2641 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2642 bus_enter_closing(bus);
2643 r = 1;
2644 } else if (r < 0)
2645 return r;
2646 if (ret)
2647 *ret = NULL;
2648 return r;
2649
2650 case BUS_AUTHENTICATING:
2651 r = bus_socket_process_authenticating(bus);
2652 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2653 bus_enter_closing(bus);
2654 r = 1;
2655 } else if (r < 0)
2656 return r;
2657
2658 if (ret)
2659 *ret = NULL;
2660
2661 return r;
2662
2663 case BUS_RUNNING:
2664 case BUS_HELLO:
2665 r = process_running(bus, hint_priority, priority, ret);
2666 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2667 bus_enter_closing(bus);
2668 r = 1;
2669
2670 if (ret)
2671 *ret = NULL;
2672 }
2673
2674 return r;
2675
2676 case BUS_CLOSING:
2677 return process_closing(bus, ret);
2678 }
2679
2680 assert_not_reached("Unknown state");
2681 }
2682
2683 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2684 return bus_process_internal(bus, false, 0, ret);
2685 }
2686
2687 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2688 return bus_process_internal(bus, true, priority, ret);
2689 }
2690
2691 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2692 struct pollfd p[2] = {};
2693 int r, e, n;
2694 struct timespec ts;
2695 usec_t m = USEC_INFINITY;
2696
2697 assert(bus);
2698
2699 if (bus->state == BUS_CLOSING)
2700 return 1;
2701
2702 if (!BUS_IS_OPEN(bus->state))
2703 return -ENOTCONN;
2704
2705 e = sd_bus_get_events(bus);
2706 if (e < 0)
2707 return e;
2708
2709 if (need_more)
2710 /* The caller really needs some more data, he doesn't
2711 * care about what's already read, or any timeouts
2712 * except its own. */
2713 e |= POLLIN;
2714 else {
2715 usec_t until;
2716 /* The caller wants to process if there's something to
2717 * process, but doesn't care otherwise */
2718
2719 r = sd_bus_get_timeout(bus, &until);
2720 if (r < 0)
2721 return r;
2722 if (r > 0) {
2723 usec_t nw;
2724 nw = now(CLOCK_MONOTONIC);
2725 m = until > nw ? until - nw : 0;
2726 }
2727 }
2728
2729 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2730 m = timeout_usec;
2731
2732 p[0].fd = bus->input_fd;
2733 if (bus->output_fd == bus->input_fd) {
2734 p[0].events = e;
2735 n = 1;
2736 } else {
2737 p[0].events = e & POLLIN;
2738 p[1].fd = bus->output_fd;
2739 p[1].events = e & POLLOUT;
2740 n = 2;
2741 }
2742
2743 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2744 if (r < 0)
2745 return -errno;
2746
2747 return r > 0 ? 1 : 0;
2748 }
2749
2750 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2751
2752 assert_return(bus, -EINVAL);
2753 assert_return(!bus_pid_changed(bus), -ECHILD);
2754
2755 if (bus->state == BUS_CLOSING)
2756 return 0;
2757
2758 if (!BUS_IS_OPEN(bus->state))
2759 return -ENOTCONN;
2760
2761 if (bus->rqueue_size > 0)
2762 return 0;
2763
2764 return bus_poll(bus, false, timeout_usec);
2765 }
2766
2767 _public_ int sd_bus_flush(sd_bus *bus) {
2768 int r;
2769
2770 assert_return(bus, -EINVAL);
2771 assert_return(!bus_pid_changed(bus), -ECHILD);
2772
2773 if (bus->state == BUS_CLOSING)
2774 return 0;
2775
2776 if (!BUS_IS_OPEN(bus->state))
2777 return -ENOTCONN;
2778
2779 r = bus_ensure_running(bus);
2780 if (r < 0)
2781 return r;
2782
2783 if (bus->wqueue_size <= 0)
2784 return 0;
2785
2786 for (;;) {
2787 r = dispatch_wqueue(bus);
2788 if (r < 0) {
2789 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2790 bus_enter_closing(bus);
2791 return -ECONNRESET;
2792 }
2793
2794 return r;
2795 }
2796
2797 if (bus->wqueue_size <= 0)
2798 return 0;
2799
2800 r = bus_poll(bus, false, (uint64_t) -1);
2801 if (r < 0)
2802 return r;
2803 }
2804 }
2805
2806 _public_ int sd_bus_add_filter(
2807 sd_bus *bus,
2808 sd_bus_slot **slot,
2809 sd_bus_message_handler_t callback,
2810 void *userdata) {
2811
2812 sd_bus_slot *s;
2813
2814 assert_return(bus, -EINVAL);
2815 assert_return(callback, -EINVAL);
2816 assert_return(!bus_pid_changed(bus), -ECHILD);
2817
2818 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2819 if (!s)
2820 return -ENOMEM;
2821
2822 s->filter_callback.callback = callback;
2823
2824 bus->filter_callbacks_modified = true;
2825 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2826
2827 if (slot)
2828 *slot = s;
2829
2830 return 0;
2831 }
2832
2833 _public_ int sd_bus_add_match(
2834 sd_bus *bus,
2835 sd_bus_slot **slot,
2836 const char *match,
2837 sd_bus_message_handler_t callback,
2838 void *userdata) {
2839
2840 struct bus_match_component *components = NULL;
2841 unsigned n_components = 0;
2842 sd_bus_slot *s = NULL;
2843 int r = 0;
2844
2845 assert_return(bus, -EINVAL);
2846 assert_return(match, -EINVAL);
2847 assert_return(!bus_pid_changed(bus), -ECHILD);
2848
2849 r = bus_match_parse(match, &components, &n_components);
2850 if (r < 0)
2851 goto finish;
2852
2853 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2854 if (!s) {
2855 r = -ENOMEM;
2856 goto finish;
2857 }
2858
2859 s->match_callback.callback = callback;
2860
2861 if (bus->bus_client) {
2862 enum bus_match_scope scope;
2863
2864 scope = bus_match_get_scope(components, n_components);
2865
2866 /* Do not install server-side matches for matches
2867 * against the local service, interface or bus path. */
2868 if (scope != BUS_MATCH_LOCAL) {
2869
2870 /* We store the original match string, so that
2871 * we can use it to remove the match again. */
2872
2873 s->match_callback.match_string = strdup(match);
2874 if (!s->match_callback.match_string) {
2875 r = -ENOMEM;
2876 goto finish;
2877 }
2878
2879 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components);
2880 if (r < 0)
2881 goto finish;
2882
2883 s->match_added = true;
2884 }
2885 }
2886
2887 bus->match_callbacks_modified = true;
2888 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2889 if (r < 0)
2890 goto finish;
2891
2892 if (slot)
2893 *slot = s;
2894 s = NULL;
2895
2896 finish:
2897 bus_match_parse_free(components, n_components);
2898 sd_bus_slot_unref(s);
2899
2900 return r;
2901 }
2902
2903 int bus_remove_match_by_string(
2904 sd_bus *bus,
2905 const char *match,
2906 sd_bus_message_handler_t callback,
2907 void *userdata) {
2908
2909 struct bus_match_component *components = NULL;
2910 unsigned n_components = 0;
2911 struct match_callback *c;
2912 int r = 0;
2913
2914 assert_return(bus, -EINVAL);
2915 assert_return(match, -EINVAL);
2916 assert_return(!bus_pid_changed(bus), -ECHILD);
2917
2918 r = bus_match_parse(match, &components, &n_components);
2919 if (r < 0)
2920 goto finish;
2921
2922 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2923 if (r <= 0)
2924 goto finish;
2925
2926 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2927
2928 finish:
2929 bus_match_parse_free(components, n_components);
2930
2931 return r;
2932 }
2933
2934 bool bus_pid_changed(sd_bus *bus) {
2935 assert(bus);
2936
2937 /* We don't support people creating a bus connection and
2938 * keeping it around over a fork(). Let's complain. */
2939
2940 return bus->original_pid != getpid_cached();
2941 }
2942
2943 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2944 sd_bus *bus = userdata;
2945 int r;
2946
2947 assert(bus);
2948
2949 r = sd_bus_process(bus, NULL);
2950 if (r < 0)
2951 return r;
2952
2953 return 1;
2954 }
2955
2956 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2957 sd_bus *bus = userdata;
2958 int r;
2959
2960 assert(bus);
2961
2962 r = sd_bus_process(bus, NULL);
2963 if (r < 0)
2964 return r;
2965
2966 return 1;
2967 }
2968
2969 static int prepare_callback(sd_event_source *s, void *userdata) {
2970 sd_bus *bus = userdata;
2971 int r, e;
2972 usec_t until;
2973
2974 assert(s);
2975 assert(bus);
2976
2977 e = sd_bus_get_events(bus);
2978 if (e < 0)
2979 return e;
2980
2981 if (bus->output_fd != bus->input_fd) {
2982
2983 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2984 if (r < 0)
2985 return r;
2986
2987 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2988 if (r < 0)
2989 return r;
2990 } else {
2991 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2992 if (r < 0)
2993 return r;
2994 }
2995
2996 r = sd_bus_get_timeout(bus, &until);
2997 if (r < 0)
2998 return r;
2999 if (r > 0) {
3000 int j;
3001
3002 j = sd_event_source_set_time(bus->time_event_source, until);
3003 if (j < 0)
3004 return j;
3005 }
3006
3007 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3008 if (r < 0)
3009 return r;
3010
3011 return 1;
3012 }
3013
3014 static int quit_callback(sd_event_source *event, void *userdata) {
3015 sd_bus *bus = userdata;
3016
3017 assert(event);
3018
3019 sd_bus_flush(bus);
3020 sd_bus_close(bus);
3021
3022 return 1;
3023 }
3024
3025 static int attach_io_events(sd_bus *bus) {
3026 int r;
3027
3028 assert(bus);
3029
3030 if (bus->input_fd < 0)
3031 return 0;
3032
3033 if (!bus->event)
3034 return 0;
3035
3036 if (!bus->input_io_event_source) {
3037 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3038 if (r < 0)
3039 return r;
3040
3041 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3042 if (r < 0)
3043 return r;
3044
3045 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3046 if (r < 0)
3047 return r;
3048
3049 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3050 } else
3051 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3052
3053 if (r < 0)
3054 return r;
3055
3056 if (bus->output_fd != bus->input_fd) {
3057 assert(bus->output_fd >= 0);
3058
3059 if (!bus->output_io_event_source) {
3060 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3061 if (r < 0)
3062 return r;
3063
3064 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3065 if (r < 0)
3066 return r;
3067
3068 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3069 } else
3070 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3071
3072 if (r < 0)
3073 return r;
3074 }
3075
3076 return 0;
3077 }
3078
3079 static void detach_io_events(sd_bus *bus) {
3080 assert(bus);
3081
3082 if (bus->input_io_event_source) {
3083 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3084 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3085 }
3086
3087 if (bus->output_io_event_source) {
3088 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3089 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3090 }
3091 }
3092
3093 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3094 int r;
3095
3096 assert_return(bus, -EINVAL);
3097 assert_return(!bus->event, -EBUSY);
3098
3099 assert(!bus->input_io_event_source);
3100 assert(!bus->output_io_event_source);
3101 assert(!bus->time_event_source);
3102
3103 if (event)
3104 bus->event = sd_event_ref(event);
3105 else {
3106 r = sd_event_default(&bus->event);
3107 if (r < 0)
3108 return r;
3109 }
3110
3111 bus->event_priority = priority;
3112
3113 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3114 if (r < 0)
3115 goto fail;
3116
3117 r = sd_event_source_set_priority(bus->time_event_source, priority);
3118 if (r < 0)
3119 goto fail;
3120
3121 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3122 if (r < 0)
3123 goto fail;
3124
3125 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3126 if (r < 0)
3127 goto fail;
3128
3129 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3130 if (r < 0)
3131 goto fail;
3132
3133 r = attach_io_events(bus);
3134 if (r < 0)
3135 goto fail;
3136
3137 return 0;
3138
3139 fail:
3140 sd_bus_detach_event(bus);
3141 return r;
3142 }
3143
3144 _public_ int sd_bus_detach_event(sd_bus *bus) {
3145 assert_return(bus, -EINVAL);
3146
3147 if (!bus->event)
3148 return 0;
3149
3150 detach_io_events(bus);
3151
3152 if (bus->time_event_source) {
3153 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3154 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3155 }
3156
3157 if (bus->quit_event_source) {
3158 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3159 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3160 }
3161
3162 bus->event = sd_event_unref(bus->event);
3163 return 1;
3164 }
3165
3166 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3167 assert_return(bus, NULL);
3168
3169 return bus->event;
3170 }
3171
3172 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3173 assert_return(bus, NULL);
3174
3175 return bus->current_message;
3176 }
3177
3178 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3179 assert_return(bus, NULL);
3180
3181 return bus->current_slot;
3182 }
3183
3184 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3185 assert_return(bus, NULL);
3186
3187 return bus->current_handler;
3188 }
3189
3190 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3191 assert_return(bus, NULL);
3192
3193 return bus->current_userdata;
3194 }
3195
3196 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3197 sd_bus *b = NULL;
3198 int r;
3199
3200 assert(bus_open);
3201 assert(default_bus);
3202
3203 if (!ret)
3204 return !!*default_bus;
3205
3206 if (*default_bus) {
3207 *ret = sd_bus_ref(*default_bus);
3208 return 0;
3209 }
3210
3211 r = bus_open(&b);
3212 if (r < 0)
3213 return r;
3214
3215 b->default_bus_ptr = default_bus;
3216 b->tid = gettid();
3217 *default_bus = b;
3218
3219 *ret = b;
3220 return 1;
3221 }
3222
3223 _public_ int sd_bus_default_system(sd_bus **ret) {
3224 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3225 }
3226
3227
3228 _public_ int sd_bus_default_user(sd_bus **ret) {
3229 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3230 }
3231
3232 _public_ int sd_bus_default(sd_bus **ret) {
3233
3234 const char *e;
3235
3236 /* Let's try our best to reuse another cached connection. If
3237 * the starter bus type is set, connect via our normal
3238 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3239 * we can share the connection with the user/system default
3240 * bus. */
3241
3242 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3243 if (e) {
3244 if (streq(e, "system"))
3245 return sd_bus_default_system(ret);
3246 else if (STR_IN_SET(e, "user", "session"))
3247 return sd_bus_default_user(ret);
3248 }
3249
3250 /* No type is specified, so we have not other option than to
3251 * use the starter address if it is set. */
3252
3253 e = secure_getenv("DBUS_STARTER_ADDRESS");
3254 if (e) {
3255
3256 return bus_default(sd_bus_open, &default_starter_bus, ret);
3257 }
3258
3259 /* Finally, if nothing is set use the cached connection for
3260 * the right scope */
3261
3262 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3263 return sd_bus_default_user(ret);
3264 else
3265 return sd_bus_default_system(ret);
3266 }
3267
3268 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3269 assert_return(b, -EINVAL);
3270 assert_return(tid, -EINVAL);
3271 assert_return(!bus_pid_changed(b), -ECHILD);
3272
3273 if (b->tid != 0) {
3274 *tid = b->tid;
3275 return 0;
3276 }
3277
3278 if (b->event)
3279 return sd_event_get_tid(b->event, tid);
3280
3281 return -ENXIO;
3282 }
3283
3284 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3285 _cleanup_free_ char *e = NULL;
3286 char *ret;
3287
3288 assert_return(object_path_is_valid(prefix), -EINVAL);
3289 assert_return(external_id, -EINVAL);
3290 assert_return(ret_path, -EINVAL);
3291
3292 e = bus_label_escape(external_id);
3293 if (!e)
3294 return -ENOMEM;
3295
3296 ret = strjoin(prefix, "/", e);
3297 if (!ret)
3298 return -ENOMEM;
3299
3300 *ret_path = ret;
3301 return 0;
3302 }
3303
3304 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3305 const char *e;
3306 char *ret;
3307
3308 assert_return(object_path_is_valid(path), -EINVAL);
3309 assert_return(object_path_is_valid(prefix), -EINVAL);
3310 assert_return(external_id, -EINVAL);
3311
3312 e = object_path_startswith(path, prefix);
3313 if (!e) {
3314 *external_id = NULL;
3315 return 0;
3316 }
3317
3318 ret = bus_label_unescape(e);
3319 if (!ret)
3320 return -ENOMEM;
3321
3322 *external_id = ret;
3323 return 1;
3324 }
3325
3326 _public_ int sd_bus_path_encode_many(char **out, const char *path_template, ...) {
3327 _cleanup_strv_free_ char **labels = NULL;
3328 char *path, *path_pos, **label_pos;
3329 const char *sep, *template_pos;
3330 size_t path_length;
3331 va_list list;
3332 int r;
3333
3334 assert_return(out, -EINVAL);
3335 assert_return(path_template, -EINVAL);
3336
3337 path_length = strlen(path_template);
3338
3339 va_start(list, path_template);
3340 for (sep = strchr(path_template, '%'); sep; sep = strchr(sep + 1, '%')) {
3341 const char *arg;
3342 char *label;
3343
3344 arg = va_arg(list, const char *);
3345 if (!arg) {
3346 va_end(list);
3347 return -EINVAL;
3348 }
3349
3350 label = bus_label_escape(arg);
3351 if (!label) {
3352 va_end(list);
3353 return -ENOMEM;
3354 }
3355
3356 r = strv_consume(&labels, label);
3357 if (r < 0) {
3358 va_end(list);
3359 return r;
3360 }
3361
3362 /* add label length, but account for the format character */
3363 path_length += strlen(label) - 1;
3364 }
3365 va_end(list);
3366
3367 path = malloc(path_length + 1);
3368 if (!path)
3369 return -ENOMEM;
3370
3371 path_pos = path;
3372 label_pos = labels;
3373
3374 for (template_pos = path_template; *template_pos; ) {
3375 sep = strchrnul(template_pos, '%');
3376 path_pos = mempcpy(path_pos, template_pos, sep - template_pos);
3377 if (!*sep)
3378 break;
3379
3380 path_pos = stpcpy(path_pos, *label_pos++);
3381 template_pos = sep + 1;
3382 }
3383
3384 *path_pos = 0;
3385 *out = path;
3386 return 0;
3387 }
3388
3389 _public_ int sd_bus_path_decode_many(const char *path, const char *path_template, ...) {
3390 _cleanup_strv_free_ char **labels = NULL;
3391 const char *template_pos, *path_pos;
3392 char **label_pos;
3393 va_list list;
3394 int r;
3395
3396 /*
3397 * This decodes an object-path based on a template argument. The
3398 * template consists of a verbatim path, optionally including special
3399 * directives:
3400 *
3401 * - Each occurrence of '%' in the template matches an arbitrary
3402 * substring of a label in the given path. At most one such
3403 * directive is allowed per label. For each such directive, the
3404 * caller must provide an output parameter (char **) via va_arg. If
3405 * NULL is passed, the given label is verified, but not returned.
3406 * For each matched label, the *decoded* label is stored in the
3407 * passed output argument, and the caller is responsible to free
3408 * it. Note that the output arguments are only modified if the
3409 * actualy path matched the template. Otherwise, they're left
3410 * untouched.
3411 *
3412 * This function returns <0 on error, 0 if the path does not match the
3413 * template, 1 if it matched.
3414 */
3415
3416 assert_return(path, -EINVAL);
3417 assert_return(path_template, -EINVAL);
3418
3419 path_pos = path;
3420
3421 for (template_pos = path_template; *template_pos; ) {
3422 const char *sep;
3423 size_t length;
3424 char *label;
3425
3426 /* verify everything until the next '%' matches verbatim */
3427 sep = strchrnul(template_pos, '%');
3428 length = sep - template_pos;
3429 if (strncmp(path_pos, template_pos, length))
3430 return 0;
3431
3432 path_pos += length;
3433 template_pos += length;
3434
3435 if (!*template_pos)
3436 break;
3437
3438 /* We found the next '%' character. Everything up until here
3439 * matched. We now skip ahead to the end of this label and make
3440 * sure it matches the tail of the label in the path. Then we
3441 * decode the string in-between and save it for later use. */
3442
3443 ++template_pos; /* skip over '%' */
3444
3445 sep = strchrnul(template_pos, '/');
3446 length = sep - template_pos; /* length of suffix to match verbatim */
3447
3448 /* verify the suffixes match */
3449 sep = strchrnul(path_pos, '/');
3450 if (sep - path_pos < (ssize_t)length ||
3451 strncmp(sep - length, template_pos, length))
3452 return 0;
3453
3454 template_pos += length; /* skip over matched label */
3455 length = sep - path_pos - length; /* length of sub-label to decode */
3456
3457 /* store unescaped label for later use */
3458 label = bus_label_unescape_n(path_pos, length);
3459 if (!label)
3460 return -ENOMEM;
3461
3462 r = strv_consume(&labels, label);
3463 if (r < 0)
3464 return r;
3465
3466 path_pos = sep; /* skip decoded label and suffix */
3467 }
3468
3469 /* end of template must match end of path */
3470 if (*path_pos)
3471 return 0;
3472
3473 /* copy the labels over to the caller */
3474 va_start(list, path_template);
3475 for (label_pos = labels; label_pos && *label_pos; ++label_pos) {
3476 char **arg;
3477
3478 arg = va_arg(list, char **);
3479 if (arg)
3480 *arg = *label_pos;
3481 else
3482 free(*label_pos);
3483 }
3484 va_end(list);
3485
3486 free(labels);
3487 labels = NULL;
3488 return 1;
3489 }
3490
3491 _public_ int sd_bus_try_close(sd_bus *bus) {
3492 assert_return(bus, -EINVAL);
3493 assert_return(!bus_pid_changed(bus), -ECHILD);
3494
3495 return -EOPNOTSUPP;
3496 }
3497
3498 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3499 assert_return(bus, -EINVAL);
3500 assert_return(description, -EINVAL);
3501 assert_return(bus->description, -ENXIO);
3502 assert_return(!bus_pid_changed(bus), -ECHILD);
3503
3504 *description = bus->description;
3505 return 0;
3506 }
3507
3508 int bus_get_root_path(sd_bus *bus) {
3509 int r;
3510
3511 if (bus->cgroup_root)
3512 return 0;
3513
3514 r = cg_get_root_path(&bus->cgroup_root);
3515 if (r == -ENOENT) {
3516 bus->cgroup_root = strdup("/");
3517 if (!bus->cgroup_root)
3518 return -ENOMEM;
3519
3520 r = 0;
3521 }
3522
3523 return r;
3524 }
3525
3526 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3527 assert_return(bus, -EINVAL);
3528 assert_return(scope, -EINVAL);
3529 assert_return(!bus_pid_changed(bus), -ECHILD);
3530
3531 if (bus->is_user) {
3532 *scope = "user";
3533 return 0;
3534 }
3535
3536 if (bus->is_system) {
3537 *scope = "system";
3538 return 0;
3539 }
3540
3541 return -ENODATA;
3542 }
3543
3544 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3545
3546 assert_return(bus, -EINVAL);
3547 assert_return(address, -EINVAL);
3548 assert_return(!bus_pid_changed(bus), -ECHILD);
3549
3550 if (bus->address) {
3551 *address = bus->address;
3552 return 0;
3553 }
3554
3555 return -ENODATA;
3556 }
3557
3558 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3559 assert_return(bus, -EINVAL);
3560 assert_return(mask, -EINVAL);
3561 assert_return(!bus_pid_changed(bus), -ECHILD);
3562
3563 *mask = bus->creds_mask;
3564 return 0;
3565 }
3566
3567 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3568 assert_return(bus, -EINVAL);
3569 assert_return(!bus_pid_changed(bus), -ECHILD);
3570
3571 return bus->bus_client;
3572 }
3573
3574 _public_ int sd_bus_is_server(sd_bus *bus) {
3575 assert_return(bus, -EINVAL);
3576 assert_return(!bus_pid_changed(bus), -ECHILD);
3577
3578 return bus->is_server;
3579 }
3580
3581 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3582 assert_return(bus, -EINVAL);
3583 assert_return(!bus_pid_changed(bus), -ECHILD);
3584
3585 return bus->anonymous_auth;
3586 }
3587
3588 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3589 assert_return(bus, -EINVAL);
3590 assert_return(!bus_pid_changed(bus), -ECHILD);
3591
3592 return bus->trusted;
3593 }
3594
3595 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3596 assert_return(bus, -EINVAL);
3597 assert_return(!bus_pid_changed(bus), -ECHILD);
3598
3599 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);
3600 }
3601
3602 static void flush_close(sd_bus *bus) {
3603 if (!bus)
3604 return;
3605
3606 /* Flushes and closes the specified bus. We take a ref before,
3607 * to ensure the flushing does not cause the bus to be
3608 * unreferenced. */
3609
3610 sd_bus_flush_close_unref(sd_bus_ref(bus));
3611 }
3612
3613 _public_ void sd_bus_default_flush_close(void) {
3614 flush_close(default_starter_bus);
3615 flush_close(default_user_bus);
3616 flush_close(default_system_bus);
3617 }
3618
3619 _public_ int sd_bus_set_exit_on_disconnect(sd_bus *bus, int b) {
3620 assert_return(bus, -EINVAL);
3621
3622 /* Turns on exit-on-disconnect, and triggers it immediately if the bus connection was already
3623 * disconnected. Note that this is triggered exclusively on disconnections triggered by the server side, never
3624 * from the client side. */
3625 bus->exit_on_disconnect = b;
3626
3627 /* If the exit condition was triggered already, exit immediately. */
3628 return bus_exit_now(bus);
3629 }
3630
3631 _public_ int sd_bus_get_exit_on_disconnect(sd_bus *bus) {
3632 assert_return(bus, -EINVAL);
3633
3634 return bus->exit_on_disconnect;
3635 }
systemd for Proxmox projects