]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd-bus/sd-bus.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
bus: automatically do a NOP reply when a NULL callback is specified for a method...
[thirdparty/systemd.git] / src / libsystemd-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
38 #include "sd-bus.h"
39 #include "bus-internal.h"
40 #include "bus-message.h"
41 #include "bus-type.h"
42 #include "bus-socket.h"
43 #include "bus-kernel.h"
44 #include "bus-control.h"
45 #include "bus-introspect.h"
46 #include "bus-signature.h"
47
48 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
49
50 static void bus_close_fds(sd_bus *b) {
51 assert(b);
52
53 if (b->input_fd >= 0)
54 close_nointr_nofail(b->input_fd);
55
56 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
57 close_nointr_nofail(b->output_fd);
58
59 b->input_fd = b->output_fd = -1;
60 }
61
62 static void bus_node_destroy(sd_bus *b, struct node *n) {
63 struct node_callback *c;
64 struct node_vtable *v;
65 struct node_enumerator *e;
66
67 assert(b);
68
69 if (!n)
70 return;
71
72 while (n->child)
73 bus_node_destroy(b, n->child);
74
75 while ((c = n->callbacks)) {
76 LIST_REMOVE(struct node_callback, callbacks, n->callbacks, c);
77 free(c);
78 }
79
80 while ((v = n->vtables)) {
81 LIST_REMOVE(struct node_vtable, vtables, n->vtables, v);
82 free(v->interface);
83 free(v);
84 }
85
86 while ((e = n->enumerators)) {
87 LIST_REMOVE(struct node_enumerator, enumerators, n->enumerators, e);
88 free(e);
89 }
90
91 if (n->parent)
92 LIST_REMOVE(struct node, siblings, n->parent->child, n);
93
94 assert_se(hashmap_remove(b->nodes, n->path) == n);
95 free(n->path);
96 free(n);
97 }
98
99 static void bus_free(sd_bus *b) {
100 struct filter_callback *f;
101 struct node *n;
102 unsigned i;
103
104 assert(b);
105
106 bus_close_fds(b);
107
108 if (b->kdbus_buffer)
109 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
110
111 free(b->rbuffer);
112 free(b->unique_name);
113 free(b->auth_buffer);
114 free(b->address);
115 free(b->kernel);
116
117 free(b->exec_path);
118 strv_free(b->exec_argv);
119
120 close_many(b->fds, b->n_fds);
121 free(b->fds);
122
123 for (i = 0; i < b->rqueue_size; i++)
124 sd_bus_message_unref(b->rqueue[i]);
125 free(b->rqueue);
126
127 for (i = 0; i < b->wqueue_size; i++)
128 sd_bus_message_unref(b->wqueue[i]);
129 free(b->wqueue);
130
131 hashmap_free_free(b->reply_callbacks);
132 prioq_free(b->reply_callbacks_prioq);
133
134 while ((f = b->filter_callbacks)) {
135 LIST_REMOVE(struct filter_callback, callbacks, b->filter_callbacks, f);
136 free(f);
137 }
138
139 bus_match_free(&b->match_callbacks);
140
141 hashmap_free_free(b->vtable_methods);
142 hashmap_free_free(b->vtable_properties);
143
144 while ((n = hashmap_first(b->nodes)))
145 bus_node_destroy(b, n);
146
147 hashmap_free(b->nodes);
148
149 bus_kernel_flush_memfd(b);
150
151 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
152
153 free(b);
154 }
155
156 int sd_bus_new(sd_bus **ret) {
157 sd_bus *r;
158
159 if (!ret)
160 return -EINVAL;
161
162 r = new0(sd_bus, 1);
163 if (!r)
164 return -ENOMEM;
165
166 r->n_ref = REFCNT_INIT;
167 r->input_fd = r->output_fd = -1;
168 r->message_version = 1;
169 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
170 r->original_pid = getpid();
171
172 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
173
174 /* We guarantee that wqueue always has space for at least one
175 * entry */
176 r->wqueue = new(sd_bus_message*, 1);
177 if (!r->wqueue) {
178 free(r);
179 return -ENOMEM;
180 }
181
182 *ret = r;
183 return 0;
184 }
185
186 int sd_bus_set_address(sd_bus *bus, const char *address) {
187 char *a;
188
189 if (!bus)
190 return -EINVAL;
191 if (bus->state != BUS_UNSET)
192 return -EPERM;
193 if (!address)
194 return -EINVAL;
195 if (bus_pid_changed(bus))
196 return -ECHILD;
197
198 a = strdup(address);
199 if (!a)
200 return -ENOMEM;
201
202 free(bus->address);
203 bus->address = a;
204
205 return 0;
206 }
207
208 int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
209 if (!bus)
210 return -EINVAL;
211 if (bus->state != BUS_UNSET)
212 return -EPERM;
213 if (input_fd < 0)
214 return -EINVAL;
215 if (output_fd < 0)
216 return -EINVAL;
217 if (bus_pid_changed(bus))
218 return -ECHILD;
219
220 bus->input_fd = input_fd;
221 bus->output_fd = output_fd;
222 return 0;
223 }
224
225 int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
226 char *p, **a;
227
228 if (!bus)
229 return -EINVAL;
230 if (bus->state != BUS_UNSET)
231 return -EPERM;
232 if (!path)
233 return -EINVAL;
234 if (strv_isempty(argv))
235 return -EINVAL;
236 if (bus_pid_changed(bus))
237 return -ECHILD;
238
239 p = strdup(path);
240 if (!p)
241 return -ENOMEM;
242
243 a = strv_copy(argv);
244 if (!a) {
245 free(p);
246 return -ENOMEM;
247 }
248
249 free(bus->exec_path);
250 strv_free(bus->exec_argv);
251
252 bus->exec_path = p;
253 bus->exec_argv = a;
254
255 return 0;
256 }
257
258 int sd_bus_set_bus_client(sd_bus *bus, int b) {
259 if (!bus)
260 return -EINVAL;
261 if (bus->state != BUS_UNSET)
262 return -EPERM;
263 if (bus_pid_changed(bus))
264 return -ECHILD;
265
266 bus->bus_client = !!b;
267 return 0;
268 }
269
270 int sd_bus_negotiate_fds(sd_bus *bus, int b) {
271 if (!bus)
272 return -EINVAL;
273 if (bus->state != BUS_UNSET)
274 return -EPERM;
275 if (bus_pid_changed(bus))
276 return -ECHILD;
277
278 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
279 return 0;
280 }
281
282 int sd_bus_negotiate_attach_comm(sd_bus *bus, int b) {
283 if (!bus)
284 return -EINVAL;
285 if (bus->state != BUS_UNSET)
286 return -EPERM;
287 if (bus_pid_changed(bus))
288 return -ECHILD;
289
290 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_COMM, b);
291 return 0;
292 }
293
294 int sd_bus_negotiate_attach_exe(sd_bus *bus, int b) {
295 if (!bus)
296 return -EINVAL;
297 if (bus->state != BUS_UNSET)
298 return -EPERM;
299 if (bus_pid_changed(bus))
300 return -ECHILD;
301
302 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_EXE, b);
303 return 0;
304 }
305
306 int sd_bus_negotiate_attach_cmdline(sd_bus *bus, int b) {
307 if (!bus)
308 return -EINVAL;
309 if (bus->state != BUS_UNSET)
310 return -EPERM;
311 if (bus_pid_changed(bus))
312 return -ECHILD;
313
314 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_CMDLINE, b);
315 return 0;
316 }
317
318 int sd_bus_negotiate_attach_cgroup(sd_bus *bus, int b) {
319 if (!bus)
320 return -EINVAL;
321 if (bus->state != BUS_UNSET)
322 return -EPERM;
323 if (bus_pid_changed(bus))
324 return -ECHILD;
325
326 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_CGROUP, b);
327 return 0;
328 }
329
330 int sd_bus_negotiate_attach_caps(sd_bus *bus, int b) {
331 if (!bus)
332 return -EINVAL;
333 if (bus->state != BUS_UNSET)
334 return -EPERM;
335 if (bus_pid_changed(bus))
336 return -ECHILD;
337
338 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_CAPS, b);
339 return 0;
340 }
341
342 int sd_bus_negotiate_attach_selinux_context(sd_bus *bus, int b) {
343 if (!bus)
344 return -EINVAL;
345 if (bus->state != BUS_UNSET)
346 return -EPERM;
347 if (bus_pid_changed(bus))
348 return -ECHILD;
349
350 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_SECLABEL, b);
351 return 0;
352 }
353
354 int sd_bus_negotiate_attach_audit(sd_bus *bus, int b) {
355 if (!bus)
356 return -EINVAL;
357 if (bus->state != BUS_UNSET)
358 return -EPERM;
359 if (bus_pid_changed(bus))
360 return -ECHILD;
361
362 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_AUDIT, b);
363 return 0;
364 }
365
366 int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
367 if (!bus)
368 return -EINVAL;
369 if (!b && !sd_id128_equal(server_id, SD_ID128_NULL))
370 return -EINVAL;
371 if (bus->state != BUS_UNSET)
372 return -EPERM;
373 if (bus_pid_changed(bus))
374 return -ECHILD;
375
376 bus->is_server = !!b;
377 bus->server_id = server_id;
378 return 0;
379 }
380
381 int sd_bus_set_anonymous(sd_bus *bus, int b) {
382 if (!bus)
383 return -EINVAL;
384 if (bus->state != BUS_UNSET)
385 return -EPERM;
386 if (bus_pid_changed(bus))
387 return -ECHILD;
388
389 bus->anonymous_auth = !!b;
390 return 0;
391 }
392
393 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata) {
394 const char *s;
395 int r;
396
397 assert(bus);
398 assert(bus->state == BUS_HELLO);
399 assert(reply);
400
401 r = bus_message_to_errno(reply);
402 if (r < 0)
403 return r;
404
405 r = sd_bus_message_read(reply, "s", &s);
406 if (r < 0)
407 return r;
408
409 if (!service_name_is_valid(s) || s[0] != ':')
410 return -EBADMSG;
411
412 bus->unique_name = strdup(s);
413 if (!bus->unique_name)
414 return -ENOMEM;
415
416 bus->state = BUS_RUNNING;
417
418 return 1;
419 }
420
421 static int bus_send_hello(sd_bus *bus) {
422 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
423 int r;
424
425 assert(bus);
426
427 if (!bus->bus_client || bus->is_kernel)
428 return 0;
429
430 r = sd_bus_message_new_method_call(
431 bus,
432 "org.freedesktop.DBus",
433 "/",
434 "org.freedesktop.DBus",
435 "Hello",
436 &m);
437 if (r < 0)
438 return r;
439
440 return sd_bus_send_with_reply(bus, m, hello_callback, NULL, 0, &bus->hello_serial);
441 }
442
443 int bus_start_running(sd_bus *bus) {
444 assert(bus);
445
446 if (bus->bus_client && !bus->is_kernel) {
447 bus->state = BUS_HELLO;
448 return 1;
449 }
450
451 bus->state = BUS_RUNNING;
452 return 1;
453 }
454
455 static int parse_address_key(const char **p, const char *key, char **value) {
456 size_t l, n = 0;
457 const char *a;
458 char *r = NULL;
459
460 assert(p);
461 assert(*p);
462 assert(value);
463
464 if (key) {
465 l = strlen(key);
466 if (strncmp(*p, key, l) != 0)
467 return 0;
468
469 if ((*p)[l] != '=')
470 return 0;
471
472 if (*value)
473 return -EINVAL;
474
475 a = *p + l + 1;
476 } else
477 a = *p;
478
479 while (*a != ';' && *a != ',' && *a != 0) {
480 char c, *t;
481
482 if (*a == '%') {
483 int x, y;
484
485 x = unhexchar(a[1]);
486 if (x < 0) {
487 free(r);
488 return x;
489 }
490
491 y = unhexchar(a[2]);
492 if (y < 0) {
493 free(r);
494 return y;
495 }
496
497 c = (char) ((x << 4) | y);
498 a += 3;
499 } else {
500 c = *a;
501 a++;
502 }
503
504 t = realloc(r, n + 2);
505 if (!t) {
506 free(r);
507 return -ENOMEM;
508 }
509
510 r = t;
511 r[n++] = c;
512 }
513
514 if (!r) {
515 r = strdup("");
516 if (!r)
517 return -ENOMEM;
518 } else
519 r[n] = 0;
520
521 if (*a == ',')
522 a++;
523
524 *p = a;
525
526 free(*value);
527 *value = r;
528
529 return 1;
530 }
531
532 static void skip_address_key(const char **p) {
533 assert(p);
534 assert(*p);
535
536 *p += strcspn(*p, ",");
537
538 if (**p == ',')
539 (*p) ++;
540 }
541
542 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
543 _cleanup_free_ char *path = NULL, *abstract = NULL;
544 size_t l;
545 int r;
546
547 assert(b);
548 assert(p);
549 assert(*p);
550 assert(guid);
551
552 while (**p != 0 && **p != ';') {
553 r = parse_address_key(p, "guid", guid);
554 if (r < 0)
555 return r;
556 else if (r > 0)
557 continue;
558
559 r = parse_address_key(p, "path", &path);
560 if (r < 0)
561 return r;
562 else if (r > 0)
563 continue;
564
565 r = parse_address_key(p, "abstract", &abstract);
566 if (r < 0)
567 return r;
568 else if (r > 0)
569 continue;
570
571 skip_address_key(p);
572 }
573
574 if (!path && !abstract)
575 return -EINVAL;
576
577 if (path && abstract)
578 return -EINVAL;
579
580 if (path) {
581 l = strlen(path);
582 if (l > sizeof(b->sockaddr.un.sun_path))
583 return -E2BIG;
584
585 b->sockaddr.un.sun_family = AF_UNIX;
586 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
587 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
588 } else if (abstract) {
589 l = strlen(abstract);
590 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
591 return -E2BIG;
592
593 b->sockaddr.un.sun_family = AF_UNIX;
594 b->sockaddr.un.sun_path[0] = 0;
595 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
596 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
597 }
598
599 return 0;
600 }
601
602 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
603 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
604 int r;
605 struct addrinfo *result, hints = {
606 .ai_socktype = SOCK_STREAM,
607 .ai_flags = AI_ADDRCONFIG,
608 };
609
610 assert(b);
611 assert(p);
612 assert(*p);
613 assert(guid);
614
615 while (**p != 0 && **p != ';') {
616 r = parse_address_key(p, "guid", guid);
617 if (r < 0)
618 return r;
619 else if (r > 0)
620 continue;
621
622 r = parse_address_key(p, "host", &host);
623 if (r < 0)
624 return r;
625 else if (r > 0)
626 continue;
627
628 r = parse_address_key(p, "port", &port);
629 if (r < 0)
630 return r;
631 else if (r > 0)
632 continue;
633
634 r = parse_address_key(p, "family", &family);
635 if (r < 0)
636 return r;
637 else if (r > 0)
638 continue;
639
640 skip_address_key(p);
641 }
642
643 if (!host || !port)
644 return -EINVAL;
645
646 if (family) {
647 if (streq(family, "ipv4"))
648 hints.ai_family = AF_INET;
649 else if (streq(family, "ipv6"))
650 hints.ai_family = AF_INET6;
651 else
652 return -EINVAL;
653 }
654
655 r = getaddrinfo(host, port, &hints, &result);
656 if (r == EAI_SYSTEM)
657 return -errno;
658 else if (r != 0)
659 return -EADDRNOTAVAIL;
660
661 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
662 b->sockaddr_size = result->ai_addrlen;
663
664 freeaddrinfo(result);
665
666 return 0;
667 }
668
669 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
670 char *path = NULL;
671 unsigned n_argv = 0, j;
672 char **argv = NULL;
673 int r;
674
675 assert(b);
676 assert(p);
677 assert(*p);
678 assert(guid);
679
680 while (**p != 0 && **p != ';') {
681 r = parse_address_key(p, "guid", guid);
682 if (r < 0)
683 goto fail;
684 else if (r > 0)
685 continue;
686
687 r = parse_address_key(p, "path", &path);
688 if (r < 0)
689 goto fail;
690 else if (r > 0)
691 continue;
692
693 if (startswith(*p, "argv")) {
694 unsigned ul;
695
696 errno = 0;
697 ul = strtoul(*p + 4, (char**) p, 10);
698 if (errno > 0 || **p != '=' || ul > 256) {
699 r = -EINVAL;
700 goto fail;
701 }
702
703 (*p) ++;
704
705 if (ul >= n_argv) {
706 char **x;
707
708 x = realloc(argv, sizeof(char*) * (ul + 2));
709 if (!x) {
710 r = -ENOMEM;
711 goto fail;
712 }
713
714 memset(x + n_argv, 0, sizeof(char*) * (ul - n_argv + 2));
715
716 argv = x;
717 n_argv = ul + 1;
718 }
719
720 r = parse_address_key(p, NULL, argv + ul);
721 if (r < 0)
722 goto fail;
723
724 continue;
725 }
726
727 skip_address_key(p);
728 }
729
730 if (!path) {
731 r = -EINVAL;
732 goto fail;
733 }
734
735 /* Make sure there are no holes in the array, with the
736 * exception of argv[0] */
737 for (j = 1; j < n_argv; j++)
738 if (!argv[j]) {
739 r = -EINVAL;
740 goto fail;
741 }
742
743 if (argv && argv[0] == NULL) {
744 argv[0] = strdup(path);
745 if (!argv[0]) {
746 r = -ENOMEM;
747 goto fail;
748 }
749 }
750
751 b->exec_path = path;
752 b->exec_argv = argv;
753 return 0;
754
755 fail:
756 for (j = 0; j < n_argv; j++)
757 free(argv[j]);
758
759 free(argv);
760 free(path);
761 return r;
762 }
763
764 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
765 _cleanup_free_ char *path = NULL;
766 int r;
767
768 assert(b);
769 assert(p);
770 assert(*p);
771 assert(guid);
772
773 while (**p != 0 && **p != ';') {
774 r = parse_address_key(p, "guid", guid);
775 if (r < 0)
776 return r;
777 else if (r > 0)
778 continue;
779
780 r = parse_address_key(p, "path", &path);
781 if (r < 0)
782 return r;
783 else if (r > 0)
784 continue;
785
786 skip_address_key(p);
787 }
788
789 if (!path)
790 return -EINVAL;
791
792 free(b->kernel);
793 b->kernel = path;
794 path = NULL;
795
796 return 0;
797 }
798
799 static void bus_reset_parsed_address(sd_bus *b) {
800 assert(b);
801
802 zero(b->sockaddr);
803 b->sockaddr_size = 0;
804 strv_free(b->exec_argv);
805 free(b->exec_path);
806 b->exec_path = NULL;
807 b->exec_argv = NULL;
808 b->server_id = SD_ID128_NULL;
809 free(b->kernel);
810 b->kernel = NULL;
811 }
812
813 static int bus_parse_next_address(sd_bus *b) {
814 _cleanup_free_ char *guid = NULL;
815 const char *a;
816 int r;
817
818 assert(b);
819
820 if (!b->address)
821 return 0;
822 if (b->address[b->address_index] == 0)
823 return 0;
824
825 bus_reset_parsed_address(b);
826
827 a = b->address + b->address_index;
828
829 while (*a != 0) {
830
831 if (*a == ';') {
832 a++;
833 continue;
834 }
835
836 if (startswith(a, "unix:")) {
837 a += 5;
838
839 r = parse_unix_address(b, &a, &guid);
840 if (r < 0)
841 return r;
842 break;
843
844 } else if (startswith(a, "tcp:")) {
845
846 a += 4;
847 r = parse_tcp_address(b, &a, &guid);
848 if (r < 0)
849 return r;
850
851 break;
852
853 } else if (startswith(a, "unixexec:")) {
854
855 a += 9;
856 r = parse_exec_address(b, &a, &guid);
857 if (r < 0)
858 return r;
859
860 break;
861
862 } else if (startswith(a, "kernel:")) {
863
864 a += 7;
865 r = parse_kernel_address(b, &a, &guid);
866 if (r < 0)
867 return r;
868
869 break;
870 }
871
872 a = strchr(a, ';');
873 if (!a)
874 return 0;
875 }
876
877 if (guid) {
878 r = sd_id128_from_string(guid, &b->server_id);
879 if (r < 0)
880 return r;
881 }
882
883 b->address_index = a - b->address;
884 return 1;
885 }
886
887 static int bus_start_address(sd_bus *b) {
888 int r;
889
890 assert(b);
891
892 for (;;) {
893 sd_bus_close(b);
894
895 if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
896
897 r = bus_socket_connect(b);
898 if (r >= 0)
899 return r;
900
901 b->last_connect_error = -r;
902
903 } else if (b->exec_path) {
904
905 r = bus_socket_exec(b);
906 if (r >= 0)
907 return r;
908
909 b->last_connect_error = -r;
910 } else if (b->kernel) {
911
912 r = bus_kernel_connect(b);
913 if (r >= 0)
914 return r;
915
916 b->last_connect_error = -r;
917 }
918
919 r = bus_parse_next_address(b);
920 if (r < 0)
921 return r;
922 if (r == 0)
923 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
924 }
925 }
926
927 int bus_next_address(sd_bus *b) {
928 assert(b);
929
930 bus_reset_parsed_address(b);
931 return bus_start_address(b);
932 }
933
934 static int bus_start_fd(sd_bus *b) {
935 struct stat st;
936 int r;
937
938 assert(b);
939 assert(b->input_fd >= 0);
940 assert(b->output_fd >= 0);
941
942 r = fd_nonblock(b->input_fd, true);
943 if (r < 0)
944 return r;
945
946 r = fd_cloexec(b->input_fd, true);
947 if (r < 0)
948 return r;
949
950 if (b->input_fd != b->output_fd) {
951 r = fd_nonblock(b->output_fd, true);
952 if (r < 0)
953 return r;
954
955 r = fd_cloexec(b->output_fd, true);
956 if (r < 0)
957 return r;
958 }
959
960 if (fstat(b->input_fd, &st) < 0)
961 return -errno;
962
963 if (S_ISCHR(b->input_fd))
964 return bus_kernel_take_fd(b);
965 else
966 return bus_socket_take_fd(b);
967 }
968
969 int sd_bus_start(sd_bus *bus) {
970 int r;
971
972 if (!bus)
973 return -EINVAL;
974 if (bus->state != BUS_UNSET)
975 return -EPERM;
976 if (bus_pid_changed(bus))
977 return -ECHILD;
978
979 bus->state = BUS_OPENING;
980
981 if (bus->is_server && bus->bus_client)
982 return -EINVAL;
983
984 if (bus->input_fd >= 0)
985 r = bus_start_fd(bus);
986 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel)
987 r = bus_start_address(bus);
988 else
989 return -EINVAL;
990
991 if (r < 0)
992 return r;
993
994 return bus_send_hello(bus);
995 }
996
997 int sd_bus_open_system(sd_bus **ret) {
998 const char *e;
999 sd_bus *b;
1000 int r;
1001
1002 if (!ret)
1003 return -EINVAL;
1004
1005 r = sd_bus_new(&b);
1006 if (r < 0)
1007 return r;
1008
1009 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1010 if (e) {
1011 r = sd_bus_set_address(b, e);
1012 if (r < 0)
1013 goto fail;
1014 } else {
1015 b->sockaddr.un.sun_family = AF_UNIX;
1016 strncpy(b->sockaddr.un.sun_path, "/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
1017 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + sizeof("/run/dbus/system_bus_socket") - 1;
1018 }
1019
1020 b->bus_client = true;
1021
1022 r = sd_bus_start(b);
1023 if (r < 0)
1024 goto fail;
1025
1026 *ret = b;
1027 return 0;
1028
1029 fail:
1030 bus_free(b);
1031 return r;
1032 }
1033
1034 int sd_bus_open_user(sd_bus **ret) {
1035 const char *e;
1036 sd_bus *b;
1037 size_t l;
1038 int r;
1039
1040 if (!ret)
1041 return -EINVAL;
1042
1043 r = sd_bus_new(&b);
1044 if (r < 0)
1045 return r;
1046
1047 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1048 if (e) {
1049 r = sd_bus_set_address(b, e);
1050 if (r < 0)
1051 goto fail;
1052 } else {
1053 e = secure_getenv("XDG_RUNTIME_DIR");
1054 if (!e) {
1055 r = -ENOENT;
1056 goto fail;
1057 }
1058
1059 l = strlen(e);
1060 if (l + 4 > sizeof(b->sockaddr.un.sun_path)) {
1061 r = -E2BIG;
1062 goto fail;
1063 }
1064
1065 b->sockaddr.un.sun_family = AF_UNIX;
1066 memcpy(mempcpy(b->sockaddr.un.sun_path, e, l), "/bus", 4);
1067 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l + 4;
1068 }
1069
1070 b->bus_client = true;
1071
1072 r = sd_bus_start(b);
1073 if (r < 0)
1074 goto fail;
1075
1076 *ret = b;
1077 return 0;
1078
1079 fail:
1080 bus_free(b);
1081 return r;
1082 }
1083
1084 void sd_bus_close(sd_bus *bus) {
1085 if (!bus)
1086 return;
1087 if (bus->state == BUS_CLOSED)
1088 return;
1089 if (bus_pid_changed(bus))
1090 return;
1091
1092 bus->state = BUS_CLOSED;
1093
1094 if (!bus->is_kernel)
1095 bus_close_fds(bus);
1096
1097 /* We'll leave the fd open in case this is a kernel bus, since
1098 * there might still be memblocks around that reference this
1099 * bus, and they might need to invoke the
1100 * KDBUS_CMD_MSG_RELEASE ioctl on the fd when they are
1101 * freed. */
1102 }
1103
1104 sd_bus *sd_bus_ref(sd_bus *bus) {
1105 if (!bus)
1106 return NULL;
1107
1108 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1109
1110 return bus;
1111 }
1112
1113 sd_bus *sd_bus_unref(sd_bus *bus) {
1114 if (!bus)
1115 return NULL;
1116
1117 if (REFCNT_DEC(bus->n_ref) <= 0)
1118 bus_free(bus);
1119
1120 return NULL;
1121 }
1122
1123 int sd_bus_is_open(sd_bus *bus) {
1124 if (!bus)
1125 return -EINVAL;
1126 if (bus_pid_changed(bus))
1127 return -ECHILD;
1128
1129 return BUS_IS_OPEN(bus->state);
1130 }
1131
1132 int sd_bus_can_send(sd_bus *bus, char type) {
1133 int r;
1134
1135 if (!bus)
1136 return -EINVAL;
1137 if (bus->state == BUS_UNSET)
1138 return -ENOTCONN;
1139 if (bus_pid_changed(bus))
1140 return -ECHILD;
1141
1142 if (type == SD_BUS_TYPE_UNIX_FD) {
1143 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1144 return 0;
1145
1146 r = bus_ensure_running(bus);
1147 if (r < 0)
1148 return r;
1149
1150 return bus->can_fds;
1151 }
1152
1153 return bus_type_is_valid(type);
1154 }
1155
1156 int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1157 int r;
1158
1159 if (!bus)
1160 return -EINVAL;
1161 if (!server_id)
1162 return -EINVAL;
1163 if (bus_pid_changed(bus))
1164 return -ECHILD;
1165
1166 r = bus_ensure_running(bus);
1167 if (r < 0)
1168 return r;
1169
1170 *server_id = bus->server_id;
1171 return 0;
1172 }
1173
1174 static int bus_seal_message(sd_bus *b, sd_bus_message *m) {
1175 assert(m);
1176
1177 if (m->header->version > b->message_version)
1178 return -EPERM;
1179
1180 if (m->sealed)
1181 return 0;
1182
1183 return bus_message_seal(m, ++b->serial);
1184 }
1185
1186 static int dispatch_wqueue(sd_bus *bus) {
1187 int r, ret = 0;
1188
1189 assert(bus);
1190 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1191
1192 while (bus->wqueue_size > 0) {
1193
1194 if (bus->is_kernel)
1195 r = bus_kernel_write_message(bus, bus->wqueue[0]);
1196 else
1197 r = bus_socket_write_message(bus, bus->wqueue[0], &bus->windex);
1198
1199 if (r < 0) {
1200 sd_bus_close(bus);
1201 return r;
1202 } else if (r == 0)
1203 /* Didn't do anything this time */
1204 return ret;
1205 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1206 /* Fully written. Let's drop the entry from
1207 * the queue.
1208 *
1209 * This isn't particularly optimized, but
1210 * well, this is supposed to be our worst-case
1211 * buffer only, and the socket buffer is
1212 * supposed to be our primary buffer, and if
1213 * it got full, then all bets are off
1214 * anyway. */
1215
1216 sd_bus_message_unref(bus->wqueue[0]);
1217 bus->wqueue_size --;
1218 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1219 bus->windex = 0;
1220
1221 ret = 1;
1222 }
1223 }
1224
1225 return ret;
1226 }
1227
1228 static int dispatch_rqueue(sd_bus *bus, sd_bus_message **m) {
1229 sd_bus_message *z = NULL;
1230 int r, ret = 0;
1231
1232 assert(bus);
1233 assert(m);
1234 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1235
1236 if (bus->rqueue_size > 0) {
1237 /* Dispatch a queued message */
1238
1239 *m = bus->rqueue[0];
1240 bus->rqueue_size --;
1241 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1242 return 1;
1243 }
1244
1245 /* Try to read a new message */
1246 do {
1247 if (bus->is_kernel)
1248 r = bus_kernel_read_message(bus, &z);
1249 else
1250 r = bus_socket_read_message(bus, &z);
1251
1252 if (r < 0) {
1253 sd_bus_close(bus);
1254 return r;
1255 }
1256 if (r == 0)
1257 return ret;
1258
1259 ret = 1;
1260 } while (!z);
1261
1262 *m = z;
1263 return ret;
1264 }
1265
1266 int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *serial) {
1267 int r;
1268
1269 if (!bus)
1270 return -EINVAL;
1271 if (!BUS_IS_OPEN(bus->state))
1272 return -ENOTCONN;
1273 if (!m)
1274 return -EINVAL;
1275 if (bus_pid_changed(bus))
1276 return -ECHILD;
1277
1278 if (m->n_fds > 0) {
1279 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1280 if (r < 0)
1281 return r;
1282 if (r == 0)
1283 return -ENOTSUP;
1284 }
1285
1286 /* If the serial number isn't kept, then we know that no reply
1287 * is expected */
1288 if (!serial && !m->sealed)
1289 m->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED;
1290
1291 r = bus_seal_message(bus, m);
1292 if (r < 0)
1293 return r;
1294
1295 /* If this is a reply and no reply was requested, then let's
1296 * suppress this, if we can */
1297 if (m->dont_send && !serial)
1298 return 0;
1299
1300 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1301 size_t idx = 0;
1302
1303 if (bus->is_kernel)
1304 r = bus_kernel_write_message(bus, m);
1305 else
1306 r = bus_socket_write_message(bus, m, &idx);
1307
1308 if (r < 0) {
1309 sd_bus_close(bus);
1310 return r;
1311 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1312 /* Wasn't fully written. So let's remember how
1313 * much was written. Note that the first entry
1314 * of the wqueue array is always allocated so
1315 * that we always can remember how much was
1316 * written. */
1317 bus->wqueue[0] = sd_bus_message_ref(m);
1318 bus->wqueue_size = 1;
1319 bus->windex = idx;
1320 }
1321 } else {
1322 sd_bus_message **q;
1323
1324 /* Just append it to the queue. */
1325
1326 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1327 return -ENOBUFS;
1328
1329 q = realloc(bus->wqueue, sizeof(sd_bus_message*) * (bus->wqueue_size + 1));
1330 if (!q)
1331 return -ENOMEM;
1332
1333 bus->wqueue = q;
1334 q[bus->wqueue_size ++] = sd_bus_message_ref(m);
1335 }
1336
1337 if (serial)
1338 *serial = BUS_MESSAGE_SERIAL(m);
1339
1340 return 0;
1341 }
1342
1343 static usec_t calc_elapse(uint64_t usec) {
1344 if (usec == (uint64_t) -1)
1345 return 0;
1346
1347 if (usec == 0)
1348 usec = BUS_DEFAULT_TIMEOUT;
1349
1350 return now(CLOCK_MONOTONIC) + usec;
1351 }
1352
1353 static int timeout_compare(const void *a, const void *b) {
1354 const struct reply_callback *x = a, *y = b;
1355
1356 if (x->timeout != 0 && y->timeout == 0)
1357 return -1;
1358
1359 if (x->timeout == 0 && y->timeout != 0)
1360 return 1;
1361
1362 if (x->timeout < y->timeout)
1363 return -1;
1364
1365 if (x->timeout > y->timeout)
1366 return 1;
1367
1368 return 0;
1369 }
1370
1371 int sd_bus_send_with_reply(
1372 sd_bus *bus,
1373 sd_bus_message *m,
1374 sd_bus_message_handler_t callback,
1375 void *userdata,
1376 uint64_t usec,
1377 uint64_t *serial) {
1378
1379 struct reply_callback *c;
1380 int r;
1381
1382 if (!bus)
1383 return -EINVAL;
1384 if (!BUS_IS_OPEN(bus->state))
1385 return -ENOTCONN;
1386 if (!m)
1387 return -EINVAL;
1388 if (!callback)
1389 return -EINVAL;
1390 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1391 return -EINVAL;
1392 if (m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
1393 return -EINVAL;
1394 if (bus_pid_changed(bus))
1395 return -ECHILD;
1396
1397 r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1398 if (r < 0)
1399 return r;
1400
1401 if (usec != (uint64_t) -1) {
1402 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1403 if (r < 0)
1404 return r;
1405 }
1406
1407 r = bus_seal_message(bus, m);
1408 if (r < 0)
1409 return r;
1410
1411 c = new0(struct reply_callback, 1);
1412 if (!c)
1413 return -ENOMEM;
1414
1415 c->callback = callback;
1416 c->userdata = userdata;
1417 c->serial = BUS_MESSAGE_SERIAL(m);
1418 c->timeout = calc_elapse(usec);
1419
1420 r = hashmap_put(bus->reply_callbacks, &c->serial, c);
1421 if (r < 0) {
1422 free(c);
1423 return r;
1424 }
1425
1426 if (c->timeout != 0) {
1427 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1428 if (r < 0) {
1429 c->timeout = 0;
1430 sd_bus_send_with_reply_cancel(bus, c->serial);
1431 return r;
1432 }
1433 }
1434
1435 r = sd_bus_send(bus, m, serial);
1436 if (r < 0) {
1437 sd_bus_send_with_reply_cancel(bus, c->serial);
1438 return r;
1439 }
1440
1441 return r;
1442 }
1443
1444 int sd_bus_send_with_reply_cancel(sd_bus *bus, uint64_t serial) {
1445 struct reply_callback *c;
1446
1447 if (!bus)
1448 return -EINVAL;
1449 if (serial == 0)
1450 return -EINVAL;
1451 if (bus_pid_changed(bus))
1452 return -ECHILD;
1453
1454 c = hashmap_remove(bus->reply_callbacks, &serial);
1455 if (!c)
1456 return 0;
1457
1458 if (c->timeout != 0)
1459 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1460
1461 free(c);
1462 return 1;
1463 }
1464
1465 int bus_ensure_running(sd_bus *bus) {
1466 int r;
1467
1468 assert(bus);
1469
1470 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED)
1471 return -ENOTCONN;
1472 if (bus->state == BUS_RUNNING)
1473 return 1;
1474
1475 for (;;) {
1476 r = sd_bus_process(bus, NULL);
1477 if (r < 0)
1478 return r;
1479 if (bus->state == BUS_RUNNING)
1480 return 1;
1481 if (r > 0)
1482 continue;
1483
1484 r = sd_bus_wait(bus, (uint64_t) -1);
1485 if (r < 0)
1486 return r;
1487 }
1488 }
1489
1490 int sd_bus_send_with_reply_and_block(
1491 sd_bus *bus,
1492 sd_bus_message *m,
1493 uint64_t usec,
1494 sd_bus_error *error,
1495 sd_bus_message **reply) {
1496
1497 int r;
1498 usec_t timeout;
1499 uint64_t serial;
1500 bool room = false;
1501
1502 if (!bus)
1503 return -EINVAL;
1504 if (!BUS_IS_OPEN(bus->state))
1505 return -ENOTCONN;
1506 if (!m)
1507 return -EINVAL;
1508 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1509 return -EINVAL;
1510 if (m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
1511 return -EINVAL;
1512 if (bus_error_is_dirty(error))
1513 return -EINVAL;
1514 if (bus_pid_changed(bus))
1515 return -ECHILD;
1516
1517 r = bus_ensure_running(bus);
1518 if (r < 0)
1519 return r;
1520
1521 r = sd_bus_send(bus, m, &serial);
1522 if (r < 0)
1523 return r;
1524
1525 timeout = calc_elapse(usec);
1526
1527 for (;;) {
1528 usec_t left;
1529 sd_bus_message *incoming = NULL;
1530
1531 if (!room) {
1532 sd_bus_message **q;
1533
1534 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1535 return -ENOBUFS;
1536
1537 /* Make sure there's room for queuing this
1538 * locally, before we read the message */
1539
1540 q = realloc(bus->rqueue, (bus->rqueue_size + 1) * sizeof(sd_bus_message*));
1541 if (!q)
1542 return -ENOMEM;
1543
1544 bus->rqueue = q;
1545 room = true;
1546 }
1547
1548 if (bus->is_kernel)
1549 r = bus_kernel_read_message(bus, &incoming);
1550 else
1551 r = bus_socket_read_message(bus, &incoming);
1552 if (r < 0)
1553 return r;
1554 if (incoming) {
1555
1556 if (incoming->reply_serial == serial) {
1557 /* Found a match! */
1558
1559 if (incoming->header->type == SD_BUS_MESSAGE_TYPE_METHOD_RETURN) {
1560
1561 if (reply)
1562 *reply = incoming;
1563 else
1564 sd_bus_message_unref(incoming);
1565
1566 return 0;
1567 }
1568
1569 if (incoming->header->type == SD_BUS_MESSAGE_TYPE_METHOD_ERROR) {
1570 int k;
1571
1572 r = sd_bus_error_copy(error, &incoming->error);
1573 if (r < 0) {
1574 sd_bus_message_unref(incoming);
1575 return r;
1576 }
1577
1578 k = bus_error_to_errno(&incoming->error);
1579 sd_bus_message_unref(incoming);
1580 return k;
1581 }
1582
1583 sd_bus_message_unref(incoming);
1584 return -EIO;
1585 }
1586
1587 /* There's already guaranteed to be room for
1588 * this, so need to resize things here */
1589 bus->rqueue[bus->rqueue_size ++] = incoming;
1590 room = false;
1591
1592 /* Try to read more, right-away */
1593 continue;
1594 }
1595 if (r != 0)
1596 continue;
1597
1598 if (timeout > 0) {
1599 usec_t n;
1600
1601 n = now(CLOCK_MONOTONIC);
1602 if (n >= timeout)
1603 return -ETIMEDOUT;
1604
1605 left = timeout - n;
1606 } else
1607 left = (uint64_t) -1;
1608
1609 r = bus_poll(bus, true, left);
1610 if (r < 0)
1611 return r;
1612
1613 r = dispatch_wqueue(bus);
1614 if (r < 0)
1615 return r;
1616 }
1617 }
1618
1619 int sd_bus_get_fd(sd_bus *bus) {
1620 if (!bus)
1621 return -EINVAL;
1622 if (!BUS_IS_OPEN(bus->state))
1623 return -ENOTCONN;
1624 if (bus->input_fd != bus->output_fd)
1625 return -EPERM;
1626 if (bus_pid_changed(bus))
1627 return -ECHILD;
1628
1629 return bus->input_fd;
1630 }
1631
1632 int sd_bus_get_events(sd_bus *bus) {
1633 int flags = 0;
1634
1635 if (!bus)
1636 return -EINVAL;
1637 if (!BUS_IS_OPEN(bus->state))
1638 return -ENOTCONN;
1639 if (bus_pid_changed(bus))
1640 return -ECHILD;
1641
1642 if (bus->state == BUS_OPENING)
1643 flags |= POLLOUT;
1644 else if (bus->state == BUS_AUTHENTICATING) {
1645
1646 if (bus_socket_auth_needs_write(bus))
1647 flags |= POLLOUT;
1648
1649 flags |= POLLIN;
1650
1651 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1652 if (bus->rqueue_size <= 0)
1653 flags |= POLLIN;
1654 if (bus->wqueue_size > 0)
1655 flags |= POLLOUT;
1656 }
1657
1658 return flags;
1659 }
1660
1661 int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1662 struct reply_callback *c;
1663
1664 if (!bus)
1665 return -EINVAL;
1666 if (!timeout_usec)
1667 return -EINVAL;
1668 if (!BUS_IS_OPEN(bus->state))
1669 return -ENOTCONN;
1670 if (bus_pid_changed(bus))
1671 return -ECHILD;
1672
1673 if (bus->state == BUS_AUTHENTICATING) {
1674 *timeout_usec = bus->auth_timeout;
1675 return 1;
1676 }
1677
1678 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
1679 *timeout_usec = (uint64_t) -1;
1680 return 0;
1681 }
1682
1683 c = prioq_peek(bus->reply_callbacks_prioq);
1684 if (!c) {
1685 *timeout_usec = (uint64_t) -1;
1686 return 0;
1687 }
1688
1689 *timeout_usec = c->timeout;
1690 return 1;
1691 }
1692
1693 static int process_timeout(sd_bus *bus) {
1694 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
1695 struct reply_callback *c;
1696 usec_t n;
1697 int r;
1698
1699 assert(bus);
1700
1701 c = prioq_peek(bus->reply_callbacks_prioq);
1702 if (!c)
1703 return 0;
1704
1705 n = now(CLOCK_MONOTONIC);
1706 if (c->timeout > n)
1707 return 0;
1708
1709 r = bus_message_new_synthetic_error(
1710 bus,
1711 c->serial,
1712 &SD_BUS_ERROR_MAKE("org.freedesktop.DBus.Error.Timeout", "Timed out"),
1713 &m);
1714 if (r < 0)
1715 return r;
1716
1717 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
1718 hashmap_remove(bus->reply_callbacks, &c->serial);
1719
1720 r = c->callback(bus, m, c->userdata);
1721 free(c);
1722
1723 return r < 0 ? r : 1;
1724 }
1725
1726 static int process_hello(sd_bus *bus, sd_bus_message *m) {
1727 assert(bus);
1728 assert(m);
1729
1730 if (bus->state != BUS_HELLO)
1731 return 0;
1732
1733 /* Let's make sure the first message on the bus is the HELLO
1734 * reply. But note that we don't actually parse the message
1735 * here (we leave that to the usual handling), we just verify
1736 * we don't let any earlier msg through. */
1737
1738 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_RETURN &&
1739 m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_ERROR)
1740 return -EIO;
1741
1742 if (m->reply_serial != bus->hello_serial)
1743 return -EIO;
1744
1745 return 0;
1746 }
1747
1748 static int process_reply(sd_bus *bus, sd_bus_message *m) {
1749 struct reply_callback *c;
1750 int r;
1751
1752 assert(bus);
1753 assert(m);
1754
1755 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_RETURN &&
1756 m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_ERROR)
1757 return 0;
1758
1759 c = hashmap_remove(bus->reply_callbacks, &m->reply_serial);
1760 if (!c)
1761 return 0;
1762
1763 if (c->timeout != 0)
1764 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1765
1766 r = sd_bus_message_rewind(m, true);
1767 if (r < 0)
1768 return r;
1769
1770 r = c->callback(bus, m, c->userdata);
1771 free(c);
1772
1773 return r;
1774 }
1775
1776 static int process_filter(sd_bus *bus, sd_bus_message *m) {
1777 struct filter_callback *l;
1778 int r;
1779
1780 assert(bus);
1781 assert(m);
1782
1783 do {
1784 bus->filter_callbacks_modified = false;
1785
1786 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
1787
1788 if (bus->filter_callbacks_modified)
1789 break;
1790
1791 /* Don't run this more than once per iteration */
1792 if (l->last_iteration == bus->iteration_counter)
1793 continue;
1794
1795 l->last_iteration = bus->iteration_counter;
1796
1797 r = sd_bus_message_rewind(m, true);
1798 if (r < 0)
1799 return r;
1800
1801 r = l->callback(bus, m, l->userdata);
1802 if (r != 0)
1803 return r;
1804
1805 }
1806
1807 } while (bus->filter_callbacks_modified);
1808
1809 return 0;
1810 }
1811
1812 static int process_match(sd_bus *bus, sd_bus_message *m) {
1813 int r;
1814
1815 assert(bus);
1816 assert(m);
1817
1818 do {
1819 bus->match_callbacks_modified = false;
1820
1821 r = bus_match_run(bus, &bus->match_callbacks, m);
1822 if (r != 0)
1823 return r;
1824
1825 } while (bus->match_callbacks_modified);
1826
1827 return 0;
1828 }
1829
1830 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
1831 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1832 int r;
1833
1834 assert(bus);
1835 assert(m);
1836
1837 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1838 return 0;
1839
1840 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
1841 return 0;
1842
1843 if (m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
1844 return 1;
1845
1846 if (streq_ptr(m->member, "Ping"))
1847 r = sd_bus_message_new_method_return(bus, m, &reply);
1848 else if (streq_ptr(m->member, "GetMachineId")) {
1849 sd_id128_t id;
1850 char sid[33];
1851
1852 r = sd_id128_get_machine(&id);
1853 if (r < 0)
1854 return r;
1855
1856 r = sd_bus_message_new_method_return(bus, m, &reply);
1857 if (r < 0)
1858 return r;
1859
1860 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
1861 } else {
1862 r = sd_bus_message_new_method_errorf(
1863 bus, m, &reply,
1864 "org.freedesktop.DBus.Error.UnknownMethod",
1865 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
1866 }
1867
1868 if (r < 0)
1869 return r;
1870
1871 r = sd_bus_send(bus, reply, NULL);
1872 if (r < 0)
1873 return r;
1874
1875 return 1;
1876 }
1877
1878 static int node_vtable_get_userdata(
1879 sd_bus *bus,
1880 const char *path,
1881 struct node_vtable *c,
1882 void **userdata) {
1883
1884 void *u;
1885 int r;
1886
1887 assert(bus);
1888 assert(path);
1889 assert(c);
1890
1891 u = c->userdata;
1892 if (c->find) {
1893 r = c->find(bus, path, c->interface, &u, u);
1894 if (r <= 0)
1895 return r;
1896 }
1897
1898 if (userdata)
1899 *userdata = u;
1900
1901 return 1;
1902 }
1903
1904 static void *vtable_property_convert_userdata(const sd_bus_vtable *p, void *u) {
1905 assert(p);
1906
1907 return (uint8_t*) u + p->property.offset;
1908 }
1909
1910 static int vtable_property_get_userdata(
1911 sd_bus *bus,
1912 const char *path,
1913 struct vtable_member *p,
1914 void **userdata) {
1915
1916 void *u;
1917 int r;
1918
1919 assert(bus);
1920 assert(path);
1921 assert(p);
1922 assert(userdata);
1923
1924 r = node_vtable_get_userdata(bus, path, p->parent, &u);
1925 if (r <= 0)
1926 return r;
1927
1928 *userdata = vtable_property_convert_userdata(p->vtable, u);
1929 return 1;
1930 }
1931
1932 static int add_enumerated_to_set(sd_bus *bus, const char *prefix, struct node_enumerator *first, Set *s) {
1933 struct node_enumerator *c;
1934 int r;
1935
1936 assert(bus);
1937 assert(prefix);
1938 assert(s);
1939
1940 LIST_FOREACH(enumerators, c, first) {
1941 char **children = NULL, **k;
1942
1943 r = c->callback(bus, prefix, &children, c->userdata);
1944 if (r < 0)
1945 return r;
1946
1947 STRV_FOREACH(k, children) {
1948 if (r < 0) {
1949 free(*k);
1950 continue;
1951 }
1952
1953 if (!object_path_is_valid(*k) && object_path_startswith(*k, prefix)) {
1954 free(*k);
1955 r = -EINVAL;
1956 continue;
1957 }
1958
1959 r = set_consume(s, *k);
1960 }
1961
1962 free(children);
1963 if (r < 0)
1964 return r;
1965 }
1966
1967 return 0;
1968 }
1969
1970 static int add_subtree_to_set(sd_bus *bus, const char *prefix, struct node *n, Set *s) {
1971 struct node *i;
1972 int r;
1973
1974 assert(bus);
1975 assert(prefix);
1976 assert(n);
1977 assert(s);
1978
1979 r = add_enumerated_to_set(bus, prefix, n->enumerators, s);
1980 if (r < 0)
1981 return r;
1982
1983 LIST_FOREACH(siblings, i, n->child) {
1984 char *t;
1985
1986 t = strdup(i->path);
1987 if (!t)
1988 return -ENOMEM;
1989
1990 r = set_consume(s, t);
1991 if (r < 0 && r != -EEXIST)
1992 return r;
1993
1994 r = add_subtree_to_set(bus, prefix, i, s);
1995 if (r < 0)
1996 return r;
1997 }
1998
1999 return 0;
2000 }
2001
2002 static int get_child_nodes(sd_bus *bus, const char *prefix, struct node *n, Set **_s) {
2003 Set *s = NULL;
2004 int r;
2005
2006 assert(bus);
2007 assert(n);
2008 assert(_s);
2009
2010 s = set_new(string_hash_func, string_compare_func);
2011 if (!s)
2012 return -ENOMEM;
2013
2014 r = add_subtree_to_set(bus, prefix, n, s);
2015 if (r < 0) {
2016 set_free_free(s);
2017 return r;
2018 }
2019
2020 *_s = s;
2021 return 0;
2022 }
2023
2024 static int node_callbacks_run(
2025 sd_bus *bus,
2026 sd_bus_message *m,
2027 struct node_callback *first,
2028 bool require_fallback,
2029 bool *found_object) {
2030
2031 struct node_callback *c;
2032 int r;
2033
2034 assert(bus);
2035 assert(m);
2036 assert(found_object);
2037
2038 LIST_FOREACH(callbacks, c, first) {
2039 if (require_fallback && !c->is_fallback)
2040 continue;
2041
2042 *found_object = true;
2043
2044 if (c->last_iteration == bus->iteration_counter)
2045 continue;
2046
2047 r = sd_bus_message_rewind(m, true);
2048 if (r < 0)
2049 return r;
2050
2051 r = c->callback(bus, m, c->userdata);
2052 if (r != 0)
2053 return r;
2054 }
2055
2056 return 0;
2057 }
2058
2059 static int method_callbacks_run(
2060 sd_bus *bus,
2061 sd_bus_message *m,
2062 struct vtable_member *c,
2063 bool require_fallback,
2064 bool *found_object) {
2065
2066 const char *signature;
2067 void *u;
2068 int r;
2069
2070 assert(bus);
2071 assert(m);
2072 assert(c);
2073 assert(found_object);
2074
2075 if (require_fallback && !c->parent->is_fallback)
2076 return 0;
2077
2078 r = node_vtable_get_userdata(bus, m->path, c->parent, &u);
2079 if (r <= 0)
2080 return r;
2081
2082 *found_object = true;
2083
2084 r = sd_bus_message_rewind(m, true);
2085 if (r < 0)
2086 return r;
2087
2088 r = sd_bus_message_get_signature(m, true, &signature);
2089 if (r < 0)
2090 return r;
2091
2092 if (!streq(c->vtable->method.signature, signature)) {
2093 r = sd_bus_reply_method_errorf(bus, m,
2094 "org.freedesktop.DBus.Error.InvalidArgs",
2095 "Invalid arguments '%s' to call %s:%s, expecting '%s'.",
2096 signature, c->interface, c->member, c->vtable->method.signature);
2097 if (r < 0)
2098 return r;
2099
2100 return 1;
2101 }
2102
2103 if (c->vtable->method.handler)
2104 return c->vtable->method.handler(bus, m, u);
2105
2106 /* If the method callback is NULL, make this a successful NOP */
2107 r = sd_bus_reply_method_return(bus, m, NULL);
2108 if (r < 0)
2109 return r;
2110
2111 return 1;
2112 }
2113
2114 static int invoke_property_get(
2115 sd_bus *bus,
2116 const sd_bus_vtable *v,
2117 const char *path,
2118 const char *interface,
2119 const char *property,
2120 sd_bus_message *m,
2121 sd_bus_error *error,
2122 void *userdata) {
2123
2124 int r;
2125 void *p;
2126
2127 assert(bus);
2128 assert(v);
2129
2130 if (v->property.get)
2131 return v->property.get(bus, path, interface, property, m, error, userdata);
2132
2133 /* Automatic handling if no callback is defined. */
2134
2135 switch (v->property.signature[0]) {
2136
2137 case SD_BUS_TYPE_STRING:
2138 case SD_BUS_TYPE_OBJECT_PATH:
2139 case SD_BUS_TYPE_SIGNATURE:
2140 p = *(char**) userdata;
2141 break;
2142
2143 default:
2144 p = userdata;
2145 }
2146
2147 r = sd_bus_message_append_basic(m, v->property.signature[0], p);
2148 if (r < 0)
2149 return r;
2150
2151 return 1;
2152 }
2153
2154 static int property_get_set_callbacks_run(
2155 sd_bus *bus,
2156 sd_bus_message *m,
2157 struct vtable_member *c,
2158 bool require_fallback,
2159 bool is_get,
2160 bool *found_object) {
2161
2162 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2163 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2164 void *u;
2165 int r;
2166
2167 assert(bus);
2168 assert(m);
2169 assert(found_object);
2170
2171 if (require_fallback && !c->parent->is_fallback)
2172 return 0;
2173
2174 r = vtable_property_get_userdata(bus, m->path, c, &u);
2175 if (r <= 0)
2176 return r;
2177
2178 *found_object = true;
2179
2180 r = sd_bus_message_new_method_return(bus, m, &reply);
2181 if (r < 0)
2182 return r;
2183
2184 c->last_iteration = bus->iteration_counter;
2185
2186 if (is_get) {
2187 r = sd_bus_message_open_container(reply, 'v', c->vtable->property.signature);
2188 if (r < 0)
2189 return r;
2190
2191 r = invoke_property_get(bus, c->vtable, m->path, c->interface, c->member, reply, &error, u);
2192 if (r < 0)
2193 return r;
2194
2195 if (sd_bus_error_is_set(&error)) {
2196 r = sd_bus_reply_method_error(bus, m, &error);
2197 if (r < 0)
2198 return r;
2199
2200 return 1;
2201 }
2202
2203 r = sd_bus_message_close_container(reply);
2204 if (r < 0)
2205 return r;
2206
2207 } else {
2208 if (c->vtable->type != _SD_BUS_VTABLE_WRITABLE_PROPERTY)
2209 sd_bus_error_setf(&error, "org.freedesktop.DBus.Error.PropertyReadOnly", "Property '%s' is not writable.", c->member);
2210 else {
2211 r = sd_bus_message_enter_container(m, 'v', c->vtable->property.signature);
2212 if (r < 0)
2213 return r;
2214
2215 if (c->vtable->property.set) {
2216 r = c->vtable->property.set(bus, m->path, c->interface, c->member, m, &error, u);
2217 if (r < 0)
2218 return r;
2219 } else
2220 assert_not_reached("automatic properties not supported yet");
2221 }
2222
2223 if (sd_bus_error_is_set(&error)) {
2224 r = sd_bus_reply_method_error(bus, m, &error);
2225 if (r < 0)
2226 return r;
2227
2228 return 1;
2229 }
2230
2231 r = sd_bus_message_exit_container(m);
2232 if (r < 0)
2233 return r;
2234 }
2235
2236 r = sd_bus_send(bus, reply, NULL);
2237 if (r < 0)
2238 return r;
2239
2240 return 1;
2241 }
2242
2243 static int vtable_append_all_properties(
2244 sd_bus *bus,
2245 sd_bus_message *reply,
2246 const char *path,
2247 struct node_vtable *c,
2248 void *userdata,
2249 sd_bus_error *error) {
2250
2251 const sd_bus_vtable *v;
2252 int r;
2253
2254 assert(bus);
2255 assert(reply);
2256 assert(c);
2257
2258 for (v = c->vtable+1; v->type != _SD_BUS_VTABLE_END; v++) {
2259 if (v->type != _SD_BUS_VTABLE_PROPERTY && v->type != _SD_BUS_VTABLE_WRITABLE_PROPERTY)
2260 continue;
2261
2262 r = sd_bus_message_open_container(reply, 'e', "sv");
2263 if (r < 0)
2264 return r;
2265
2266 r = sd_bus_message_append(reply, "s", c->interface);
2267 if (r < 0)
2268 return r;
2269
2270 r = sd_bus_message_open_container(reply, 'v', v->property.signature);
2271 if (r < 0)
2272 return r;
2273
2274 r = invoke_property_get(bus, v, path, c->interface, v->property.member, reply, error, vtable_property_convert_userdata(v, userdata));
2275 if (r < 0)
2276 return r;
2277
2278 if (sd_bus_error_is_set(error))
2279 return 0;
2280
2281 r = sd_bus_message_close_container(reply);
2282 if (r < 0)
2283 return r;
2284
2285 r = sd_bus_message_close_container(reply);
2286 if (r < 0)
2287 return r;
2288 }
2289
2290 return 1;
2291 }
2292
2293 static int property_get_all_callbacks_run(
2294 sd_bus *bus,
2295 sd_bus_message *m,
2296 struct node_vtable *first,
2297 bool require_fallback,
2298 const char *iface,
2299 bool *found_object) {
2300
2301 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2302 struct node_vtable *c;
2303 bool found_interface = false;
2304 int r;
2305
2306 assert(bus);
2307 assert(m);
2308 assert(found_object);
2309
2310 r = sd_bus_message_new_method_return(bus, m, &reply);
2311 if (r < 0)
2312 return r;
2313
2314 r = sd_bus_message_open_container(reply, 'a', "{sv}");
2315 if (r < 0)
2316 return r;
2317
2318 LIST_FOREACH(vtables, c, first) {
2319 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2320 void *u;
2321
2322 if (require_fallback && !c->is_fallback)
2323 continue;
2324
2325 r = node_vtable_get_userdata(bus, m->path, c, &u);
2326 if (r < 0)
2327 return r;
2328 if (r == 0)
2329 continue;
2330
2331 *found_object = true;
2332
2333 if (iface && !streq(c->interface, iface))
2334 continue;
2335 found_interface = true;
2336
2337 c->last_iteration = bus->iteration_counter;
2338
2339 r = vtable_append_all_properties(bus, reply, m->path, c, u, &error);
2340 if (r < 0)
2341 return r;
2342
2343 if (sd_bus_error_is_set(&error)) {
2344 r = sd_bus_reply_method_error(bus, m, &error);
2345 if (r < 0)
2346 return r;
2347
2348 return 1;
2349 }
2350 }
2351
2352 if (!found_interface) {
2353 r = sd_bus_reply_method_errorf(
2354 bus, m,
2355 "org.freedesktop.DBus.Error.UnknownInterface",
2356 "Unknown interface '%s'.", iface);
2357 if (r < 0)
2358 return r;
2359
2360 return 1;
2361 }
2362
2363 r = sd_bus_message_close_container(reply);
2364 if (r < 0)
2365 return r;
2366
2367 r = sd_bus_send(bus, reply, NULL);
2368 if (r < 0)
2369 return r;
2370
2371 return 1;
2372 }
2373
2374 static bool bus_node_with_object_manager(sd_bus *bus, struct node *n) {
2375 assert(bus);
2376
2377 if (n->object_manager)
2378 return true;
2379
2380 if (n->parent)
2381 return bus_node_with_object_manager(bus, n->parent);
2382
2383 return false;
2384 }
2385
2386 static bool bus_node_exists(sd_bus *bus, struct node *n, const char *path, bool require_fallback) {
2387 struct node_vtable *c;
2388 struct node_callback *k;
2389
2390 assert(bus);
2391 assert(n);
2392
2393 /* Tests if there's anything attached directly to this node
2394 * for the specified path */
2395
2396 LIST_FOREACH(callbacks, k, n->callbacks) {
2397 if (require_fallback && !k->is_fallback)
2398 continue;
2399
2400 return true;
2401 }
2402
2403 LIST_FOREACH(vtables, c, n->vtables) {
2404
2405 if (require_fallback && !c->is_fallback)
2406 continue;
2407
2408 if (node_vtable_get_userdata(bus, path, c, NULL) > 0)
2409 return true;
2410 }
2411
2412 return !require_fallback && (n->enumerators || n->object_manager);
2413 }
2414
2415 static int process_introspect(
2416 sd_bus *bus,
2417 sd_bus_message *m,
2418 struct node *n,
2419 bool require_fallback,
2420 bool *found_object) {
2421
2422 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2423 _cleanup_set_free_free_ Set *s = NULL;
2424 struct introspect intro;
2425 struct node_vtable *c;
2426 bool empty;
2427 int r;
2428
2429 assert(bus);
2430 assert(m);
2431 assert(n);
2432 assert(found_object);
2433
2434 r = get_child_nodes(bus, m->path, n, &s);
2435 if (r < 0)
2436 return r;
2437
2438 r = introspect_begin(&intro);
2439 if (r < 0)
2440 return r;
2441
2442 r = introspect_write_default_interfaces(&intro, bus_node_with_object_manager(bus, n));
2443 if (r < 0)
2444 return r;
2445
2446 empty = set_isempty(s);
2447
2448 LIST_FOREACH(vtables, c, n->vtables) {
2449 if (require_fallback && !c->is_fallback)
2450 continue;
2451
2452 r = node_vtable_get_userdata(bus, m->path, c, NULL);
2453 if (r < 0)
2454 return r;
2455 if (r == 0)
2456 continue;
2457
2458 empty = false;
2459
2460 r = introspect_write_interface(&intro, c->interface, c->vtable);
2461 if (r < 0)
2462 goto finish;
2463 }
2464
2465 if (empty) {
2466 /* Nothing?, let's see if we exist at all, and if not
2467 * refuse to do anything */
2468 r = bus_node_exists(bus, n, m->path, require_fallback);
2469 if (r < 0)
2470 return r;
2471
2472 if (r == 0)
2473 goto finish;
2474 }
2475
2476 *found_object = true;
2477
2478 r = introspect_write_child_nodes(&intro, s, m->path);
2479 if (r < 0)
2480 goto finish;
2481
2482 r = introspect_finish(&intro, bus, m, &reply);
2483 if (r < 0)
2484 goto finish;
2485
2486 r = sd_bus_send(bus, reply, NULL);
2487 if (r < 0)
2488 goto finish;
2489
2490 r = 1;
2491
2492 finish:
2493 introspect_free(&intro);
2494 return r;
2495 }
2496
2497 static int object_manager_serialize_vtable(
2498 sd_bus *bus,
2499 sd_bus_message *reply,
2500 const char *path,
2501 struct node_vtable *c,
2502 sd_bus_error *error) {
2503
2504 void *u;
2505 int r;
2506
2507 assert(bus);
2508 assert(reply);
2509 assert(path);
2510 assert(c);
2511 assert(error);
2512
2513 r = node_vtable_get_userdata(bus, path, c, &u);
2514 if (r <= 0)
2515 return r;
2516
2517 r = sd_bus_message_open_container(reply, 'e', "sa{sv}");
2518 if (r < 0)
2519 return r;
2520
2521 r = sd_bus_message_append(reply, "s", c->interface);
2522 if (r < 0)
2523 return r;
2524
2525 r = sd_bus_message_open_container(reply, 'a', "{sv}");
2526 if (r < 0)
2527 return r;
2528
2529 r = vtable_append_all_properties(bus, reply, path, c, u, error);
2530 if (r < 0)
2531 return r;
2532
2533 r = sd_bus_message_close_container(reply);
2534 if (r < 0)
2535 return r;
2536
2537 r = sd_bus_message_close_container(reply);
2538 if (r < 0)
2539 return r;
2540
2541 return 0;
2542 }
2543
2544 static int object_manager_serialize_path(
2545 sd_bus *bus,
2546 sd_bus_message *reply,
2547 const char *prefix,
2548 const char *path,
2549 bool require_fallback,
2550 sd_bus_error *error) {
2551
2552 struct node_vtable *i;
2553 struct node *n;
2554 int r;
2555
2556 assert(bus);
2557 assert(reply);
2558 assert(prefix);
2559 assert(path);
2560 assert(error);
2561
2562 n = hashmap_get(bus->nodes, prefix);
2563 if (!n)
2564 return 0;
2565
2566 r = sd_bus_message_open_container(reply, 'e', "oa{sa{sv}}");
2567 if (r < 0)
2568 return r;
2569
2570 r = sd_bus_message_append(reply, "o", path);
2571 if (r < 0)
2572 return r;
2573
2574 r = sd_bus_message_open_container(reply, 'a', "{sa{sv}}");
2575 if (r < 0)
2576 return r;
2577
2578 LIST_FOREACH(vtables, i, n->vtables) {
2579
2580 if (require_fallback && !i->is_fallback)
2581 continue;
2582
2583 r = object_manager_serialize_vtable(bus, reply, path, i, error);
2584 if (r < 0)
2585 return r;
2586 if (sd_bus_error_is_set(error))
2587 return 0;
2588 }
2589
2590 r = sd_bus_message_close_container(reply);
2591 if (r < 0)
2592 return r;
2593
2594 r = sd_bus_message_close_container(reply);
2595 if (r < 0)
2596 return r;
2597
2598 return 1;
2599 }
2600
2601 static int object_manager_serialize_path_and_fallbacks(
2602 sd_bus *bus,
2603 sd_bus_message *reply,
2604 const char *path,
2605 sd_bus_error *error) {
2606
2607 size_t pl;
2608 int r;
2609
2610 assert(bus);
2611 assert(reply);
2612 assert(path);
2613 assert(error);
2614
2615 /* First, add all vtables registered for this path */
2616 r = object_manager_serialize_path(bus, reply, path, path, false, error);
2617 if (r < 0)
2618 return r;
2619 if (sd_bus_error_is_set(error))
2620 return 0;
2621
2622 /* Second, add fallback vtables registered for any of the prefixes */
2623 pl = strlen(path);
2624 if (pl > 1) {
2625 char p[pl + 1];
2626 strcpy(p, path);
2627
2628 for (;;) {
2629 char *e;
2630
2631 e = strrchr(p, '/');
2632 if (e == p || !e)
2633 break;
2634
2635 *e = 0;
2636
2637 r = object_manager_serialize_path(bus, reply, p, path, true, error);
2638 if (r < 0)
2639 return r;
2640
2641 if (sd_bus_error_is_set(error))
2642 return 0;
2643 }
2644 }
2645
2646 return 0;
2647 }
2648
2649 static int process_get_managed_objects(
2650 sd_bus *bus,
2651 sd_bus_message *m,
2652 struct node *n,
2653 bool require_fallback,
2654 bool *found_object) {
2655
2656 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2657 _cleanup_set_free_free_ Set *s = NULL;
2658 bool empty;
2659 int r;
2660
2661 assert(bus);
2662 assert(m);
2663 assert(n);
2664 assert(found_object);
2665
2666 if (!bus_node_with_object_manager(bus, n))
2667 return 0;
2668
2669 r = get_child_nodes(bus, m->path, n, &s);
2670 if (r < 0)
2671 return r;
2672
2673 r = sd_bus_message_new_method_return(bus, m, &reply);
2674 if (r < 0)
2675 return r;
2676
2677 r = sd_bus_message_open_container(reply, 'a', "{oa{sa{sv}}}");
2678 if (r < 0)
2679 return r;
2680
2681 empty = set_isempty(s);
2682 if (empty) {
2683 struct node_vtable *c;
2684
2685 /* Hmm, so we have no children? Then let's check
2686 * whether we exist at all, i.e. whether at least one
2687 * vtable exists. */
2688
2689 LIST_FOREACH(vtables, c, n->vtables) {
2690
2691 if (require_fallback && !c->is_fallback)
2692 continue;
2693
2694 if (r < 0)
2695 return r;
2696 if (r == 0)
2697 continue;
2698
2699 empty = false;
2700 break;
2701 }
2702
2703 if (empty)
2704 return 0;
2705 } else {
2706 Iterator i;
2707 char *path;
2708
2709 SET_FOREACH(path, s, i) {
2710 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2711
2712 r = object_manager_serialize_path_and_fallbacks(bus, reply, path, &error);
2713 if (r < 0)
2714 return -ENOMEM;
2715
2716 if (sd_bus_error_is_set(&error)) {
2717 r = sd_bus_reply_method_error(bus, m, &error);
2718 if (r < 0)
2719 return r;
2720
2721 return 1;
2722 }
2723 }
2724 }
2725
2726 r = sd_bus_message_close_container(reply);
2727 if (r < 0)
2728 return r;
2729
2730 r = sd_bus_send(bus, reply, NULL);
2731 if (r < 0)
2732 return r;
2733
2734 return 1;
2735 }
2736
2737 static int object_find_and_run(
2738 sd_bus *bus,
2739 sd_bus_message *m,
2740 const char *p,
2741 bool require_fallback,
2742 bool *found_object) {
2743
2744 struct node *n;
2745 struct vtable_member vtable_key, *v;
2746 int r;
2747
2748 assert(bus);
2749 assert(m);
2750 assert(p);
2751 assert(found_object);
2752
2753 n = hashmap_get(bus->nodes, p);
2754 if (!n)
2755 return 0;
2756
2757 /* First, try object callbacks */
2758 r = node_callbacks_run(bus, m, n->callbacks, require_fallback, found_object);
2759 if (r != 0)
2760 return r;
2761
2762 if (!m->interface || !m->member)
2763 return 0;
2764
2765 /* Then, look for a known method */
2766 vtable_key.path = (char*) p;
2767 vtable_key.interface = m->interface;
2768 vtable_key.member = m->member;
2769
2770 v = hashmap_get(bus->vtable_methods, &vtable_key);
2771 if (v) {
2772 r = method_callbacks_run(bus, m, v, require_fallback, found_object);
2773 if (r != 0)
2774 return r;
2775 }
2776
2777 /* Then, look for a known property */
2778 if (streq(m->interface, "org.freedesktop.DBus.Properties")) {
2779 bool get = false;
2780
2781 get = streq(m->member, "Get");
2782
2783 if (get || streq(m->member, "Set")) {
2784
2785 r = sd_bus_message_rewind(m, true);
2786 if (r < 0)
2787 return r;
2788
2789 vtable_key.path = (char*) p;
2790
2791 r = sd_bus_message_read(m, "ss", &vtable_key.interface, &vtable_key.member);
2792 if (r < 0)
2793 return r;
2794
2795 v = hashmap_get(bus->vtable_properties, &vtable_key);
2796 if (v) {
2797 r = property_get_set_callbacks_run(bus, m, v, require_fallback, get, found_object);
2798 if (r != 0)
2799 return r;
2800 }
2801
2802 } else if (streq(m->member, "GetAll")) {
2803 const char *iface;
2804
2805 r = sd_bus_message_rewind(m, true);
2806 if (r < 0)
2807 return r;
2808
2809 r = sd_bus_message_read(m, "s", &iface);
2810 if (r < 0)
2811 return r;
2812
2813 if (iface[0] == 0)
2814 iface = NULL;
2815
2816 r = property_get_all_callbacks_run(bus, m, n->vtables, require_fallback, iface, found_object);
2817 if (r != 0)
2818 return r;
2819 }
2820
2821 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
2822
2823 r = process_introspect(bus, m, n, require_fallback, found_object);
2824 if (r != 0)
2825 return r;
2826
2827 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.ObjectManager", "GetManagedObjects")) {
2828
2829 r = process_get_managed_objects(bus, m, n, require_fallback, found_object);
2830 if (r != 0)
2831 return r;
2832 }
2833
2834 if (!*found_object) {
2835 r = bus_node_exists(bus, n, m->path, require_fallback);
2836 if (r < 0)
2837 return r;
2838
2839 if (r > 0)
2840 *found_object = true;
2841 }
2842
2843 return 0;
2844 }
2845
2846 static int process_object(sd_bus *bus, sd_bus_message *m) {
2847 int r;
2848 size_t pl;
2849 bool found_object = false;
2850
2851 assert(bus);
2852 assert(m);
2853
2854 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
2855 return 0;
2856
2857 if (!m->path)
2858 return 0;
2859
2860 if (hashmap_isempty(bus->nodes))
2861 return 0;
2862
2863 pl = strlen(m->path);
2864 do {
2865 char p[pl+1];
2866
2867 bus->nodes_modified = false;
2868
2869 r = object_find_and_run(bus, m, m->path, false, &found_object);
2870 if (r != 0)
2871 return r;
2872
2873 /* Look for fallback prefixes */
2874 strcpy(p, m->path);
2875 for (;;) {
2876 char *e;
2877
2878 if (streq(p, "/"))
2879 break;
2880
2881 if (bus->nodes_modified)
2882 break;
2883
2884 e = strrchr(p, '/');
2885 assert(e);
2886 if (e == p)
2887 *(e+1) = 0;
2888 else
2889 *e = 0;
2890
2891 r = object_find_and_run(bus, m, p, true, &found_object);
2892 if (r != 0)
2893 return r;
2894 }
2895
2896 } while (bus->nodes_modified);
2897
2898 if (!found_object)
2899 return 0;
2900
2901 if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "Get") ||
2902 sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "Set"))
2903 r = sd_bus_reply_method_errorf(
2904 bus, m,
2905 "org.freedesktop.DBus.Error.UnknownProperty",
2906 "Unknown property or interface.");
2907 else
2908 r = sd_bus_reply_method_errorf(
2909 bus, m,
2910 "org.freedesktop.DBus.Error.UnknownMethod",
2911 "Unknown method '%s' or interface '%s'.", m->member, m->interface);
2912
2913 if (r < 0)
2914 return r;
2915
2916 return 1;
2917 }
2918
2919 static int process_message(sd_bus *bus, sd_bus_message *m) {
2920 int r;
2921
2922 assert(bus);
2923 assert(m);
2924
2925 bus->iteration_counter++;
2926
2927 r = process_hello(bus, m);
2928 if (r != 0)
2929 return r;
2930
2931 r = process_reply(bus, m);
2932 if (r != 0)
2933 return r;
2934
2935 r = process_filter(bus, m);
2936 if (r != 0)
2937 return r;
2938
2939 r = process_match(bus, m);
2940 if (r != 0)
2941 return r;
2942
2943 r = process_builtin(bus, m);
2944 if (r != 0)
2945 return r;
2946
2947 return process_object(bus, m);
2948 }
2949
2950 static int process_running(sd_bus *bus, sd_bus_message **ret) {
2951 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2952 int r;
2953
2954 assert(bus);
2955 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2956
2957 r = process_timeout(bus);
2958 if (r != 0)
2959 goto null_message;
2960
2961 r = dispatch_wqueue(bus);
2962 if (r != 0)
2963 goto null_message;
2964
2965 r = dispatch_rqueue(bus, &m);
2966 if (r < 0)
2967 return r;
2968 if (!m)
2969 goto null_message;
2970
2971 r = process_message(bus, m);
2972 if (r != 0)
2973 goto null_message;
2974
2975 if (ret) {
2976 r = sd_bus_message_rewind(m, true);
2977 if (r < 0)
2978 return r;
2979
2980 *ret = m;
2981 m = NULL;
2982 return 1;
2983 }
2984
2985 if (m->header->type == SD_BUS_MESSAGE_TYPE_METHOD_CALL) {
2986
2987 r = sd_bus_reply_method_errorf(
2988 bus, m,
2989 "org.freedesktop.DBus.Error.UnknownObject",
2990 "Unknown object '%s'.", m->path);
2991 if (r < 0)
2992 return r;
2993 }
2994
2995 return 1;
2996
2997 null_message:
2998 if (r >= 0 && ret)
2999 *ret = NULL;
3000
3001 return r;
3002 }
3003
3004 int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
3005 int r;
3006
3007 /* Returns 0 when we didn't do anything. This should cause the
3008 * caller to invoke sd_bus_wait() before returning the next
3009 * time. Returns > 0 when we did something, which possibly
3010 * means *ret is filled in with an unprocessed message. */
3011
3012 if (!bus)
3013 return -EINVAL;
3014 if (bus_pid_changed(bus))
3015 return -ECHILD;
3016
3017 /* We don't allow recursively invoking sd_bus_process(). */
3018 if (bus->processing)
3019 return -EBUSY;
3020
3021 switch (bus->state) {
3022
3023 case BUS_UNSET:
3024 case BUS_CLOSED:
3025 return -ENOTCONN;
3026
3027 case BUS_OPENING:
3028 r = bus_socket_process_opening(bus);
3029 if (r < 0)
3030 return r;
3031 if (ret)
3032 *ret = NULL;
3033 return r;
3034
3035 case BUS_AUTHENTICATING:
3036
3037 r = bus_socket_process_authenticating(bus);
3038 if (r < 0)
3039 return r;
3040 if (ret)
3041 *ret = NULL;
3042 return r;
3043
3044 case BUS_RUNNING:
3045 case BUS_HELLO:
3046
3047 bus->processing = true;
3048 r = process_running(bus, ret);
3049 bus->processing = false;
3050
3051 return r;
3052 }
3053
3054 assert_not_reached("Unknown state");
3055 }
3056
3057 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
3058 struct pollfd p[2] = {};
3059 int r, e, n;
3060 struct timespec ts;
3061 usec_t until, m;
3062
3063 assert(bus);
3064
3065 if (!BUS_IS_OPEN(bus->state))
3066 return -ENOTCONN;
3067
3068 e = sd_bus_get_events(bus);
3069 if (e < 0)
3070 return e;
3071
3072 if (need_more)
3073 e |= POLLIN;
3074
3075 r = sd_bus_get_timeout(bus, &until);
3076 if (r < 0)
3077 return r;
3078 if (r == 0)
3079 m = (uint64_t) -1;
3080 else {
3081 usec_t nw;
3082 nw = now(CLOCK_MONOTONIC);
3083 m = until > nw ? until - nw : 0;
3084 }
3085
3086 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
3087 m = timeout_usec;
3088
3089 p[0].fd = bus->input_fd;
3090 if (bus->output_fd == bus->input_fd) {
3091 p[0].events = e;
3092 n = 1;
3093 } else {
3094 p[0].events = e & POLLIN;
3095 p[1].fd = bus->output_fd;
3096 p[1].events = e & POLLOUT;
3097 n = 2;
3098 }
3099
3100 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
3101 if (r < 0)
3102 return -errno;
3103
3104 return r > 0 ? 1 : 0;
3105 }
3106
3107 int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
3108
3109 if (!bus)
3110 return -EINVAL;
3111 if (!BUS_IS_OPEN(bus->state))
3112 return -ENOTCONN;
3113 if (bus_pid_changed(bus))
3114 return -ECHILD;
3115
3116 if (bus->rqueue_size > 0)
3117 return 0;
3118
3119 return bus_poll(bus, false, timeout_usec);
3120 }
3121
3122 int sd_bus_flush(sd_bus *bus) {
3123 int r;
3124
3125 if (!bus)
3126 return -EINVAL;
3127 if (!BUS_IS_OPEN(bus->state))
3128 return -ENOTCONN;
3129 if (bus_pid_changed(bus))
3130 return -ECHILD;
3131
3132 r = bus_ensure_running(bus);
3133 if (r < 0)
3134 return r;
3135
3136 if (bus->wqueue_size <= 0)
3137 return 0;
3138
3139 for (;;) {
3140 r = dispatch_wqueue(bus);
3141 if (r < 0)
3142 return r;
3143
3144 if (bus->wqueue_size <= 0)
3145 return 0;
3146
3147 r = bus_poll(bus, false, (uint64_t) -1);
3148 if (r < 0)
3149 return r;
3150 }
3151 }
3152
3153 int sd_bus_add_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *userdata) {
3154 struct filter_callback *f;
3155
3156 if (!bus)
3157 return -EINVAL;
3158 if (!callback)
3159 return -EINVAL;
3160 if (bus_pid_changed(bus))
3161 return -ECHILD;
3162
3163 f = new0(struct filter_callback, 1);
3164 if (!f)
3165 return -ENOMEM;
3166 f->callback = callback;
3167 f->userdata = userdata;
3168
3169 bus->filter_callbacks_modified = true;
3170 LIST_PREPEND(struct filter_callback, callbacks, bus->filter_callbacks, f);
3171 return 0;
3172 }
3173
3174 int sd_bus_remove_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *userdata) {
3175 struct filter_callback *f;
3176
3177 if (!bus)
3178 return -EINVAL;
3179 if (!callback)
3180 return -EINVAL;
3181 if (bus_pid_changed(bus))
3182 return -ECHILD;
3183
3184 LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
3185 if (f->callback == callback && f->userdata == userdata) {
3186 bus->filter_callbacks_modified = true;
3187 LIST_REMOVE(struct filter_callback, callbacks, bus->filter_callbacks, f);
3188 free(f);
3189 return 1;
3190 }
3191 }
3192
3193 return 0;
3194 }
3195
3196 static struct node *bus_node_allocate(sd_bus *bus, const char *path) {
3197 struct node *n, *parent;
3198 const char *e;
3199 char *s, *p;
3200 int r;
3201
3202 assert(bus);
3203 assert(path);
3204 assert(path[0] == '/');
3205
3206 n = hashmap_get(bus->nodes, path);
3207 if (n)
3208 return n;
3209
3210 r = hashmap_ensure_allocated(&bus->nodes, string_hash_func, string_compare_func);
3211 if (r < 0)
3212 return NULL;
3213
3214 s = strdup(path);
3215 if (!s)
3216 return NULL;
3217
3218 if (streq(path, "/"))
3219 parent = NULL;
3220 else {
3221 e = strrchr(path, '/');
3222 assert(e);
3223
3224 p = strndupa(path, MAX(1, path - e));
3225
3226 parent = bus_node_allocate(bus, p);
3227 if (!parent) {
3228 free(s);
3229 return NULL;
3230 }
3231 }
3232
3233 n = new0(struct node, 1);
3234 if (!n)
3235 return NULL;
3236
3237 n->parent = parent;
3238 n->path = s;
3239
3240 r = hashmap_put(bus->nodes, s, n);
3241 if (r < 0) {
3242 free(s);
3243 free(n);
3244 return NULL;
3245 }
3246
3247 if (parent)
3248 LIST_PREPEND(struct node, siblings, parent->child, n);
3249
3250 return n;
3251 }
3252
3253 static void bus_node_gc(sd_bus *b, struct node *n) {
3254 assert(b);
3255
3256 if (!n)
3257 return;
3258
3259 if (n->child ||
3260 n->callbacks ||
3261 n->vtables ||
3262 n->enumerators ||
3263 n->object_manager)
3264 return;
3265
3266 assert(hashmap_remove(b->nodes, n->path) == n);
3267
3268 if (n->parent)
3269 LIST_REMOVE(struct node, siblings, n->parent->child, n);
3270
3271 free(n->path);
3272 bus_node_gc(b, n->parent);
3273 free(n);
3274 }
3275
3276 static int bus_add_object(
3277 sd_bus *b,
3278 bool fallback,
3279 const char *path,
3280 sd_bus_message_handler_t callback,
3281 void *userdata) {
3282
3283 struct node_callback *c;
3284 struct node *n;
3285 int r;
3286
3287 if (!b)
3288 return -EINVAL;
3289 if (!object_path_is_valid(path))
3290 return -EINVAL;
3291 if (!callback)
3292 return -EINVAL;
3293 if (bus_pid_changed(b))
3294 return -ECHILD;
3295
3296 n = bus_node_allocate(b, path);
3297 if (!n)
3298 return -ENOMEM;
3299
3300 c = new0(struct node_callback, 1);
3301 if (!c) {
3302 r = -ENOMEM;
3303 goto fail;
3304 }
3305
3306 c->node = n;
3307 c->callback = callback;
3308 c->userdata = userdata;
3309 c->is_fallback = fallback;
3310
3311 LIST_PREPEND(struct node_callback, callbacks, n->callbacks, c);
3312 return 0;
3313
3314 fail:
3315 free(c);
3316 bus_node_gc(b, n);
3317 return r;
3318 }
3319
3320 static int bus_remove_object(
3321 sd_bus *bus,
3322 bool fallback,
3323 const char *path,
3324 sd_bus_message_handler_t callback,
3325 void *userdata) {
3326
3327 struct node_callback *c;
3328 struct node *n;
3329
3330 if (!bus)
3331 return -EINVAL;
3332 if (!object_path_is_valid(path))
3333 return -EINVAL;
3334 if (!callback)
3335 return -EINVAL;
3336 if (bus_pid_changed(bus))
3337 return -ECHILD;
3338
3339 n = hashmap_get(bus->nodes, path);
3340 if (!n)
3341 return 0;
3342
3343 LIST_FOREACH(callbacks, c, n->callbacks)
3344 if (c->callback == callback && c->userdata == userdata && c->is_fallback == fallback)
3345 break;
3346 if (!c)
3347 return 0;
3348
3349 LIST_REMOVE(struct node_callback, callbacks, n->callbacks, c);
3350 free(c);
3351
3352 bus_node_gc(bus, n);
3353
3354 return 1;
3355 }
3356
3357 int sd_bus_add_object(sd_bus *bus, const char *path, sd_bus_message_handler_t callback, void *userdata) {
3358 return bus_add_object(bus, false, path, callback, userdata);
3359 }
3360
3361 int sd_bus_remove_object(sd_bus *bus, const char *path, sd_bus_message_handler_t callback, void *userdata) {
3362 return bus_remove_object(bus, false, path, callback, userdata);
3363 }
3364
3365 int sd_bus_add_fallback(sd_bus *bus, const char *prefix, sd_bus_message_handler_t callback, void *userdata) {
3366 return bus_add_object(bus, true, prefix, callback, userdata);
3367 }
3368
3369 int sd_bus_remove_fallback(sd_bus *bus, const char *prefix, sd_bus_message_handler_t callback, void *userdata) {
3370 return bus_remove_object(bus, true, prefix, callback, userdata);
3371 }
3372
3373 int sd_bus_add_match(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata) {
3374 struct bus_match_component *components = NULL;
3375 unsigned n_components = 0;
3376 uint64_t cookie = 0;
3377 int r = 0;
3378
3379 if (!bus)
3380 return -EINVAL;
3381 if (!match)
3382 return -EINVAL;
3383 if (bus_pid_changed(bus))
3384 return -ECHILD;
3385
3386 r = bus_match_parse(match, &components, &n_components);
3387 if (r < 0)
3388 goto finish;
3389
3390 if (bus->bus_client) {
3391 cookie = ++bus->match_cookie;
3392
3393 r = bus_add_match_internal(bus, match, components, n_components, cookie);
3394 if (r < 0)
3395 goto finish;
3396 }
3397
3398 bus->match_callbacks_modified = true;
3399 r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
3400 if (r < 0) {
3401 if (bus->bus_client)
3402 bus_remove_match_internal(bus, match, cookie);
3403 }
3404
3405 finish:
3406 bus_match_parse_free(components, n_components);
3407 return r;
3408 }
3409
3410 int sd_bus_remove_match(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata) {
3411 struct bus_match_component *components = NULL;
3412 unsigned n_components = 0;
3413 int r = 0, q = 0;
3414 uint64_t cookie = 0;
3415
3416 if (!bus)
3417 return -EINVAL;
3418 if (!match)
3419 return -EINVAL;
3420 if (bus_pid_changed(bus))
3421 return -ECHILD;
3422
3423 r = bus_match_parse(match, &components, &n_components);
3424 if (r < 0)
3425 return r;
3426
3427 bus->match_callbacks_modified = true;
3428 r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
3429
3430 if (bus->bus_client)
3431 q = bus_remove_match_internal(bus, match, cookie);
3432
3433 bus_match_parse_free(components, n_components);
3434
3435 return r < 0 ? r : q;
3436 }
3437
3438 int sd_bus_emit_signal(
3439 sd_bus *bus,
3440 const char *path,
3441 const char *interface,
3442 const char *member,
3443 const char *types, ...) {
3444
3445 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
3446 int r;
3447
3448 if (!bus)
3449 return -EINVAL;
3450 if (!BUS_IS_OPEN(bus->state))
3451 return -ENOTCONN;
3452 if (bus_pid_changed(bus))
3453 return -ECHILD;
3454
3455 r = sd_bus_message_new_signal(bus, path, interface, member, &m);
3456 if (r < 0)
3457 return r;
3458
3459 if (!isempty(types)) {
3460 va_list ap;
3461
3462 va_start(ap, types);
3463 r = bus_message_append_ap(m, types, ap);
3464 va_end(ap);
3465 if (r < 0)
3466 return r;
3467 }
3468
3469 return sd_bus_send(bus, m, NULL);
3470 }
3471
3472 int sd_bus_call_method(
3473 sd_bus *bus,
3474 const char *destination,
3475 const char *path,
3476 const char *interface,
3477 const char *member,
3478 sd_bus_error *error,
3479 sd_bus_message **reply,
3480 const char *types, ...) {
3481
3482 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
3483 int r;
3484
3485 if (!bus)
3486
3487 return -EINVAL;
3488 if (!BUS_IS_OPEN(bus->state))
3489 return -ENOTCONN;
3490 if (bus_pid_changed(bus))
3491 return -ECHILD;
3492
3493 r = sd_bus_message_new_method_call(bus, destination, path, interface, member, &m);
3494 if (r < 0)
3495 return r;
3496
3497 if (!isempty(types)) {
3498 va_list ap;
3499
3500 va_start(ap, types);
3501 r = bus_message_append_ap(m, types, ap);
3502 va_end(ap);
3503 if (r < 0)
3504 return r;
3505 }
3506
3507 return sd_bus_send_with_reply_and_block(bus, m, 0, error, reply);
3508 }
3509
3510 int sd_bus_reply_method_return(
3511 sd_bus *bus,
3512 sd_bus_message *call,
3513 const char *types, ...) {
3514
3515 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
3516 int r;
3517
3518 if (!bus)
3519 return -EINVAL;
3520 if (!call)
3521 return -EINVAL;
3522 if (!call->sealed)
3523 return -EPERM;
3524 if (call->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
3525 return -EINVAL;
3526 if (!BUS_IS_OPEN(bus->state))
3527 return -ENOTCONN;
3528 if (bus_pid_changed(bus))
3529 return -ECHILD;
3530
3531 if (call->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
3532 return 0;
3533
3534 r = sd_bus_message_new_method_return(bus, call, &m);
3535 if (r < 0)
3536 return r;
3537
3538 if (!isempty(types)) {
3539 va_list ap;
3540
3541 va_start(ap, types);
3542 r = bus_message_append_ap(m, types, ap);
3543 va_end(ap);
3544 if (r < 0)
3545 return r;
3546 }
3547
3548 return sd_bus_send(bus, m, NULL);
3549 }
3550
3551 int sd_bus_reply_method_error(
3552 sd_bus *bus,
3553 sd_bus_message *call,
3554 const sd_bus_error *e) {
3555
3556 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
3557 int r;
3558
3559 if (!bus)
3560 return -EINVAL;
3561 if (!call)
3562 return -EINVAL;
3563 if (!call->sealed)
3564 return -EPERM;
3565 if (call->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
3566 return -EINVAL;
3567 if (!sd_bus_error_is_set(e))
3568 return -EINVAL;
3569 if (!BUS_IS_OPEN(bus->state))
3570 return -ENOTCONN;
3571 if (bus_pid_changed(bus))
3572 return -ECHILD;
3573
3574 if (call->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
3575 return 0;
3576
3577 r = sd_bus_message_new_method_error(bus, call, e, &m);
3578 if (r < 0)
3579 return r;
3580
3581 return sd_bus_send(bus, m, NULL);
3582 }
3583
3584 int sd_bus_reply_method_errorf(
3585 sd_bus *bus,
3586 sd_bus_message *call,
3587 const char *name,
3588 const char *format,
3589 ...) {
3590
3591 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
3592 char *n, *m;
3593 va_list ap;
3594 int r;
3595
3596 n = strdup(name);
3597 if (!n)
3598 return -ENOMEM;
3599
3600 if (format) {
3601 va_start(ap, format);
3602 r = vasprintf(&m, format, ap);
3603 va_end(ap);
3604
3605 if (r < 0) {
3606 free(n);
3607 return -ENOMEM;
3608 }
3609 }
3610
3611 error.name = n;
3612 error.message = m;
3613 error.need_free = true;
3614
3615 return sd_bus_reply_method_error(bus, call, &error);
3616 }
3617
3618 bool bus_pid_changed(sd_bus *bus) {
3619 assert(bus);
3620
3621 /* We don't support people creating a bus connection and
3622 * keeping it around over a fork(). Let's complain. */
3623
3624 return bus->original_pid != getpid();
3625 }
3626
3627 static void free_node_vtable(sd_bus *bus, struct node_vtable *w) {
3628 assert(bus);
3629
3630 if (!w)
3631 return;
3632
3633 if (w->interface && w->node && w->vtable) {
3634 const sd_bus_vtable *v;
3635
3636 for (v = w->vtable; v->type != _SD_BUS_VTABLE_END; v++) {
3637 struct vtable_member *x = NULL;
3638
3639 switch (v->type) {
3640
3641 case _SD_BUS_VTABLE_METHOD: {
3642 struct vtable_member key;
3643
3644 key.path = w->node->path;
3645 key.interface = w->interface;
3646 key.member = v->method.member;
3647
3648 x = hashmap_remove(bus->vtable_methods, &key);
3649 break;
3650 }
3651
3652 case _SD_BUS_VTABLE_PROPERTY:
3653 case _SD_BUS_VTABLE_WRITABLE_PROPERTY: {
3654 struct vtable_member key;
3655
3656 key.path = w->node->path;
3657 key.interface = w->interface;
3658 key.member = v->property.member;
3659 x = hashmap_remove(bus->vtable_properties, &key);
3660 break;
3661 }}
3662
3663 free(x);
3664 }
3665 }
3666
3667 free(w->interface);
3668 free(w);
3669 }
3670
3671 static unsigned vtable_member_hash_func(const void *a) {
3672 const struct vtable_member *m = a;
3673
3674 return
3675 string_hash_func(m->path) ^
3676 string_hash_func(m->interface) ^
3677 string_hash_func(m->member);
3678 }
3679
3680 static int vtable_member_compare_func(const void *a, const void *b) {
3681 const struct vtable_member *x = a, *y = b;
3682 int r;
3683
3684 r = strcmp(x->path, y->path);
3685 if (r != 0)
3686 return r;
3687
3688 r = strcmp(x->interface, y->interface);
3689 if (r != 0)
3690 return r;
3691
3692 return strcmp(x->member, y->member);
3693 }
3694
3695 static int add_object_vtable_internal(
3696 sd_bus *bus,
3697 const char *path,
3698 const char *interface,
3699 const sd_bus_vtable *vtable,
3700 bool fallback,
3701 sd_bus_object_find_t find,
3702 void *userdata) {
3703
3704 struct node_vtable *c = NULL, *i;
3705 const sd_bus_vtable *v;
3706 struct node *n;
3707 int r;
3708
3709 if (!bus)
3710 return -EINVAL;
3711 if (!object_path_is_valid(path))
3712 return -EINVAL;
3713 if (!interface_name_is_valid(interface))
3714 return -EINVAL;
3715 if (!vtable || vtable[0].type != _SD_BUS_VTABLE_START || vtable[0].start.element_size != sizeof(struct sd_bus_vtable))
3716 return -EINVAL;
3717 if (bus_pid_changed(bus))
3718 return -ECHILD;
3719
3720 r = hashmap_ensure_allocated(&bus->vtable_methods, vtable_member_hash_func, vtable_member_compare_func);
3721 if (r < 0)
3722 return r;
3723
3724 r = hashmap_ensure_allocated(&bus->vtable_properties, vtable_member_hash_func, vtable_member_compare_func);
3725 if (r < 0)
3726 return r;
3727
3728 n = bus_node_allocate(bus, path);
3729 if (!n)
3730 return -ENOMEM;
3731
3732 LIST_FOREACH(vtables, i, n->vtables) {
3733 if (streq(i->interface, interface)) {
3734 r = -EEXIST;
3735 goto fail;
3736 }
3737
3738 if (i->is_fallback != fallback) {
3739 r = -EPROTOTYPE;
3740 goto fail;
3741 }
3742 }
3743
3744 c = new0(struct node_vtable, 1);
3745 if (!c) {
3746 r = -ENOMEM;
3747 goto fail;
3748 }
3749
3750 c->node = n;
3751 c->is_fallback = fallback;
3752 c->vtable = vtable;
3753 c->userdata = userdata;
3754 c->find = find;
3755
3756 c->interface = strdup(interface);
3757 if (!c->interface) {
3758 r = -ENOMEM;
3759 goto fail;
3760 }
3761
3762 for (v = c->vtable+1; v->type != _SD_BUS_VTABLE_END; v++) {
3763
3764 switch (v->type) {
3765
3766 case _SD_BUS_VTABLE_METHOD: {
3767 struct vtable_member *m;
3768
3769 if (!member_name_is_valid(v->method.member) ||
3770 !signature_is_valid(v->method.signature, false) ||
3771 !signature_is_valid(v->method.result, false) ||
3772 !(v->method.handler || (isempty(v->method.signature) && isempty(v->method.result))) ||
3773 v->flags & (SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE|SD_BUS_VTABLE_PROPERTY_INVALIDATE_ONLY)) {
3774 r = -EINVAL;
3775 goto fail;
3776 }
3777
3778 m = new0(struct vtable_member, 1);
3779 if (!m) {
3780 r = -ENOMEM;
3781 goto fail;
3782 }
3783
3784 m->parent = c;
3785 m->path = n->path;
3786 m->interface = c->interface;
3787 m->member = v->method.member;
3788 m->vtable = v;
3789
3790 r = hashmap_put(bus->vtable_methods, m, m);
3791 if (r < 0) {
3792 free(m);
3793 goto fail;
3794 }
3795
3796 break;
3797 }
3798
3799 case _SD_BUS_VTABLE_PROPERTY:
3800 case _SD_BUS_VTABLE_WRITABLE_PROPERTY: {
3801 struct vtable_member *m;
3802
3803 if (!member_name_is_valid(v->property.member) ||
3804 !signature_is_single(v->property.signature, false) ||
3805 !(v->property.get || bus_type_is_basic(v->property.signature[0])) ||
3806 v->flags & SD_BUS_VTABLE_METHOD_NO_REPLY ||
3807 (v->flags & SD_BUS_VTABLE_PROPERTY_INVALIDATE_ONLY && !(v->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE))) {
3808 r = -EINVAL;
3809 goto fail;
3810 }
3811
3812
3813 m = new0(struct vtable_member, 1);
3814 if (!m) {
3815 r = -ENOMEM;
3816 goto fail;
3817 }
3818
3819 m->parent = c;
3820 m->path = n->path;
3821 m->interface = c->interface;
3822 m->member = v->property.member;
3823 m->vtable = v;
3824
3825 r = hashmap_put(bus->vtable_properties, m, m);
3826 if (r < 0) {
3827 free(m);
3828 goto fail;
3829 }
3830
3831 break;
3832 }
3833
3834 case _SD_BUS_VTABLE_SIGNAL:
3835
3836 if (!member_name_is_valid(v->signal.member) ||
3837 !signature_is_single(v->signal.signature, false)) {
3838 r = -EINVAL;
3839 goto fail;
3840 }
3841
3842 break;
3843
3844 default:
3845 r = -EINVAL;
3846 goto fail;
3847 }
3848 }
3849
3850 LIST_PREPEND(struct node_vtable, vtables, n->vtables, c);
3851 return 0;
3852
3853 fail:
3854 if (c)
3855 free_node_vtable(bus, c);
3856
3857 bus_node_gc(bus, n);
3858 return r;
3859 }
3860
3861 static int remove_object_vtable_internal(
3862 sd_bus *bus,
3863 const char *path,
3864 const char *interface,
3865 bool fallback) {
3866
3867 struct node_vtable *c;
3868 struct node *n;
3869
3870 if (!bus)
3871 return -EINVAL;
3872 if (!object_path_is_valid(path))
3873 return -EINVAL;
3874 if (!interface_name_is_valid(interface))
3875 return -EINVAL;
3876 if (bus_pid_changed(bus))
3877 return -ECHILD;
3878
3879 n = hashmap_get(bus->nodes, path);
3880 if (!n)
3881 return 0;
3882
3883 LIST_FOREACH(vtables, c, n->vtables)
3884 if (streq(c->interface, interface) && c->is_fallback == fallback)
3885 break;
3886
3887 if (!c)
3888 return 0;
3889
3890 LIST_REMOVE(struct node_vtable, vtables, n->vtables, c);
3891
3892 free_node_vtable(bus, c);
3893 return 1;
3894 }
3895
3896 int sd_bus_add_object_vtable(
3897 sd_bus *bus,
3898 const char *path,
3899 const char *interface,
3900 const sd_bus_vtable *vtable,
3901 void *userdata) {
3902
3903 return add_object_vtable_internal(bus, path, interface, vtable, false, NULL, userdata);
3904 }
3905
3906 int sd_bus_remove_object_vtable(
3907 sd_bus *bus,
3908 const char *path,
3909 const char *interface) {
3910
3911 return remove_object_vtable_internal(bus, path, interface, false);
3912 }
3913
3914 int sd_bus_add_fallback_vtable(
3915 sd_bus *bus,
3916 const char *path,
3917 const char *interface,
3918 const sd_bus_vtable *vtable,
3919 sd_bus_object_find_t find,
3920 void *userdata) {
3921
3922 return add_object_vtable_internal(bus, path, interface, vtable, true, find, userdata);
3923 }
3924
3925 int sd_bus_remove_fallback_vtable(
3926 sd_bus *bus,
3927 const char *path,
3928 const char *interface) {
3929
3930 return remove_object_vtable_internal(bus, path, interface, true);
3931 }
3932
3933 int sd_bus_add_node_enumerator(
3934 sd_bus *bus,
3935 const char *path,
3936 sd_bus_node_enumerator_t callback,
3937 void *userdata) {
3938
3939 struct node_enumerator *c;
3940 struct node *n;
3941 int r;
3942
3943 if (!bus)
3944 return -EINVAL;
3945 if (!object_path_is_valid(path))
3946 return -EINVAL;
3947 if (!callback)
3948 return -EINVAL;
3949 if (bus_pid_changed(bus))
3950 return -ECHILD;
3951
3952 n = bus_node_allocate(bus, path);
3953 if (!n)
3954 return -ENOMEM;
3955
3956 c = new0(struct node_enumerator, 1);
3957 if (!c) {
3958 r = -ENOMEM;
3959 goto fail;
3960 }
3961
3962 c->node = n;
3963 c->callback = callback;
3964 c->userdata = userdata;
3965
3966 LIST_PREPEND(struct node_enumerator, enumerators, n->enumerators, c);
3967 return 0;
3968
3969 fail:
3970 free(c);
3971 bus_node_gc(bus, n);
3972 return r;
3973 }
3974
3975 int sd_bus_remove_node_enumerator(
3976 sd_bus *bus,
3977 const char *path,
3978 sd_bus_node_enumerator_t callback,
3979 void *userdata) {
3980
3981 struct node_enumerator *c;
3982 struct node *n;
3983
3984 if (!bus)
3985 return -EINVAL;
3986 if (!object_path_is_valid(path))
3987 return -EINVAL;
3988 if (!callback)
3989 return -EINVAL;
3990 if (bus_pid_changed(bus))
3991 return -ECHILD;
3992
3993 n = hashmap_get(bus->nodes, path);
3994 if (!n)
3995 return 0;
3996
3997 LIST_FOREACH(enumerators, c, n->enumerators)
3998 if (c->callback == callback && c->userdata == userdata)
3999 break;
4000
4001 if (!c)
4002 return 0;
4003
4004 LIST_REMOVE(struct node_enumerator, enumerators, n->enumerators, c);
4005 free(c);
4006
4007 bus_node_gc(bus, n);
4008
4009 return 1;
4010 }
4011
4012 static int emit_properties_changed_on_interface(
4013 sd_bus *bus,
4014 const char *prefix,
4015 const char *path,
4016 const char *interface,
4017 bool require_fallback,
4018 char **names) {
4019
4020 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
4021 bool has_invalidating = false;
4022 struct vtable_member key;
4023 struct node_vtable *c;
4024 struct node *n;
4025 char **property;
4026 void *u = NULL;
4027 int r;
4028
4029 assert(bus);
4030 assert(path);
4031 assert(interface);
4032
4033 n = hashmap_get(bus->nodes, prefix);
4034 if (!n)
4035 return 0;
4036
4037 LIST_FOREACH(vtables, c, n->vtables) {
4038 if (require_fallback && !c->is_fallback)
4039 continue;
4040
4041 if (streq(c->interface, interface))
4042 break;
4043 }
4044
4045 if (!c)
4046 return 0;
4047
4048 r = node_vtable_get_userdata(bus, path, c, &u);
4049 if (r <= 0)
4050 return r;
4051
4052 r = sd_bus_message_new_signal(bus, path, "org.freedesktop.DBus.Properties", "PropertiesChanged", &m);
4053 if (r < 0)
4054 return r;
4055
4056 r = sd_bus_message_append(m, "s", interface);
4057 if (r < 0)
4058 return r;
4059
4060 r = sd_bus_message_open_container(m, 'a', "{sv}");
4061 if (r < 0)
4062 return r;
4063
4064 key.path = prefix;
4065 key.interface = interface;
4066
4067 STRV_FOREACH(property, names) {
4068 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4069 struct vtable_member *v;
4070
4071 key.member = *property;
4072 v = hashmap_get(bus->vtable_properties, &key);
4073 if (!v)
4074 return -ENOENT;
4075
4076 assert(c == v->parent);
4077
4078 if (!(v->vtable->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE))
4079 return -EDOM;
4080 if (v->vtable->flags & SD_BUS_VTABLE_PROPERTY_INVALIDATE_ONLY) {
4081 has_invalidating = true;
4082 continue;
4083 }
4084
4085 r = sd_bus_message_open_container(m, 'e', "sv");
4086 if (r < 0)
4087 return r;
4088
4089 r = sd_bus_message_append(m, "s", *property);
4090 if (r < 0)
4091 return r;
4092
4093 r = sd_bus_message_open_container(m, 'v', v->vtable->property.signature);
4094 if (r < 0)
4095 return r;
4096
4097 r = invoke_property_get(bus, v->vtable, m->path, interface, *property, m, &error, vtable_property_convert_userdata(v->vtable, u));
4098 if (r < 0)
4099 return r;
4100
4101 if (sd_bus_error_is_set(&error))
4102 return bus_error_to_errno(&error);
4103
4104 r = sd_bus_message_close_container(m);
4105 if (r < 0)
4106 return r;
4107
4108 r = sd_bus_message_close_container(m);
4109 if (r < 0)
4110 return r;
4111 }
4112
4113 r = sd_bus_message_close_container(m);
4114 if (r < 0)
4115 return r;
4116
4117 r = sd_bus_message_open_container(m, 'a', "s");
4118 if (r < 0)
4119 return r;
4120
4121 if (has_invalidating) {
4122 STRV_FOREACH(property, names) {
4123 struct vtable_member *v;
4124
4125 key.member = *property;
4126 assert_se(v = hashmap_get(bus->vtable_properties, &key));
4127 assert(c == v->parent);
4128
4129 if (!(v->vtable->flags & SD_BUS_VTABLE_PROPERTY_INVALIDATE_ONLY))
4130 continue;
4131
4132 r = sd_bus_message_append(m, "s", *property);
4133 if (r < 0)
4134 return r;
4135 }
4136 }
4137
4138 r = sd_bus_message_close_container(m);
4139 if (r < 0)
4140 return r;
4141
4142 r = sd_bus_send(bus, m, NULL);
4143 if (r < 0)
4144 return r;
4145
4146 return 1;
4147 }
4148
4149 int sd_bus_emit_properties_changed_strv(sd_bus *bus, const char *path, const char *interface, char **names) {
4150 size_t pl;
4151 int r;
4152
4153 if (!bus)
4154 return -EINVAL;
4155 if (!object_path_is_valid(path))
4156 return -EINVAL;
4157 if (!interface_name_is_valid(interface))
4158 return -EINVAL;
4159
4160 r = emit_properties_changed_on_interface(bus, path, path, interface, false, names);
4161 if (r != 0)
4162 return r;
4163
4164 pl = strlen(path);
4165 if (pl > 1 ) {
4166 char p[pl+1];
4167
4168 strcpy(p, path);
4169 for (;;) {
4170 char *e;
4171
4172 if (streq(p, "/"))
4173 break;
4174
4175 e = strrchr(p, '/');
4176 assert(e);
4177 if (e == p)
4178 *(e+1) = 0;
4179 else
4180 *e = 0;
4181
4182 r = emit_properties_changed_on_interface(bus, p, path, interface, true, names);
4183 if (r != 0)
4184 return r;
4185 }
4186 }
4187
4188 return -ENOENT;
4189 }
4190
4191 int sd_bus_emit_properties_changed(sd_bus *bus, const char *path, const char *interface, const char *name, ...) {
4192 _cleanup_strv_free_ char **names = NULL;
4193 va_list ap;
4194
4195 va_start(ap, name);
4196 names = strv_new_ap(name, ap);
4197 va_end(ap);
4198
4199 if (!names)
4200 return -ENOMEM;
4201
4202 return sd_bus_emit_properties_changed_strv(bus, path, interface, names);
4203 }
4204
4205 int sd_bus_emit_interfaces_added(sd_bus *bus, const char *path, const char *interfaces, ...) {
4206 return -ENOSYS;
4207 }
4208
4209 int sd_bus_emit_interfaces_removed(sd_bus *bus, const char *path, const char *interfaces, ...) {
4210 return -ENOSYS;
4211 }
4212
4213 int sd_bus_get_property(
4214 sd_bus *bus,
4215 const char *destination,
4216 const char *path,
4217 const char *interface,
4218 const char *member,
4219 sd_bus_error *error,
4220 sd_bus_message **reply,
4221 const char *type) {
4222
4223 sd_bus_message *rep = NULL;
4224 int r;
4225
4226 if (interface && !interface_name_is_valid(interface))
4227 return -EINVAL;
4228 if (!member_name_is_valid(member))
4229 return -EINVAL;
4230 if (!signature_is_single(type, false))
4231 return -EINVAL;
4232 if (!reply)
4233 return -EINVAL;
4234
4235 r = sd_bus_call_method(bus, destination, path, "org.freedesktop.DBus.Properties", "Get", error, &rep, "ss", strempty(interface), member);
4236 if (r < 0)
4237 return r;
4238
4239 r = sd_bus_message_enter_container(rep, 'v', type);
4240 if (r < 0) {
4241 sd_bus_message_unref(rep);
4242 return r;
4243 }
4244
4245 *reply = rep;
4246 return 0;
4247 }
4248
4249 int sd_bus_set_property(
4250 sd_bus *bus,
4251 const char *destination,
4252 const char *path,
4253 const char *interface,
4254 const char *member,
4255 sd_bus_error *error,
4256 const char *type, ...) {
4257
4258 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
4259 va_list ap;
4260 int r;
4261
4262 if (interface && !interface_name_is_valid(interface))
4263 return -EINVAL;
4264 if (!member_name_is_valid(member))
4265 return -EINVAL;
4266 if (!signature_is_single(type, false))
4267 return -EINVAL;
4268
4269 r = sd_bus_message_new_method_call(bus, destination, path, "org.freedesktop.DBus.Properties", "Set", &m);
4270 if (r < 0)
4271 return r;
4272
4273 r = sd_bus_message_append(m, "ss", strempty(interface), member);
4274 if (r < 0)
4275 return r;
4276
4277 r = sd_bus_message_open_container(m, 'v', type);
4278 if (r < 0)
4279 return r;
4280
4281 va_start(ap, type);
4282 r = bus_message_append_ap(m, type, ap);
4283 va_end(ap);
4284 if (r < 0)
4285 return r;
4286
4287 r = sd_bus_message_close_container(m);
4288 if (r < 0)
4289 return r;
4290
4291 return sd_bus_send_with_reply_and_block(bus, m, 0, error, NULL);
4292 }
4293
4294 int sd_bus_add_object_manager(sd_bus *bus, const char *path) {
4295 struct node *n;
4296
4297 if (!bus)
4298 return -EINVAL;
4299 if (!object_path_is_valid(path))
4300 return -EINVAL;
4301 if (bus_pid_changed(bus))
4302 return -ECHILD;
4303
4304 n = bus_node_allocate(bus, path);
4305 if (!n)
4306 return -ENOMEM;
4307
4308 n->object_manager = true;
4309 return 0;
4310 }
4311
4312 int sd_bus_remove_object_manager(sd_bus *bus, const char *path) {
4313 struct node *n;
4314
4315 if (!bus)
4316 return -EINVAL;
4317 if (!object_path_is_valid(path))
4318 return -EINVAL;
4319 if (bus_pid_changed(bus))
4320 return -ECHILD;
4321
4322 n = hashmap_get(bus->nodes, path);
4323 if (!n)
4324 return 0;
4325
4326 if (!n->object_manager)
4327 return 0;
4328
4329 n->object_manager = false;
4330 bus_node_gc(bus, n);
4331 return 1;
4332 }
Unnamed repository; edit this file 'description' to name the repository.