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