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