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