]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd/sd-bus/sd-bus.c
projects / thirdparty / systemd.git / blob
? search:


28fc19e2cf2d7b935b35371f2955ca5e256a1d54
[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_func, uint64_compare_func);
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 r = c->callback(bus, m, slot->userdata, &error_buffer);
2106 bus->current_slot = sd_bus_slot_unref(slot);
2107 bus->current_message = NULL;
2108
2109 if (slot->floating) {
2110 bus_slot_disconnect(slot);
2111 sd_bus_slot_unref(slot);
2112 }
2113
2114 return bus_maybe_reply_error(m, r, &error_buffer);
2115 }
2116
2117 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2118 assert(bus);
2119 assert(m);
2120
2121 if (bus->state != BUS_HELLO)
2122 return 0;
2123
2124 /* Let's make sure the first message on the bus is the HELLO
2125 * reply. But note that we don't actually parse the message
2126 * here (we leave that to the usual handling), we just verify
2127 * we don't let any earlier msg through. */
2128
2129 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2130 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2131 return -EIO;
2132
2133 if (m->reply_cookie != 1)
2134 return -EIO;
2135
2136 return 0;
2137 }
2138
2139 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2140 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2141 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2142 struct reply_callback *c;
2143 sd_bus_slot *slot;
2144 int r;
2145
2146 assert(bus);
2147 assert(m);
2148
2149 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2150 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2151 return 0;
2152
2153 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2154 return 0;
2155
2156 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2157 return 0;
2158
2159 c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2160 if (!c)
2161 return 0;
2162
2163 c->cookie = 0;
2164
2165 slot = container_of(c, sd_bus_slot, reply_callback);
2166
2167 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2168
2169 /* If the reply contained a file descriptor which we
2170 * didn't want we pass an error instead. */
2171
2172 r = bus_message_new_synthetic_error(
2173 bus,
2174 m->reply_cookie,
2175 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2176 &synthetic_reply);
2177 if (r < 0)
2178 return r;
2179
2180 r = bus_seal_synthetic_message(bus, synthetic_reply);
2181 if (r < 0)
2182 return r;
2183
2184 m = synthetic_reply;
2185 } else {
2186 r = sd_bus_message_rewind(m, true);
2187 if (r < 0)
2188 return r;
2189 }
2190
2191 if (c->timeout != 0) {
2192 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2193 c->timeout = 0;
2194 }
2195
2196 bus->current_slot = sd_bus_slot_ref(slot);
2197 r = c->callback(bus, m, slot->userdata, &error_buffer);
2198 bus->current_slot = sd_bus_slot_unref(slot);
2199
2200 if (slot->floating) {
2201 bus_slot_disconnect(slot);
2202 sd_bus_slot_unref(slot);
2203 }
2204
2205 return bus_maybe_reply_error(m, r, &error_buffer);
2206 }
2207
2208 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2209 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2210 struct filter_callback *l;
2211 int r;
2212
2213 assert(bus);
2214 assert(m);
2215
2216 do {
2217 bus->filter_callbacks_modified = false;
2218
2219 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2220 sd_bus_slot *slot;
2221
2222 if (bus->filter_callbacks_modified)
2223 break;
2224
2225 /* Don't run this more than once per iteration */
2226 if (l->last_iteration == bus->iteration_counter)
2227 continue;
2228
2229 l->last_iteration = bus->iteration_counter;
2230
2231 r = sd_bus_message_rewind(m, true);
2232 if (r < 0)
2233 return r;
2234
2235 slot = container_of(l, sd_bus_slot, filter_callback);
2236
2237 bus->current_slot = sd_bus_slot_ref(slot);
2238 r = l->callback(bus, m, slot->userdata, &error_buffer);
2239 bus->current_slot = sd_bus_slot_unref(slot);
2240
2241 r = bus_maybe_reply_error(m, r, &error_buffer);
2242 if (r != 0)
2243 return r;
2244
2245 }
2246
2247 } while (bus->filter_callbacks_modified);
2248
2249 return 0;
2250 }
2251
2252 static int process_match(sd_bus *bus, sd_bus_message *m) {
2253 int r;
2254
2255 assert(bus);
2256 assert(m);
2257
2258 do {
2259 bus->match_callbacks_modified = false;
2260
2261 r = bus_match_run(bus, &bus->match_callbacks, m);
2262 if (r != 0)
2263 return r;
2264
2265 } while (bus->match_callbacks_modified);
2266
2267 return 0;
2268 }
2269
2270 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2271 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2272 int r;
2273
2274 assert(bus);
2275 assert(m);
2276
2277 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2278 return 0;
2279
2280 if (bus->manual_peer_interface)
2281 return 0;
2282
2283 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2284 return 0;
2285
2286 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2287 return 0;
2288
2289 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2290 return 1;
2291
2292 if (streq_ptr(m->member, "Ping"))
2293 r = sd_bus_message_new_method_return(m, &reply);
2294 else if (streq_ptr(m->member, "GetMachineId")) {
2295 sd_id128_t id;
2296 char sid[33];
2297
2298 r = sd_id128_get_machine(&id);
2299 if (r < 0)
2300 return r;
2301
2302 r = sd_bus_message_new_method_return(m, &reply);
2303 if (r < 0)
2304 return r;
2305
2306 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2307 } else {
2308 r = sd_bus_message_new_method_errorf(
2309 m, &reply,
2310 SD_BUS_ERROR_UNKNOWN_METHOD,
2311 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2312 }
2313
2314 if (r < 0)
2315 return r;
2316
2317 r = sd_bus_send(bus, reply, NULL);
2318 if (r < 0)
2319 return r;
2320
2321 return 1;
2322 }
2323
2324 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2325 assert(bus);
2326 assert(m);
2327
2328 /* If we got a message with a file descriptor which we didn't
2329 * want to accept, then let's drop it. How can this even
2330 * happen? For example, when the kernel queues a message into
2331 * an activatable names's queue which allows fds, and then is
2332 * delivered to us later even though we ourselves did not
2333 * negotiate it. */
2334
2335 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2336 return 0;
2337
2338 if (m->n_fds <= 0)
2339 return 0;
2340
2341 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2342 return 0;
2343
2344 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2345 return 1; /* just eat it up */
2346
2347 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2348 }
2349
2350 static int process_message(sd_bus *bus, sd_bus_message *m) {
2351 int r;
2352
2353 assert(bus);
2354 assert(m);
2355
2356 bus->current_message = m;
2357 bus->iteration_counter++;
2358
2359 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2360 bus_message_type_to_string(m->header->type),
2361 strna(sd_bus_message_get_sender(m)),
2362 strna(sd_bus_message_get_destination(m)),
2363 strna(sd_bus_message_get_path(m)),
2364 strna(sd_bus_message_get_interface(m)),
2365 strna(sd_bus_message_get_member(m)),
2366 BUS_MESSAGE_COOKIE(m),
2367 m->reply_cookie,
2368 strna(m->error.message));
2369
2370 r = process_hello(bus, m);
2371 if (r != 0)
2372 goto finish;
2373
2374 r = process_reply(bus, m);
2375 if (r != 0)
2376 goto finish;
2377
2378 r = process_fd_check(bus, m);
2379 if (r != 0)
2380 goto finish;
2381
2382 r = process_filter(bus, m);
2383 if (r != 0)
2384 goto finish;
2385
2386 r = process_match(bus, m);
2387 if (r != 0)
2388 goto finish;
2389
2390 r = process_builtin(bus, m);
2391 if (r != 0)
2392 goto finish;
2393
2394 r = bus_process_object(bus, m);
2395
2396 finish:
2397 bus->current_message = NULL;
2398 return r;
2399 }
2400
2401 static int dispatch_track(sd_bus *bus) {
2402 assert(bus);
2403
2404 if (!bus->track_queue)
2405 return 0;
2406
2407 bus_track_dispatch(bus->track_queue);
2408 return 1;
2409 }
2410
2411 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2412 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2413 int r;
2414
2415 assert(bus);
2416 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2417
2418 r = process_timeout(bus);
2419 if (r != 0)
2420 goto null_message;
2421
2422 r = dispatch_wqueue(bus);
2423 if (r != 0)
2424 goto null_message;
2425
2426 r = dispatch_track(bus);
2427 if (r != 0)
2428 goto null_message;
2429
2430 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2431 if (r < 0)
2432 return r;
2433 if (!m)
2434 goto null_message;
2435
2436 r = process_message(bus, m);
2437 if (r != 0)
2438 goto null_message;
2439
2440 if (ret) {
2441 r = sd_bus_message_rewind(m, true);
2442 if (r < 0)
2443 return r;
2444
2445 *ret = m;
2446 m = NULL;
2447 return 1;
2448 }
2449
2450 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2451
2452 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2453 strna(sd_bus_message_get_sender(m)),
2454 strna(sd_bus_message_get_path(m)),
2455 strna(sd_bus_message_get_interface(m)),
2456 strna(sd_bus_message_get_member(m)));
2457
2458 r = sd_bus_reply_method_errorf(
2459 m,
2460 SD_BUS_ERROR_UNKNOWN_OBJECT,
2461 "Unknown object '%s'.", m->path);
2462 if (r < 0)
2463 return r;
2464 }
2465
2466 return 1;
2467
2468 null_message:
2469 if (r >= 0 && ret)
2470 *ret = NULL;
2471
2472 return r;
2473 }
2474
2475 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2476 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2477 struct reply_callback *c;
2478 int r;
2479
2480 assert(bus);
2481 assert(bus->state == BUS_CLOSING);
2482
2483 c = hashmap_first(bus->reply_callbacks);
2484 if (c) {
2485 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2486 sd_bus_slot *slot;
2487
2488 /* First, fail all outstanding method calls */
2489 r = bus_message_new_synthetic_error(
2490 bus,
2491 c->cookie,
2492 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2493 &m);
2494 if (r < 0)
2495 return r;
2496
2497 r = bus_seal_synthetic_message(bus, m);
2498 if (r < 0)
2499 return r;
2500
2501 if (c->timeout != 0) {
2502 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2503 c->timeout = 0;
2504 }
2505
2506 hashmap_remove(bus->reply_callbacks, &c->cookie);
2507 c->cookie = 0;
2508
2509 slot = container_of(c, sd_bus_slot, reply_callback);
2510
2511 bus->iteration_counter++;
2512
2513 bus->current_message = m;
2514 bus->current_slot = sd_bus_slot_ref(slot);
2515 r = c->callback(bus, m, slot->userdata, &error_buffer);
2516 bus->current_slot = sd_bus_slot_unref(slot);
2517 bus->current_message = NULL;
2518
2519 if (slot->floating) {
2520 bus_slot_disconnect(slot);
2521 sd_bus_slot_unref(slot);
2522 }
2523
2524 return bus_maybe_reply_error(m, r, &error_buffer);
2525 }
2526
2527 /* Then, synthesize a Disconnected message */
2528 r = sd_bus_message_new_signal(
2529 bus,
2530 &m,
2531 "/org/freedesktop/DBus/Local",
2532 "org.freedesktop.DBus.Local",
2533 "Disconnected");
2534 if (r < 0)
2535 return r;
2536
2537 m->sender = "org.freedesktop.DBus.Local";
2538
2539 r = bus_seal_synthetic_message(bus, m);
2540 if (r < 0)
2541 return r;
2542
2543 sd_bus_close(bus);
2544
2545 bus->current_message = m;
2546 bus->iteration_counter++;
2547
2548 r = process_filter(bus, m);
2549 if (r != 0)
2550 goto finish;
2551
2552 r = process_match(bus, m);
2553 if (r != 0)
2554 goto finish;
2555
2556 if (ret) {
2557 *ret = m;
2558 m = NULL;
2559 }
2560
2561 r = 1;
2562
2563 finish:
2564 bus->current_message = NULL;
2565
2566 return r;
2567 }
2568
2569 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2570 BUS_DONT_DESTROY(bus);
2571 int r;
2572
2573 /* Returns 0 when we didn't do anything. This should cause the
2574 * caller to invoke sd_bus_wait() before returning the next
2575 * time. Returns > 0 when we did something, which possibly
2576 * means *ret is filled in with an unprocessed message. */
2577
2578 assert_return(bus, -EINVAL);
2579 assert_return(!bus_pid_changed(bus), -ECHILD);
2580
2581 /* We don't allow recursively invoking sd_bus_process(). */
2582 assert_return(!bus->current_message, -EBUSY);
2583 assert(!bus->current_slot);
2584
2585 switch (bus->state) {
2586
2587 case BUS_UNSET:
2588 return -ENOTCONN;
2589
2590 case BUS_CLOSED:
2591 return -ECONNRESET;
2592
2593 case BUS_OPENING:
2594 r = bus_socket_process_opening(bus);
2595 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2596 bus_enter_closing(bus);
2597 r = 1;
2598 } else if (r < 0)
2599 return r;
2600 if (ret)
2601 *ret = NULL;
2602 return r;
2603
2604 case BUS_AUTHENTICATING:
2605 r = bus_socket_process_authenticating(bus);
2606 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2607 bus_enter_closing(bus);
2608 r = 1;
2609 } else if (r < 0)
2610 return r;
2611
2612 if (ret)
2613 *ret = NULL;
2614
2615 return r;
2616
2617 case BUS_RUNNING:
2618 case BUS_HELLO:
2619 r = process_running(bus, hint_priority, priority, ret);
2620 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2621 bus_enter_closing(bus);
2622 r = 1;
2623
2624 if (ret)
2625 *ret = NULL;
2626 }
2627
2628 return r;
2629
2630 case BUS_CLOSING:
2631 return process_closing(bus, ret);
2632 }
2633
2634 assert_not_reached("Unknown state");
2635 }
2636
2637 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2638 return bus_process_internal(bus, false, 0, ret);
2639 }
2640
2641 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2642 return bus_process_internal(bus, true, priority, ret);
2643 }
2644
2645 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2646 struct pollfd p[2] = {};
2647 int r, e, n;
2648 struct timespec ts;
2649 usec_t m = (usec_t) -1;
2650
2651 assert(bus);
2652
2653 if (bus->state == BUS_CLOSING)
2654 return 1;
2655
2656 if (!BUS_IS_OPEN(bus->state))
2657 return -ENOTCONN;
2658
2659 e = sd_bus_get_events(bus);
2660 if (e < 0)
2661 return e;
2662
2663 if (need_more)
2664 /* The caller really needs some more data, he doesn't
2665 * care about what's already read, or any timeouts
2666 * except its own.*/
2667 e |= POLLIN;
2668 else {
2669 usec_t until;
2670 /* The caller wants to process if there's something to
2671 * process, but doesn't care otherwise */
2672
2673 r = sd_bus_get_timeout(bus, &until);
2674 if (r < 0)
2675 return r;
2676 if (r > 0) {
2677 usec_t nw;
2678 nw = now(CLOCK_MONOTONIC);
2679 m = until > nw ? until - nw : 0;
2680 }
2681 }
2682
2683 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2684 m = timeout_usec;
2685
2686 p[0].fd = bus->input_fd;
2687 if (bus->output_fd == bus->input_fd) {
2688 p[0].events = e;
2689 n = 1;
2690 } else {
2691 p[0].events = e & POLLIN;
2692 p[1].fd = bus->output_fd;
2693 p[1].events = e & POLLOUT;
2694 n = 2;
2695 }
2696
2697 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2698 if (r < 0)
2699 return -errno;
2700
2701 return r > 0 ? 1 : 0;
2702 }
2703
2704 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2705
2706 assert_return(bus, -EINVAL);
2707 assert_return(!bus_pid_changed(bus), -ECHILD);
2708
2709 if (bus->state == BUS_CLOSING)
2710 return 0;
2711
2712 if (!BUS_IS_OPEN(bus->state))
2713 return -ENOTCONN;
2714
2715 if (bus->rqueue_size > 0)
2716 return 0;
2717
2718 return bus_poll(bus, false, timeout_usec);
2719 }
2720
2721 _public_ int sd_bus_flush(sd_bus *bus) {
2722 int r;
2723
2724 assert_return(bus, -EINVAL);
2725 assert_return(!bus_pid_changed(bus), -ECHILD);
2726
2727 if (bus->state == BUS_CLOSING)
2728 return 0;
2729
2730 if (!BUS_IS_OPEN(bus->state))
2731 return -ENOTCONN;
2732
2733 r = bus_ensure_running(bus);
2734 if (r < 0)
2735 return r;
2736
2737 if (bus->wqueue_size <= 0)
2738 return 0;
2739
2740 for (;;) {
2741 r = dispatch_wqueue(bus);
2742 if (r < 0) {
2743 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2744 bus_enter_closing(bus);
2745 return -ECONNRESET;
2746 }
2747
2748 return r;
2749 }
2750
2751 if (bus->wqueue_size <= 0)
2752 return 0;
2753
2754 r = bus_poll(bus, false, (uint64_t) -1);
2755 if (r < 0)
2756 return r;
2757 }
2758 }
2759
2760 _public_ int sd_bus_add_filter(
2761 sd_bus *bus,
2762 sd_bus_slot **slot,
2763 sd_bus_message_handler_t callback,
2764 void *userdata) {
2765
2766 sd_bus_slot *s;
2767
2768 assert_return(bus, -EINVAL);
2769 assert_return(callback, -EINVAL);
2770 assert_return(!bus_pid_changed(bus), -ECHILD);
2771
2772 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2773 if (!s)
2774 return -ENOMEM;
2775
2776 s->filter_callback.callback = callback;
2777
2778 bus->filter_callbacks_modified = true;
2779 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2780
2781 if (slot)
2782 *slot = s;
2783
2784 return 0;
2785 }
2786
2787 _public_ int sd_bus_add_match(
2788 sd_bus *bus,
2789 sd_bus_slot **slot,
2790 const char *match,
2791 sd_bus_message_handler_t callback,
2792 void *userdata) {
2793
2794 struct bus_match_component *components = NULL;
2795 unsigned n_components = 0;
2796 sd_bus_slot *s = NULL;
2797 int r = 0;
2798
2799 assert_return(bus, -EINVAL);
2800 assert_return(match, -EINVAL);
2801 assert_return(!bus_pid_changed(bus), -ECHILD);
2802
2803 r = bus_match_parse(match, &components, &n_components);
2804 if (r < 0)
2805 goto finish;
2806
2807 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2808 if (!s) {
2809 r = -ENOMEM;
2810 goto finish;
2811 }
2812
2813 s->match_callback.callback = callback;
2814 s->match_callback.cookie = ++bus->match_cookie;
2815
2816 if (bus->bus_client) {
2817
2818 if (!bus->is_kernel) {
2819 /* When this is not a kernel transport, we
2820 * store the original match string, so that we
2821 * can use it to remove the match again */
2822
2823 s->match_callback.match_string = strdup(match);
2824 if (!s->match_callback.match_string) {
2825 r = -ENOMEM;
2826 goto finish;
2827 }
2828 }
2829
2830 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2831 if (r < 0)
2832 goto finish;
2833 }
2834
2835 bus->match_callbacks_modified = true;
2836 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2837 if (r < 0)
2838 goto finish;
2839
2840 if (slot)
2841 *slot = s;
2842 s = NULL;
2843
2844 finish:
2845 bus_match_parse_free(components, n_components);
2846 sd_bus_slot_unref(s);
2847
2848 return r;
2849 }
2850
2851 int bus_remove_match_by_string(
2852 sd_bus *bus,
2853 const char *match,
2854 sd_bus_message_handler_t callback,
2855 void *userdata) {
2856
2857 struct bus_match_component *components = NULL;
2858 unsigned n_components = 0;
2859 struct match_callback *c;
2860 int r = 0;
2861
2862 assert_return(bus, -EINVAL);
2863 assert_return(match, -EINVAL);
2864 assert_return(!bus_pid_changed(bus), -ECHILD);
2865
2866 r = bus_match_parse(match, &components, &n_components);
2867 if (r < 0)
2868 goto finish;
2869
2870 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2871 if (r <= 0)
2872 goto finish;
2873
2874 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2875
2876 finish:
2877 bus_match_parse_free(components, n_components);
2878
2879 return r;
2880 }
2881
2882 bool bus_pid_changed(sd_bus *bus) {
2883 assert(bus);
2884
2885 /* We don't support people creating a bus connection and
2886 * keeping it around over a fork(). Let's complain. */
2887
2888 return bus->original_pid != getpid();
2889 }
2890
2891 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2892 sd_bus *bus = userdata;
2893 int r;
2894
2895 assert(bus);
2896
2897 r = sd_bus_process(bus, NULL);
2898 if (r < 0)
2899 return r;
2900
2901 return 1;
2902 }
2903
2904 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2905 sd_bus *bus = userdata;
2906 int r;
2907
2908 assert(bus);
2909
2910 r = sd_bus_process(bus, NULL);
2911 if (r < 0)
2912 return r;
2913
2914 return 1;
2915 }
2916
2917 static int prepare_callback(sd_event_source *s, void *userdata) {
2918 sd_bus *bus = userdata;
2919 int r, e;
2920 usec_t until;
2921
2922 assert(s);
2923 assert(bus);
2924
2925 e = sd_bus_get_events(bus);
2926 if (e < 0)
2927 return e;
2928
2929 if (bus->output_fd != bus->input_fd) {
2930
2931 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2932 if (r < 0)
2933 return r;
2934
2935 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2936 if (r < 0)
2937 return r;
2938 } else {
2939 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2940 if (r < 0)
2941 return r;
2942 }
2943
2944 r = sd_bus_get_timeout(bus, &until);
2945 if (r < 0)
2946 return r;
2947 if (r > 0) {
2948 int j;
2949
2950 j = sd_event_source_set_time(bus->time_event_source, until);
2951 if (j < 0)
2952 return j;
2953 }
2954
2955 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2956 if (r < 0)
2957 return r;
2958
2959 return 1;
2960 }
2961
2962 static int quit_callback(sd_event_source *event, void *userdata) {
2963 sd_bus *bus = userdata;
2964
2965 assert(event);
2966
2967 sd_bus_flush(bus);
2968 sd_bus_close(bus);
2969
2970 return 1;
2971 }
2972
2973 static int attach_io_events(sd_bus *bus) {
2974 int r;
2975
2976 assert(bus);
2977
2978 if (bus->input_fd < 0)
2979 return 0;
2980
2981 if (!bus->event)
2982 return 0;
2983
2984 if (!bus->input_io_event_source) {
2985 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
2986 if (r < 0)
2987 return r;
2988
2989 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2990 if (r < 0)
2991 return r;
2992
2993 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
2994 } else
2995 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
2996
2997 if (r < 0)
2998 return r;
2999
3000 if (bus->output_fd != bus->input_fd) {
3001 assert(bus->output_fd >= 0);
3002
3003 if (!bus->output_io_event_source) {
3004 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3005 if (r < 0)
3006 return r;
3007
3008 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3009 } else
3010 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3011
3012 if (r < 0)
3013 return r;
3014 }
3015
3016 return 0;
3017 }
3018
3019 static void detach_io_events(sd_bus *bus) {
3020 assert(bus);
3021
3022 if (bus->input_io_event_source) {
3023 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3024 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3025 }
3026
3027 if (bus->output_io_event_source) {
3028 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3029 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3030 }
3031 }
3032
3033 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3034 int r;
3035
3036 assert_return(bus, -EINVAL);
3037 assert_return(!bus->event, -EBUSY);
3038
3039 assert(!bus->input_io_event_source);
3040 assert(!bus->output_io_event_source);
3041 assert(!bus->time_event_source);
3042
3043 if (event)
3044 bus->event = sd_event_ref(event);
3045 else {
3046 r = sd_event_default(&bus->event);
3047 if (r < 0)
3048 return r;
3049 }
3050
3051 bus->event_priority = priority;
3052
3053 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3054 if (r < 0)
3055 goto fail;
3056
3057 r = sd_event_source_set_priority(bus->time_event_source, priority);
3058 if (r < 0)
3059 goto fail;
3060
3061 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3062 if (r < 0)
3063 goto fail;
3064
3065 r = attach_io_events(bus);
3066 if (r < 0)
3067 goto fail;
3068
3069 return 0;
3070
3071 fail:
3072 sd_bus_detach_event(bus);
3073 return r;
3074 }
3075
3076 _public_ int sd_bus_detach_event(sd_bus *bus) {
3077 assert_return(bus, -EINVAL);
3078
3079 if (!bus->event)
3080 return 0;
3081
3082 detach_io_events(bus);
3083
3084 if (bus->time_event_source) {
3085 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3086 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3087 }
3088
3089 if (bus->quit_event_source) {
3090 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3091 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3092 }
3093
3094 bus->event = sd_event_unref(bus->event);
3095 return 1;
3096 }
3097
3098 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3099 assert_return(bus, NULL);
3100
3101 return bus->event;
3102 }
3103
3104 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3105 assert_return(bus, NULL);
3106
3107 return bus->current_message;
3108 }
3109
3110 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3111 assert_return(bus, NULL);
3112
3113 return bus->current_slot;
3114 }
3115
3116 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3117 sd_bus *b = NULL;
3118 int r;
3119
3120 assert(bus_open);
3121 assert(default_bus);
3122
3123 if (!ret)
3124 return !!*default_bus;
3125
3126 if (*default_bus) {
3127 *ret = sd_bus_ref(*default_bus);
3128 return 0;
3129 }
3130
3131 r = bus_open(&b);
3132 if (r < 0)
3133 return r;
3134
3135 b->default_bus_ptr = default_bus;
3136 b->tid = gettid();
3137 *default_bus = b;
3138
3139 *ret = b;
3140 return 1;
3141 }
3142
3143 _public_ int sd_bus_default_system(sd_bus **ret) {
3144 static thread_local sd_bus *default_system_bus = NULL;
3145
3146 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3147 }
3148
3149 _public_ int sd_bus_default_user(sd_bus **ret) {
3150 static thread_local sd_bus *default_user_bus = NULL;
3151
3152 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3153 }
3154
3155 _public_ int sd_bus_default(sd_bus **ret) {
3156
3157 const char *e;
3158
3159 /* Let's try our best to reuse another cached connection. If
3160 * the starter bus type is set, connect via our normal
3161 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3162 * we can share the connection with the user/system default
3163 * bus. */
3164
3165 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3166 if (e) {
3167 if (streq(e, "system"))
3168 return sd_bus_default_system(ret);
3169 else if (STR_IN_SET(e, "user", "session"))
3170 return sd_bus_default_user(ret);
3171 }
3172
3173 /* No type is specified, so we have not other option than to
3174 * use the starter address if it is set. */
3175
3176 e = secure_getenv("DBUS_STARTER_ADDRESS");
3177 if (e) {
3178 static thread_local sd_bus *default_starter_bus = NULL;
3179
3180 return bus_default(sd_bus_open, &default_starter_bus, ret);
3181 }
3182
3183 /* Finally, if nothing is set use the cached connection for
3184 * the right scope */
3185
3186 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3187 return sd_bus_default_user(ret);
3188 else
3189 return sd_bus_default_system(ret);
3190 }
3191
3192 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3193 assert_return(b, -EINVAL);
3194 assert_return(tid, -EINVAL);
3195 assert_return(!bus_pid_changed(b), -ECHILD);
3196
3197 if (b->tid != 0) {
3198 *tid = b->tid;
3199 return 0;
3200 }
3201
3202 if (b->event)
3203 return sd_event_get_tid(b->event, tid);
3204
3205 return -ENXIO;
3206 }
3207
3208 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3209 _cleanup_free_ char *e = NULL;
3210 char *ret;
3211
3212 assert_return(object_path_is_valid(prefix), -EINVAL);
3213 assert_return(external_id, -EINVAL);
3214 assert_return(ret_path, -EINVAL);
3215
3216 e = bus_label_escape(external_id);
3217 if (!e)
3218 return -ENOMEM;
3219
3220 ret = strjoin(prefix, "/", e, NULL);
3221 if (!ret)
3222 return -ENOMEM;
3223
3224 *ret_path = ret;
3225 return 0;
3226 }
3227
3228 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3229 const char *e;
3230 char *ret;
3231
3232 assert_return(object_path_is_valid(path), -EINVAL);
3233 assert_return(object_path_is_valid(prefix), -EINVAL);
3234 assert_return(external_id, -EINVAL);
3235
3236 e = object_path_startswith(path, prefix);
3237 if (!e) {
3238 *external_id = NULL;
3239 return 0;
3240 }
3241
3242 ret = bus_label_unescape(e);
3243 if (!ret)
3244 return -ENOMEM;
3245
3246 *external_id = ret;
3247 return 1;
3248 }
3249
3250 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3251 sd_bus_creds *c;
3252 pid_t pid = 0;
3253 int r;
3254
3255 assert_return(bus, -EINVAL);
3256 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3257 assert_return(ret, -EINVAL);
3258 assert_return(!bus_pid_changed(bus), -ECHILD);
3259
3260 if (bus->is_kernel)
3261 return -ENOTSUP;
3262
3263 if (!BUS_IS_OPEN(bus->state))
3264 return -ENOTCONN;
3265
3266 if (!bus->ucred_valid && !isempty(bus->label))
3267 return -ENODATA;
3268
3269 c = bus_creds_new();
3270 if (!c)
3271 return -ENOMEM;
3272
3273 if (bus->ucred_valid) {
3274 pid = c->pid = bus->ucred.pid;
3275 c->uid = bus->ucred.uid;
3276 c->gid = bus->ucred.gid;
3277
3278 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3279 }
3280
3281 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3282 c->label = strdup(bus->label);
3283 if (!c->label) {
3284 sd_bus_creds_unref(c);
3285 return -ENOMEM;
3286 }
3287
3288 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3289 }
3290
3291 r = bus_creds_add_more(c, mask, pid, 0);
3292 if (r < 0)
3293 return r;
3294
3295 *ret = c;
3296 return 0;
3297 }
3298
3299 _public_ int sd_bus_try_close(sd_bus *bus) {
3300 int r;
3301
3302 assert_return(bus, -EINVAL);
3303 assert_return(!bus_pid_changed(bus), -ECHILD);
3304
3305 if (!bus->is_kernel)
3306 return -ENOTSUP;
3307
3308 if (!BUS_IS_OPEN(bus->state))
3309 return -ENOTCONN;
3310
3311 if (bus->rqueue_size > 0)
3312 return -EBUSY;
3313
3314 if (bus->wqueue_size > 0)
3315 return -EBUSY;
3316
3317 r = bus_kernel_try_close(bus);
3318 if (r < 0)
3319 return r;
3320
3321 sd_bus_close(bus);
3322 return 0;
3323 }
3324
3325 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3326 assert_return(bus, -EINVAL);
3327 assert_return(name, -EINVAL);
3328 assert_return(!bus_pid_changed(bus), -ECHILD);
3329
3330 *name = bus->connection_name;
3331 return 0;
3332 }
Unnamed repository; edit this file 'description' to name the repository.