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