]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd/sd-bus/bus-objects.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
test: add smoke tests for `--network-namespace-path`
[thirdparty/systemd.git] / src / libsystemd / sd-bus / bus-objects.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2 /***
3 This file is part of systemd.
4
5 Copyright 2013 Lennart Poettering
6
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
11
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
16
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
19 ***/
20
21 #include "alloc-util.h"
22 #include "bus-internal.h"
23 #include "bus-introspect.h"
24 #include "bus-message.h"
25 #include "bus-objects.h"
26 #include "bus-signature.h"
27 #include "bus-slot.h"
28 #include "bus-type.h"
29 #include "bus-util.h"
30 #include "set.h"
31 #include "string-util.h"
32 #include "strv.h"
33
34 static int node_vtable_get_userdata(
35 sd_bus *bus,
36 const char *path,
37 struct node_vtable *c,
38 void **userdata,
39 sd_bus_error *error) {
40
41 sd_bus_slot *s;
42 void *u, *found_u;
43 int r;
44
45 assert(bus);
46 assert(path);
47 assert(c);
48
49 s = container_of(c, sd_bus_slot, node_vtable);
50 u = s->userdata;
51 if (c->find) {
52 bus->current_slot = sd_bus_slot_ref(s);
53 bus->current_userdata = u;
54 r = c->find(bus, path, c->interface, u, &found_u, error);
55 bus->current_userdata = NULL;
56 bus->current_slot = sd_bus_slot_unref(s);
57
58 if (r < 0)
59 return r;
60 if (sd_bus_error_is_set(error))
61 return -sd_bus_error_get_errno(error);
62 if (r == 0)
63 return r;
64 } else
65 found_u = u;
66
67 if (userdata)
68 *userdata = found_u;
69
70 return 1;
71 }
72
73 static void *vtable_method_convert_userdata(const sd_bus_vtable *p, void *u) {
74 assert(p);
75
76 return (uint8_t*) u + p->x.method.offset;
77 }
78
79 static void *vtable_property_convert_userdata(const sd_bus_vtable *p, void *u) {
80 assert(p);
81
82 return (uint8_t*) u + p->x.property.offset;
83 }
84
85 static int vtable_property_get_userdata(
86 sd_bus *bus,
87 const char *path,
88 struct vtable_member *p,
89 void **userdata,
90 sd_bus_error *error) {
91
92 void *u;
93 int r;
94
95 assert(bus);
96 assert(path);
97 assert(p);
98 assert(userdata);
99
100 r = node_vtable_get_userdata(bus, path, p->parent, &u, error);
101 if (r <= 0)
102 return r;
103 if (bus->nodes_modified)
104 return 0;
105
106 *userdata = vtable_property_convert_userdata(p->vtable, u);
107 return 1;
108 }
109
110 static int add_enumerated_to_set(
111 sd_bus *bus,
112 const char *prefix,
113 struct node_enumerator *first,
114 Set *s,
115 sd_bus_error *error) {
116
117 struct node_enumerator *c;
118 int r;
119
120 assert(bus);
121 assert(prefix);
122 assert(s);
123
124 LIST_FOREACH(enumerators, c, first) {
125 char **children = NULL, **k;
126 sd_bus_slot *slot;
127
128 if (bus->nodes_modified)
129 return 0;
130
131 slot = container_of(c, sd_bus_slot, node_enumerator);
132
133 bus->current_slot = sd_bus_slot_ref(slot);
134 bus->current_userdata = slot->userdata;
135 r = c->callback(bus, prefix, slot->userdata, &children, error);
136 bus->current_userdata = NULL;
137 bus->current_slot = sd_bus_slot_unref(slot);
138
139 if (r < 0)
140 return r;
141 if (sd_bus_error_is_set(error))
142 return -sd_bus_error_get_errno(error);
143
144 STRV_FOREACH(k, children) {
145 if (r < 0) {
146 free(*k);
147 continue;
148 }
149
150 if (!object_path_is_valid(*k)) {
151 free(*k);
152 r = -EINVAL;
153 continue;
154 }
155
156 if (!object_path_startswith(*k, prefix)) {
157 free(*k);
158 continue;
159 }
160
161 r = set_consume(s, *k);
162 if (r == -EEXIST)
163 r = 0;
164 }
165
166 free(children);
167 if (r < 0)
168 return r;
169 }
170
171 return 0;
172 }
173
174 enum {
175 /* if set, add_subtree() works recursively */
176 CHILDREN_RECURSIVE = (1U << 1),
177 /* if set, add_subtree() scans object-manager hierarchies recursively */
178 CHILDREN_SUBHIERARCHIES = (1U << 0),
179 };
180
181 static int add_subtree_to_set(
182 sd_bus *bus,
183 const char *prefix,
184 struct node *n,
185 unsigned int flags,
186 Set *s,
187 sd_bus_error *error) {
188
189 struct node *i;
190 int r;
191
192 assert(bus);
193 assert(prefix);
194 assert(n);
195 assert(s);
196
197 r = add_enumerated_to_set(bus, prefix, n->enumerators, s, error);
198 if (r < 0)
199 return r;
200 if (bus->nodes_modified)
201 return 0;
202
203 LIST_FOREACH(siblings, i, n->child) {
204 char *t;
205
206 if (!object_path_startswith(i->path, prefix))
207 continue;
208
209 t = strdup(i->path);
210 if (!t)
211 return -ENOMEM;
212
213 r = set_consume(s, t);
214 if (r < 0 && r != -EEXIST)
215 return r;
216
217 if ((flags & CHILDREN_RECURSIVE) &&
218 ((flags & CHILDREN_SUBHIERARCHIES) || !i->object_managers)) {
219 r = add_subtree_to_set(bus, prefix, i, flags, s, error);
220 if (r < 0)
221 return r;
222 if (bus->nodes_modified)
223 return 0;
224 }
225 }
226
227 return 0;
228 }
229
230 static int get_child_nodes(
231 sd_bus *bus,
232 const char *prefix,
233 struct node *n,
234 unsigned int flags,
235 Set **_s,
236 sd_bus_error *error) {
237
238 Set *s = NULL;
239 int r;
240
241 assert(bus);
242 assert(prefix);
243 assert(n);
244 assert(_s);
245
246 s = set_new(&string_hash_ops);
247 if (!s)
248 return -ENOMEM;
249
250 r = add_subtree_to_set(bus, prefix, n, flags, s, error);
251 if (r < 0) {
252 set_free_free(s);
253 return r;
254 }
255
256 *_s = s;
257 return 0;
258 }
259
260 static int node_callbacks_run(
261 sd_bus *bus,
262 sd_bus_message *m,
263 struct node_callback *first,
264 bool require_fallback,
265 bool *found_object) {
266
267 struct node_callback *c;
268 int r;
269
270 assert(bus);
271 assert(m);
272 assert(found_object);
273
274 LIST_FOREACH(callbacks, c, first) {
275 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
276 sd_bus_slot *slot;
277
278 if (bus->nodes_modified)
279 return 0;
280
281 if (require_fallback && !c->is_fallback)
282 continue;
283
284 *found_object = true;
285
286 if (c->last_iteration == bus->iteration_counter)
287 continue;
288
289 c->last_iteration = bus->iteration_counter;
290
291 r = sd_bus_message_rewind(m, true);
292 if (r < 0)
293 return r;
294
295 slot = container_of(c, sd_bus_slot, node_callback);
296
297 bus->current_slot = sd_bus_slot_ref(slot);
298 bus->current_handler = c->callback;
299 bus->current_userdata = slot->userdata;
300 r = c->callback(m, slot->userdata, &error_buffer);
301 bus->current_userdata = NULL;
302 bus->current_handler = NULL;
303 bus->current_slot = sd_bus_slot_unref(slot);
304
305 r = bus_maybe_reply_error(m, r, &error_buffer);
306 if (r != 0)
307 return r;
308 }
309
310 return 0;
311 }
312
313 #define CAPABILITY_SHIFT(x) (((x) >> __builtin_ctzll(_SD_BUS_VTABLE_CAPABILITY_MASK)) & 0xFFFF)
314
315 static int check_access(sd_bus *bus, sd_bus_message *m, struct vtable_member *c, sd_bus_error *error) {
316 uint64_t cap;
317 int r;
318
319 assert(bus);
320 assert(m);
321 assert(c);
322
323 /* If the entire bus is trusted let's grant access */
324 if (bus->trusted)
325 return 0;
326
327 /* If the member is marked UNPRIVILEGED let's grant access */
328 if (c->vtable->flags & SD_BUS_VTABLE_UNPRIVILEGED)
329 return 0;
330
331 /* Check have the caller has the requested capability
332 * set. Note that the flags value contains the capability
333 * number plus one, which we need to subtract here. We do this
334 * so that we have 0 as special value for "default
335 * capability". */
336 cap = CAPABILITY_SHIFT(c->vtable->flags);
337 if (cap == 0)
338 cap = CAPABILITY_SHIFT(c->parent->vtable[0].flags);
339 if (cap == 0)
340 cap = CAP_SYS_ADMIN;
341 else
342 cap--;
343
344 r = sd_bus_query_sender_privilege(m, cap);
345 if (r < 0)
346 return r;
347 if (r > 0)
348 return 0;
349
350 return sd_bus_error_setf(error, SD_BUS_ERROR_ACCESS_DENIED, "Access to %s.%s() not permitted.", c->interface, c->member);
351 }
352
353 static int method_callbacks_run(
354 sd_bus *bus,
355 sd_bus_message *m,
356 struct vtable_member *c,
357 bool require_fallback,
358 bool *found_object) {
359
360 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
361 const char *signature;
362 void *u;
363 int r;
364
365 assert(bus);
366 assert(m);
367 assert(c);
368 assert(found_object);
369
370 if (require_fallback && !c->parent->is_fallback)
371 return 0;
372
373 r = check_access(bus, m, c, &error);
374 if (r < 0)
375 return bus_maybe_reply_error(m, r, &error);
376
377 r = node_vtable_get_userdata(bus, m->path, c->parent, &u, &error);
378 if (r <= 0)
379 return bus_maybe_reply_error(m, r, &error);
380 if (bus->nodes_modified)
381 return 0;
382
383 u = vtable_method_convert_userdata(c->vtable, u);
384
385 *found_object = true;
386
387 if (c->last_iteration == bus->iteration_counter)
388 return 0;
389
390 c->last_iteration = bus->iteration_counter;
391
392 r = sd_bus_message_rewind(m, true);
393 if (r < 0)
394 return r;
395
396 signature = sd_bus_message_get_signature(m, true);
397 if (!signature)
398 return -EINVAL;
399
400 if (!streq(strempty(c->vtable->x.method.signature), signature))
401 return sd_bus_reply_method_errorf(
402 m,
403 SD_BUS_ERROR_INVALID_ARGS,
404 "Invalid arguments '%s' to call %s.%s(), expecting '%s'.",
405 signature, c->interface, c->member, strempty(c->vtable->x.method.signature));
406
407 /* Keep track what the signature of the reply to this message
408 * should be, so that this can be enforced when sealing the
409 * reply. */
410 m->enforced_reply_signature = strempty(c->vtable->x.method.result);
411
412 if (c->vtable->x.method.handler) {
413 sd_bus_slot *slot;
414
415 slot = container_of(c->parent, sd_bus_slot, node_vtable);
416
417 bus->current_slot = sd_bus_slot_ref(slot);
418 bus->current_handler = c->vtable->x.method.handler;
419 bus->current_userdata = u;
420 r = c->vtable->x.method.handler(m, u, &error);
421 bus->current_userdata = NULL;
422 bus->current_handler = NULL;
423 bus->current_slot = sd_bus_slot_unref(slot);
424
425 return bus_maybe_reply_error(m, r, &error);
426 }
427
428 /* If the method callback is NULL, make this a successful NOP */
429 r = sd_bus_reply_method_return(m, NULL);
430 if (r < 0)
431 return r;
432
433 return 1;
434 }
435
436 static int invoke_property_get(
437 sd_bus *bus,
438 sd_bus_slot *slot,
439 const sd_bus_vtable *v,
440 const char *path,
441 const char *interface,
442 const char *property,
443 sd_bus_message *reply,
444 void *userdata,
445 sd_bus_error *error) {
446
447 const void *p;
448 int r;
449
450 assert(bus);
451 assert(slot);
452 assert(v);
453 assert(path);
454 assert(interface);
455 assert(property);
456 assert(reply);
457
458 if (v->x.property.get) {
459
460 bus->current_slot = sd_bus_slot_ref(slot);
461 bus->current_userdata = userdata;
462 r = v->x.property.get(bus, path, interface, property, reply, userdata, error);
463 bus->current_userdata = NULL;
464 bus->current_slot = sd_bus_slot_unref(slot);
465
466 if (r < 0)
467 return r;
468 if (sd_bus_error_is_set(error))
469 return -sd_bus_error_get_errno(error);
470 return r;
471 }
472
473 /* Automatic handling if no callback is defined. */
474
475 if (streq(v->x.property.signature, "as"))
476 return sd_bus_message_append_strv(reply, *(char***) userdata);
477
478 assert(signature_is_single(v->x.property.signature, false));
479 assert(bus_type_is_basic(v->x.property.signature[0]));
480
481 switch (v->x.property.signature[0]) {
482
483 case SD_BUS_TYPE_STRING:
484 case SD_BUS_TYPE_SIGNATURE:
485 p = strempty(*(char**) userdata);
486 break;
487
488 case SD_BUS_TYPE_OBJECT_PATH:
489 p = *(char**) userdata;
490 assert(p);
491 break;
492
493 default:
494 p = userdata;
495 break;
496 }
497
498 return sd_bus_message_append_basic(reply, v->x.property.signature[0], p);
499 }
500
501 static int invoke_property_set(
502 sd_bus *bus,
503 sd_bus_slot *slot,
504 const sd_bus_vtable *v,
505 const char *path,
506 const char *interface,
507 const char *property,
508 sd_bus_message *value,
509 void *userdata,
510 sd_bus_error *error) {
511
512 int r;
513
514 assert(bus);
515 assert(slot);
516 assert(v);
517 assert(path);
518 assert(interface);
519 assert(property);
520 assert(value);
521
522 if (v->x.property.set) {
523
524 bus->current_slot = sd_bus_slot_ref(slot);
525 bus->current_userdata = userdata;
526 r = v->x.property.set(bus, path, interface, property, value, userdata, error);
527 bus->current_userdata = NULL;
528 bus->current_slot = sd_bus_slot_unref(slot);
529
530 if (r < 0)
531 return r;
532 if (sd_bus_error_is_set(error))
533 return -sd_bus_error_get_errno(error);
534 return r;
535 }
536
537 /* Automatic handling if no callback is defined. */
538
539 assert(signature_is_single(v->x.property.signature, false));
540 assert(bus_type_is_basic(v->x.property.signature[0]));
541
542 switch (v->x.property.signature[0]) {
543
544 case SD_BUS_TYPE_STRING:
545 case SD_BUS_TYPE_OBJECT_PATH:
546 case SD_BUS_TYPE_SIGNATURE: {
547 const char *p;
548 char *n;
549
550 r = sd_bus_message_read_basic(value, v->x.property.signature[0], &p);
551 if (r < 0)
552 return r;
553
554 n = strdup(p);
555 if (!n)
556 return -ENOMEM;
557
558 free(*(char**) userdata);
559 *(char**) userdata = n;
560
561 break;
562 }
563
564 default:
565 r = sd_bus_message_read_basic(value, v->x.property.signature[0], userdata);
566 if (r < 0)
567 return r;
568
569 break;
570 }
571
572 return 1;
573 }
574
575 static int property_get_set_callbacks_run(
576 sd_bus *bus,
577 sd_bus_message *m,
578 struct vtable_member *c,
579 bool require_fallback,
580 bool is_get,
581 bool *found_object) {
582
583 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
584 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
585 sd_bus_slot *slot;
586 void *u = NULL;
587 int r;
588
589 assert(bus);
590 assert(m);
591 assert(c);
592 assert(found_object);
593
594 if (require_fallback && !c->parent->is_fallback)
595 return 0;
596
597 r = vtable_property_get_userdata(bus, m->path, c, &u, &error);
598 if (r <= 0)
599 return bus_maybe_reply_error(m, r, &error);
600 if (bus->nodes_modified)
601 return 0;
602
603 slot = container_of(c->parent, sd_bus_slot, node_vtable);
604
605 *found_object = true;
606
607 r = sd_bus_message_new_method_return(m, &reply);
608 if (r < 0)
609 return r;
610
611 if (is_get) {
612 /* Note that we do not protect against reexecution
613 * here (using the last_iteration check, see below),
614 * should the node tree have changed and we got called
615 * again. We assume that property Get() calls are
616 * ultimately without side-effects or if they aren't
617 * then at least idempotent. */
618
619 r = sd_bus_message_open_container(reply, 'v', c->vtable->x.property.signature);
620 if (r < 0)
621 return r;
622
623 /* Note that we do not do an access check here. Read
624 * access to properties is always unrestricted, since
625 * PropertiesChanged signals broadcast contents
626 * anyway. */
627
628 r = invoke_property_get(bus, slot, c->vtable, m->path, c->interface, c->member, reply, u, &error);
629 if (r < 0)
630 return bus_maybe_reply_error(m, r, &error);
631
632 if (bus->nodes_modified)
633 return 0;
634
635 r = sd_bus_message_close_container(reply);
636 if (r < 0)
637 return r;
638
639 } else {
640 const char *signature = NULL;
641 char type = 0;
642
643 if (c->vtable->type != _SD_BUS_VTABLE_WRITABLE_PROPERTY)
644 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_PROPERTY_READ_ONLY, "Property '%s' is not writable.", c->member);
645
646 /* Avoid that we call the set routine more than once
647 * if the processing of this message got restarted
648 * because the node tree changed. */
649 if (c->last_iteration == bus->iteration_counter)
650 return 0;
651
652 c->last_iteration = bus->iteration_counter;
653
654 r = sd_bus_message_peek_type(m, &type, &signature);
655 if (r < 0)
656 return r;
657
658 if (type != 'v' || !streq(strempty(signature), strempty(c->vtable->x.property.signature)))
659 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INVALID_ARGS, "Incorrect parameters for property '%s', expected '%s', got '%s'.", c->member, strempty(c->vtable->x.property.signature), strempty(signature));
660
661 r = sd_bus_message_enter_container(m, 'v', c->vtable->x.property.signature);
662 if (r < 0)
663 return r;
664
665 r = check_access(bus, m, c, &error);
666 if (r < 0)
667 return bus_maybe_reply_error(m, r, &error);
668
669 r = invoke_property_set(bus, slot, c->vtable, m->path, c->interface, c->member, m, u, &error);
670 if (r < 0)
671 return bus_maybe_reply_error(m, r, &error);
672
673 if (bus->nodes_modified)
674 return 0;
675
676 r = sd_bus_message_exit_container(m);
677 if (r < 0)
678 return r;
679 }
680
681 r = sd_bus_send(bus, reply, NULL);
682 if (r < 0)
683 return r;
684
685 return 1;
686 }
687
688 static int vtable_append_one_property(
689 sd_bus *bus,
690 sd_bus_message *reply,
691 const char *path,
692 struct node_vtable *c,
693 const sd_bus_vtable *v,
694 void *userdata,
695 sd_bus_error *error) {
696
697 sd_bus_slot *slot;
698 int r;
699
700 assert(bus);
701 assert(reply);
702 assert(path);
703 assert(c);
704 assert(v);
705
706 r = sd_bus_message_open_container(reply, 'e', "sv");
707 if (r < 0)
708 return r;
709
710 r = sd_bus_message_append(reply, "s", v->x.property.member);
711 if (r < 0)
712 return r;
713
714 r = sd_bus_message_open_container(reply, 'v', v->x.property.signature);
715 if (r < 0)
716 return r;
717
718 slot = container_of(c, sd_bus_slot, node_vtable);
719
720 r = invoke_property_get(bus, slot, v, path, c->interface, v->x.property.member, reply, vtable_property_convert_userdata(v, userdata), error);
721 if (r < 0)
722 return r;
723 if (bus->nodes_modified)
724 return 0;
725
726 r = sd_bus_message_close_container(reply);
727 if (r < 0)
728 return r;
729
730 r = sd_bus_message_close_container(reply);
731 if (r < 0)
732 return r;
733
734 return 0;
735 }
736
737 static int vtable_append_all_properties(
738 sd_bus *bus,
739 sd_bus_message *reply,
740 const char *path,
741 struct node_vtable *c,
742 void *userdata,
743 sd_bus_error *error) {
744
745 const sd_bus_vtable *v;
746 int r;
747
748 assert(bus);
749 assert(reply);
750 assert(path);
751 assert(c);
752
753 if (c->vtable[0].flags & SD_BUS_VTABLE_HIDDEN)
754 return 1;
755
756 for (v = c->vtable+1; v->type != _SD_BUS_VTABLE_END; v++) {
757 if (!IN_SET(v->type, _SD_BUS_VTABLE_PROPERTY, _SD_BUS_VTABLE_WRITABLE_PROPERTY))
758 continue;
759
760 if (v->flags & SD_BUS_VTABLE_HIDDEN)
761 continue;
762
763 if (v->flags & SD_BUS_VTABLE_PROPERTY_EXPLICIT)
764 continue;
765
766 r = vtable_append_one_property(bus, reply, path, c, v, userdata, error);
767 if (r < 0)
768 return r;
769 if (bus->nodes_modified)
770 return 0;
771 }
772
773 return 1;
774 }
775
776 static int property_get_all_callbacks_run(
777 sd_bus *bus,
778 sd_bus_message *m,
779 struct node_vtable *first,
780 bool require_fallback,
781 const char *iface,
782 bool *found_object) {
783
784 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
785 struct node_vtable *c;
786 bool found_interface;
787 int r;
788
789 assert(bus);
790 assert(m);
791 assert(found_object);
792
793 r = sd_bus_message_new_method_return(m, &reply);
794 if (r < 0)
795 return r;
796
797 r = sd_bus_message_open_container(reply, 'a', "{sv}");
798 if (r < 0)
799 return r;
800
801 found_interface = !iface ||
802 streq(iface, "org.freedesktop.DBus.Properties") ||
803 streq(iface, "org.freedesktop.DBus.Peer") ||
804 streq(iface, "org.freedesktop.DBus.Introspectable");
805
806 LIST_FOREACH(vtables, c, first) {
807 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
808 void *u;
809
810 if (require_fallback && !c->is_fallback)
811 continue;
812
813 r = node_vtable_get_userdata(bus, m->path, c, &u, &error);
814 if (r < 0)
815 return bus_maybe_reply_error(m, r, &error);
816 if (bus->nodes_modified)
817 return 0;
818 if (r == 0)
819 continue;
820
821 *found_object = true;
822
823 if (iface && !streq(c->interface, iface))
824 continue;
825 found_interface = true;
826
827 r = vtable_append_all_properties(bus, reply, m->path, c, u, &error);
828 if (r < 0)
829 return bus_maybe_reply_error(m, r, &error);
830 if (bus->nodes_modified)
831 return 0;
832 }
833
834 if (!*found_object)
835 return 0;
836
837 if (!found_interface) {
838 r = sd_bus_reply_method_errorf(
839 m,
840 SD_BUS_ERROR_UNKNOWN_INTERFACE,
841 "Unknown interface '%s'.", iface);
842 if (r < 0)
843 return r;
844
845 return 1;
846 }
847
848 r = sd_bus_message_close_container(reply);
849 if (r < 0)
850 return r;
851
852 r = sd_bus_send(bus, reply, NULL);
853 if (r < 0)
854 return r;
855
856 return 1;
857 }
858
859 static int bus_node_exists(
860 sd_bus *bus,
861 struct node *n,
862 const char *path,
863 bool require_fallback) {
864
865 struct node_vtable *c;
866 struct node_callback *k;
867 int r;
868
869 assert(bus);
870 assert(n);
871 assert(path);
872
873 /* Tests if there's anything attached directly to this node
874 * for the specified path */
875
876 if (!require_fallback && (n->enumerators || n->object_managers))
877 return true;
878
879 LIST_FOREACH(callbacks, k, n->callbacks) {
880 if (require_fallback && !k->is_fallback)
881 continue;
882
883 return 1;
884 }
885
886 LIST_FOREACH(vtables, c, n->vtables) {
887 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
888
889 if (require_fallback && !c->is_fallback)
890 continue;
891
892 r = node_vtable_get_userdata(bus, path, c, NULL, &error);
893 if (r != 0)
894 return r;
895 if (bus->nodes_modified)
896 return 0;
897 }
898
899 return 0;
900 }
901
902 static int process_introspect(
903 sd_bus *bus,
904 sd_bus_message *m,
905 struct node *n,
906 bool require_fallback,
907 bool *found_object) {
908
909 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
910 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
911 _cleanup_set_free_free_ Set *s = NULL;
912 const char *previous_interface = NULL;
913 struct introspect intro;
914 struct node_vtable *c;
915 bool empty;
916 int r;
917
918 assert(bus);
919 assert(m);
920 assert(n);
921 assert(found_object);
922
923 r = get_child_nodes(bus, m->path, n, 0, &s, &error);
924 if (r < 0)
925 return bus_maybe_reply_error(m, r, &error);
926 if (bus->nodes_modified)
927 return 0;
928
929 r = introspect_begin(&intro, bus->trusted);
930 if (r < 0)
931 return r;
932
933 r = introspect_write_default_interfaces(&intro, !require_fallback && n->object_managers);
934 if (r < 0)
935 return r;
936
937 empty = set_isempty(s);
938
939 LIST_FOREACH(vtables, c, n->vtables) {
940 if (require_fallback && !c->is_fallback)
941 continue;
942
943 r = node_vtable_get_userdata(bus, m->path, c, NULL, &error);
944 if (r < 0) {
945 r = bus_maybe_reply_error(m, r, &error);
946 goto finish;
947 }
948 if (bus->nodes_modified) {
949 r = 0;
950 goto finish;
951 }
952 if (r == 0)
953 continue;
954
955 empty = false;
956
957 if (c->vtable[0].flags & SD_BUS_VTABLE_HIDDEN)
958 continue;
959
960 if (!streq_ptr(previous_interface, c->interface)) {
961
962 if (previous_interface)
963 fputs_unlocked(" </interface>\n", intro.f);
964
965 fprintf(intro.f, " <interface name=\"%s\">\n", c->interface);
966 }
967
968 r = introspect_write_interface(&intro, c->vtable);
969 if (r < 0)
970 goto finish;
971
972 previous_interface = c->interface;
973 }
974
975 if (previous_interface)
976 fputs_unlocked(" </interface>\n", intro.f);
977
978 if (empty) {
979 /* Nothing?, let's see if we exist at all, and if not
980 * refuse to do anything */
981 r = bus_node_exists(bus, n, m->path, require_fallback);
982 if (r <= 0) {
983 r = bus_maybe_reply_error(m, r, &error);
984 goto finish;
985 }
986 if (bus->nodes_modified) {
987 r = 0;
988 goto finish;
989 }
990 }
991
992 *found_object = true;
993
994 r = introspect_write_child_nodes(&intro, s, m->path);
995 if (r < 0)
996 goto finish;
997
998 r = introspect_finish(&intro, bus, m, &reply);
999 if (r < 0)
1000 goto finish;
1001
1002 r = sd_bus_send(bus, reply, NULL);
1003 if (r < 0)
1004 goto finish;
1005
1006 r = 1;
1007
1008 finish:
1009 introspect_free(&intro);
1010 return r;
1011 }
1012
1013 static int object_manager_serialize_path(
1014 sd_bus *bus,
1015 sd_bus_message *reply,
1016 const char *prefix,
1017 const char *path,
1018 bool require_fallback,
1019 sd_bus_error *error) {
1020
1021 const char *previous_interface = NULL;
1022 bool found_something = false;
1023 struct node_vtable *i;
1024 struct node *n;
1025 int r;
1026
1027 assert(bus);
1028 assert(reply);
1029 assert(prefix);
1030 assert(path);
1031 assert(error);
1032
1033 n = hashmap_get(bus->nodes, prefix);
1034 if (!n)
1035 return 0;
1036
1037 LIST_FOREACH(vtables, i, n->vtables) {
1038 void *u;
1039
1040 if (require_fallback && !i->is_fallback)
1041 continue;
1042
1043 r = node_vtable_get_userdata(bus, path, i, &u, error);
1044 if (r < 0)
1045 return r;
1046 if (bus->nodes_modified)
1047 return 0;
1048 if (r == 0)
1049 continue;
1050
1051 if (!found_something) {
1052
1053 /* Open the object part */
1054
1055 r = sd_bus_message_open_container(reply, 'e', "oa{sa{sv}}");
1056 if (r < 0)
1057 return r;
1058
1059 r = sd_bus_message_append(reply, "o", path);
1060 if (r < 0)
1061 return r;
1062
1063 r = sd_bus_message_open_container(reply, 'a', "{sa{sv}}");
1064 if (r < 0)
1065 return r;
1066
1067 r = sd_bus_message_append(reply, "{sa{sv}}", "org.freedesktop.DBus.Peer", 0);
1068 if (r < 0)
1069 return r;
1070
1071 r = sd_bus_message_append(reply, "{sa{sv}}", "org.freedesktop.DBus.Introspectable", 0);
1072 if (r < 0)
1073 return r;
1074
1075 r = sd_bus_message_append(reply, "{sa{sv}}", "org.freedesktop.DBus.Properties", 0);
1076 if (r < 0)
1077 return r;
1078
1079 r = sd_bus_message_append(reply, "{sa{sv}}", "org.freedesktop.DBus.ObjectManager", 0);
1080 if (r < 0)
1081 return r;
1082
1083 found_something = true;
1084 }
1085
1086 if (!streq_ptr(previous_interface, i->interface)) {
1087
1088 /* Maybe close the previous interface part */
1089
1090 if (previous_interface) {
1091 r = sd_bus_message_close_container(reply);
1092 if (r < 0)
1093 return r;
1094
1095 r = sd_bus_message_close_container(reply);
1096 if (r < 0)
1097 return r;
1098 }
1099
1100 /* Open the new interface part */
1101
1102 r = sd_bus_message_open_container(reply, 'e', "sa{sv}");
1103 if (r < 0)
1104 return r;
1105
1106 r = sd_bus_message_append(reply, "s", i->interface);
1107 if (r < 0)
1108 return r;
1109
1110 r = sd_bus_message_open_container(reply, 'a', "{sv}");
1111 if (r < 0)
1112 return r;
1113 }
1114
1115 r = vtable_append_all_properties(bus, reply, path, i, u, error);
1116 if (r < 0)
1117 return r;
1118 if (bus->nodes_modified)
1119 return 0;
1120
1121 previous_interface = i->interface;
1122 }
1123
1124 if (previous_interface) {
1125 r = sd_bus_message_close_container(reply);
1126 if (r < 0)
1127 return r;
1128
1129 r = sd_bus_message_close_container(reply);
1130 if (r < 0)
1131 return r;
1132 }
1133
1134 if (found_something) {
1135 r = sd_bus_message_close_container(reply);
1136 if (r < 0)
1137 return r;
1138
1139 r = sd_bus_message_close_container(reply);
1140 if (r < 0)
1141 return r;
1142 }
1143
1144 return 1;
1145 }
1146
1147 static int object_manager_serialize_path_and_fallbacks(
1148 sd_bus *bus,
1149 sd_bus_message *reply,
1150 const char *path,
1151 sd_bus_error *error) {
1152
1153 char *prefix;
1154 int r;
1155
1156 assert(bus);
1157 assert(reply);
1158 assert(path);
1159 assert(error);
1160
1161 /* First, add all vtables registered for this path */
1162 r = object_manager_serialize_path(bus, reply, path, path, false, error);
1163 if (r < 0)
1164 return r;
1165 if (bus->nodes_modified)
1166 return 0;
1167
1168 /* Second, add fallback vtables registered for any of the prefixes */
1169 prefix = alloca(strlen(path) + 1);
1170 OBJECT_PATH_FOREACH_PREFIX(prefix, path) {
1171 r = object_manager_serialize_path(bus, reply, prefix, path, true, error);
1172 if (r < 0)
1173 return r;
1174 if (bus->nodes_modified)
1175 return 0;
1176 }
1177
1178 return 0;
1179 }
1180
1181 static int process_get_managed_objects(
1182 sd_bus *bus,
1183 sd_bus_message *m,
1184 struct node *n,
1185 bool require_fallback,
1186 bool *found_object) {
1187
1188 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1189 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1190 _cleanup_set_free_free_ Set *s = NULL;
1191 Iterator i;
1192 char *path;
1193 int r;
1194
1195 assert(bus);
1196 assert(m);
1197 assert(n);
1198 assert(found_object);
1199
1200 /* Spec says, GetManagedObjects() is only implemented on the root of a
1201 * sub-tree. Therefore, we require a registered object-manager on
1202 * exactly the queried path, otherwise, we refuse to respond. */
1203
1204 if (require_fallback || !n->object_managers)
1205 return 0;
1206
1207 r = get_child_nodes(bus, m->path, n, CHILDREN_RECURSIVE, &s, &error);
1208 if (r < 0)
1209 return bus_maybe_reply_error(m, r, &error);
1210 if (bus->nodes_modified)
1211 return 0;
1212
1213 r = sd_bus_message_new_method_return(m, &reply);
1214 if (r < 0)
1215 return r;
1216
1217 r = sd_bus_message_open_container(reply, 'a', "{oa{sa{sv}}}");
1218 if (r < 0)
1219 return r;
1220
1221 SET_FOREACH(path, s, i) {
1222 r = object_manager_serialize_path_and_fallbacks(bus, reply, path, &error);
1223 if (r < 0)
1224 return bus_maybe_reply_error(m, r, &error);
1225
1226 if (bus->nodes_modified)
1227 return 0;
1228 }
1229
1230 r = sd_bus_message_close_container(reply);
1231 if (r < 0)
1232 return r;
1233
1234 r = sd_bus_send(bus, reply, NULL);
1235 if (r < 0)
1236 return r;
1237
1238 return 1;
1239 }
1240
1241 static int object_find_and_run(
1242 sd_bus *bus,
1243 sd_bus_message *m,
1244 const char *p,
1245 bool require_fallback,
1246 bool *found_object) {
1247
1248 struct node *n;
1249 struct vtable_member vtable_key, *v;
1250 int r;
1251
1252 assert(bus);
1253 assert(m);
1254 assert(p);
1255 assert(found_object);
1256
1257 n = hashmap_get(bus->nodes, p);
1258 if (!n)
1259 return 0;
1260
1261 /* First, try object callbacks */
1262 r = node_callbacks_run(bus, m, n->callbacks, require_fallback, found_object);
1263 if (r != 0)
1264 return r;
1265 if (bus->nodes_modified)
1266 return 0;
1267
1268 if (!m->interface || !m->member)
1269 return 0;
1270
1271 /* Then, look for a known method */
1272 vtable_key.path = (char*) p;
1273 vtable_key.interface = m->interface;
1274 vtable_key.member = m->member;
1275
1276 v = hashmap_get(bus->vtable_methods, &vtable_key);
1277 if (v) {
1278 r = method_callbacks_run(bus, m, v, require_fallback, found_object);
1279 if (r != 0)
1280 return r;
1281 if (bus->nodes_modified)
1282 return 0;
1283 }
1284
1285 /* Then, look for a known property */
1286 if (streq(m->interface, "org.freedesktop.DBus.Properties")) {
1287 bool get = false;
1288
1289 get = streq(m->member, "Get");
1290
1291 if (get || streq(m->member, "Set")) {
1292
1293 r = sd_bus_message_rewind(m, true);
1294 if (r < 0)
1295 return r;
1296
1297 vtable_key.path = (char*) p;
1298
1299 r = sd_bus_message_read(m, "ss", &vtable_key.interface, &vtable_key.member);
1300 if (r < 0)
1301 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INVALID_ARGS, "Expected interface and member parameters");
1302
1303 v = hashmap_get(bus->vtable_properties, &vtable_key);
1304 if (v) {
1305 r = property_get_set_callbacks_run(bus, m, v, require_fallback, get, found_object);
1306 if (r != 0)
1307 return r;
1308 }
1309
1310 } else if (streq(m->member, "GetAll")) {
1311 const char *iface;
1312
1313 r = sd_bus_message_rewind(m, true);
1314 if (r < 0)
1315 return r;
1316
1317 r = sd_bus_message_read(m, "s", &iface);
1318 if (r < 0)
1319 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INVALID_ARGS, "Expected interface parameter");
1320
1321 if (iface[0] == 0)
1322 iface = NULL;
1323
1324 r = property_get_all_callbacks_run(bus, m, n->vtables, require_fallback, iface, found_object);
1325 if (r != 0)
1326 return r;
1327 }
1328
1329 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
1330
1331 if (!isempty(sd_bus_message_get_signature(m, true)))
1332 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INVALID_ARGS, "Expected no parameters");
1333
1334 r = process_introspect(bus, m, n, require_fallback, found_object);
1335 if (r != 0)
1336 return r;
1337
1338 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.ObjectManager", "GetManagedObjects")) {
1339
1340 if (!isempty(sd_bus_message_get_signature(m, true)))
1341 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INVALID_ARGS, "Expected no parameters");
1342
1343 r = process_get_managed_objects(bus, m, n, require_fallback, found_object);
1344 if (r != 0)
1345 return r;
1346 }
1347
1348 if (bus->nodes_modified)
1349 return 0;
1350
1351 if (!*found_object) {
1352 r = bus_node_exists(bus, n, m->path, require_fallback);
1353 if (r < 0)
1354 return bus_maybe_reply_error(m, r, NULL);
1355 if (bus->nodes_modified)
1356 return 0;
1357 if (r > 0)
1358 *found_object = true;
1359 }
1360
1361 return 0;
1362 }
1363
1364 int bus_process_object(sd_bus *bus, sd_bus_message *m) {
1365 int r;
1366 size_t pl;
1367 bool found_object = false;
1368
1369 assert(bus);
1370 assert(m);
1371
1372 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1373 return 0;
1374
1375 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
1376 return 0;
1377
1378 if (hashmap_isempty(bus->nodes))
1379 return 0;
1380
1381 /* Never respond to broadcast messages */
1382 if (bus->bus_client && !m->destination)
1383 return 0;
1384
1385 assert(m->path);
1386 assert(m->member);
1387
1388 pl = strlen(m->path);
1389 do {
1390 char prefix[pl+1];
1391
1392 bus->nodes_modified = false;
1393
1394 r = object_find_and_run(bus, m, m->path, false, &found_object);
1395 if (r != 0)
1396 return r;
1397
1398 /* Look for fallback prefixes */
1399 OBJECT_PATH_FOREACH_PREFIX(prefix, m->path) {
1400
1401 if (bus->nodes_modified)
1402 break;
1403
1404 r = object_find_and_run(bus, m, prefix, true, &found_object);
1405 if (r != 0)
1406 return r;
1407 }
1408
1409 } while (bus->nodes_modified);
1410
1411 if (!found_object)
1412 return 0;
1413
1414 if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "Get") ||
1415 sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "Set"))
1416 r = sd_bus_reply_method_errorf(
1417 m,
1418 SD_BUS_ERROR_UNKNOWN_PROPERTY,
1419 "Unknown property or interface.");
1420 else
1421 r = sd_bus_reply_method_errorf(
1422 m,
1423 SD_BUS_ERROR_UNKNOWN_METHOD,
1424 "Unknown method '%s' or interface '%s'.", m->member, m->interface);
1425
1426 if (r < 0)
1427 return r;
1428
1429 return 1;
1430 }
1431
1432 static struct node *bus_node_allocate(sd_bus *bus, const char *path) {
1433 struct node *n, *parent;
1434 const char *e;
1435 _cleanup_free_ char *s = NULL;
1436 char *p;
1437 int r;
1438
1439 assert(bus);
1440 assert(path);
1441 assert(path[0] == '/');
1442
1443 n = hashmap_get(bus->nodes, path);
1444 if (n)
1445 return n;
1446
1447 r = hashmap_ensure_allocated(&bus->nodes, &string_hash_ops);
1448 if (r < 0)
1449 return NULL;
1450
1451 s = strdup(path);
1452 if (!s)
1453 return NULL;
1454
1455 if (streq(path, "/"))
1456 parent = NULL;
1457 else {
1458 e = strrchr(path, '/');
1459 assert(e);
1460
1461 p = strndupa(path, MAX(1, e - path));
1462
1463 parent = bus_node_allocate(bus, p);
1464 if (!parent)
1465 return NULL;
1466 }
1467
1468 n = new0(struct node, 1);
1469 if (!n)
1470 return NULL;
1471
1472 n->parent = parent;
1473 n->path = s;
1474 s = NULL; /* do not free */
1475
1476 r = hashmap_put(bus->nodes, n->path, n);
1477 if (r < 0) {
1478 free(n->path);
1479 return mfree(n);
1480 }
1481
1482 if (parent)
1483 LIST_PREPEND(siblings, parent->child, n);
1484
1485 return n;
1486 }
1487
1488 void bus_node_gc(sd_bus *b, struct node *n) {
1489 assert(b);
1490
1491 if (!n)
1492 return;
1493
1494 if (n->child ||
1495 n->callbacks ||
1496 n->vtables ||
1497 n->enumerators ||
1498 n->object_managers)
1499 return;
1500
1501 assert_se(hashmap_remove(b->nodes, n->path) == n);
1502
1503 if (n->parent)
1504 LIST_REMOVE(siblings, n->parent->child, n);
1505
1506 free(n->path);
1507 bus_node_gc(b, n->parent);
1508 free(n);
1509 }
1510
1511 static int bus_find_parent_object_manager(sd_bus *bus, struct node **out, const char *path) {
1512 struct node *n;
1513
1514 assert(bus);
1515 assert(path);
1516
1517 n = hashmap_get(bus->nodes, path);
1518 if (!n) {
1519 char *prefix;
1520
1521 prefix = alloca(strlen(path) + 1);
1522 OBJECT_PATH_FOREACH_PREFIX(prefix, path) {
1523 n = hashmap_get(bus->nodes, prefix);
1524 if (n)
1525 break;
1526 }
1527 }
1528
1529 while (n && !n->object_managers)
1530 n = n->parent;
1531
1532 if (out)
1533 *out = n;
1534 return !!n;
1535 }
1536
1537 static int bus_add_object(
1538 sd_bus *bus,
1539 sd_bus_slot **slot,
1540 bool fallback,
1541 const char *path,
1542 sd_bus_message_handler_t callback,
1543 void *userdata) {
1544
1545 sd_bus_slot *s;
1546 struct node *n;
1547 int r;
1548
1549 assert_return(bus, -EINVAL);
1550 assert_return(object_path_is_valid(path), -EINVAL);
1551 assert_return(callback, -EINVAL);
1552 assert_return(!bus_pid_changed(bus), -ECHILD);
1553
1554 n = bus_node_allocate(bus, path);
1555 if (!n)
1556 return -ENOMEM;
1557
1558 s = bus_slot_allocate(bus, !slot, BUS_NODE_CALLBACK, sizeof(struct node_callback), userdata);
1559 if (!s) {
1560 r = -ENOMEM;
1561 goto fail;
1562 }
1563
1564 s->node_callback.callback = callback;
1565 s->node_callback.is_fallback = fallback;
1566
1567 s->node_callback.node = n;
1568 LIST_PREPEND(callbacks, n->callbacks, &s->node_callback);
1569 bus->nodes_modified = true;
1570
1571 if (slot)
1572 *slot = s;
1573
1574 return 0;
1575
1576 fail:
1577 sd_bus_slot_unref(s);
1578 bus_node_gc(bus, n);
1579
1580 return r;
1581 }
1582
1583 _public_ int sd_bus_add_object(
1584 sd_bus *bus,
1585 sd_bus_slot **slot,
1586 const char *path,
1587 sd_bus_message_handler_t callback,
1588 void *userdata) {
1589
1590 return bus_add_object(bus, slot, false, path, callback, userdata);
1591 }
1592
1593 _public_ int sd_bus_add_fallback(
1594 sd_bus *bus,
1595 sd_bus_slot **slot,
1596 const char *prefix,
1597 sd_bus_message_handler_t callback,
1598 void *userdata) {
1599
1600 return bus_add_object(bus, slot, true, prefix, callback, userdata);
1601 }
1602
1603 static void vtable_member_hash_func(const void *a, struct siphash *state) {
1604 const struct vtable_member *m = a;
1605
1606 assert(m);
1607
1608 string_hash_func(m->path, state);
1609 string_hash_func(m->interface, state);
1610 string_hash_func(m->member, state);
1611 }
1612
1613 static int vtable_member_compare_func(const void *a, const void *b) {
1614 const struct vtable_member *x = a, *y = b;
1615 int r;
1616
1617 assert(x);
1618 assert(y);
1619
1620 r = strcmp(x->path, y->path);
1621 if (r != 0)
1622 return r;
1623
1624 r = strcmp(x->interface, y->interface);
1625 if (r != 0)
1626 return r;
1627
1628 return strcmp(x->member, y->member);
1629 }
1630
1631 static const struct hash_ops vtable_member_hash_ops = {
1632 .hash = vtable_member_hash_func,
1633 .compare = vtable_member_compare_func
1634 };
1635
1636 static int add_object_vtable_internal(
1637 sd_bus *bus,
1638 sd_bus_slot **slot,
1639 const char *path,
1640 const char *interface,
1641 const sd_bus_vtable *vtable,
1642 bool fallback,
1643 sd_bus_object_find_t find,
1644 void *userdata) {
1645
1646 sd_bus_slot *s = NULL;
1647 struct node_vtable *i, *existing = NULL;
1648 const sd_bus_vtable *v;
1649 struct node *n;
1650 int r;
1651
1652 assert_return(bus, -EINVAL);
1653 assert_return(object_path_is_valid(path), -EINVAL);
1654 assert_return(interface_name_is_valid(interface), -EINVAL);
1655 assert_return(vtable, -EINVAL);
1656 assert_return(vtable[0].type == _SD_BUS_VTABLE_START, -EINVAL);
1657 assert_return(vtable[0].x.start.element_size == sizeof(struct sd_bus_vtable), -EINVAL);
1658 assert_return(!bus_pid_changed(bus), -ECHILD);
1659 assert_return(!streq(interface, "org.freedesktop.DBus.Properties") &&
1660 !streq(interface, "org.freedesktop.DBus.Introspectable") &&
1661 !streq(interface, "org.freedesktop.DBus.Peer") &&
1662 !streq(interface, "org.freedesktop.DBus.ObjectManager"), -EINVAL);
1663
1664 r = hashmap_ensure_allocated(&bus->vtable_methods, &vtable_member_hash_ops);
1665 if (r < 0)
1666 return r;
1667
1668 r = hashmap_ensure_allocated(&bus->vtable_properties, &vtable_member_hash_ops);
1669 if (r < 0)
1670 return r;
1671
1672 n = bus_node_allocate(bus, path);
1673 if (!n)
1674 return -ENOMEM;
1675
1676 LIST_FOREACH(vtables, i, n->vtables) {
1677 if (i->is_fallback != fallback) {
1678 r = -EPROTOTYPE;
1679 goto fail;
1680 }
1681
1682 if (streq(i->interface, interface)) {
1683
1684 if (i->vtable == vtable) {
1685 r = -EEXIST;
1686 goto fail;
1687 }
1688
1689 existing = i;
1690 }
1691 }
1692
1693 s = bus_slot_allocate(bus, !slot, BUS_NODE_VTABLE, sizeof(struct node_vtable), userdata);
1694 if (!s) {
1695 r = -ENOMEM;
1696 goto fail;
1697 }
1698
1699 s->node_vtable.is_fallback = fallback;
1700 s->node_vtable.vtable = vtable;
1701 s->node_vtable.find = find;
1702
1703 s->node_vtable.interface = strdup(interface);
1704 if (!s->node_vtable.interface) {
1705 r = -ENOMEM;
1706 goto fail;
1707 }
1708
1709 for (v = s->node_vtable.vtable+1; v->type != _SD_BUS_VTABLE_END; v++) {
1710
1711 switch (v->type) {
1712
1713 case _SD_BUS_VTABLE_METHOD: {
1714 struct vtable_member *m;
1715
1716 if (!member_name_is_valid(v->x.method.member) ||
1717 !signature_is_valid(strempty(v->x.method.signature), false) ||
1718 !signature_is_valid(strempty(v->x.method.result), false) ||
1719 !(v->x.method.handler || (isempty(v->x.method.signature) && isempty(v->x.method.result))) ||
1720 v->flags & (SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE|SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION)) {
1721 r = -EINVAL;
1722 goto fail;
1723 }
1724
1725 m = new0(struct vtable_member, 1);
1726 if (!m) {
1727 r = -ENOMEM;
1728 goto fail;
1729 }
1730
1731 m->parent = &s->node_vtable;
1732 m->path = n->path;
1733 m->interface = s->node_vtable.interface;
1734 m->member = v->x.method.member;
1735 m->vtable = v;
1736
1737 r = hashmap_put(bus->vtable_methods, m, m);
1738 if (r < 0) {
1739 free(m);
1740 goto fail;
1741 }
1742
1743 break;
1744 }
1745
1746 case _SD_BUS_VTABLE_WRITABLE_PROPERTY:
1747
1748 if (!(v->x.property.set || bus_type_is_basic(v->x.property.signature[0]))) {
1749 r = -EINVAL;
1750 goto fail;
1751 }
1752
1753 if (v->flags & SD_BUS_VTABLE_PROPERTY_CONST) {
1754 r = -EINVAL;
1755 goto fail;
1756 }
1757
1758 _fallthrough_;
1759 case _SD_BUS_VTABLE_PROPERTY: {
1760 struct vtable_member *m;
1761
1762 if (!member_name_is_valid(v->x.property.member) ||
1763 !signature_is_single(v->x.property.signature, false) ||
1764 !(v->x.property.get || bus_type_is_basic(v->x.property.signature[0]) || streq(v->x.property.signature, "as")) ||
1765 (v->flags & SD_BUS_VTABLE_METHOD_NO_REPLY) ||
1766 (!!(v->flags & SD_BUS_VTABLE_PROPERTY_CONST) + !!(v->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE) + !!(v->flags & SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION)) > 1 ||
1767 ((v->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE) && (v->flags & SD_BUS_VTABLE_PROPERTY_EXPLICIT)) ||
1768 (v->flags & SD_BUS_VTABLE_UNPRIVILEGED && v->type == _SD_BUS_VTABLE_PROPERTY)) {
1769 r = -EINVAL;
1770 goto fail;
1771 }
1772
1773 m = new0(struct vtable_member, 1);
1774 if (!m) {
1775 r = -ENOMEM;
1776 goto fail;
1777 }
1778
1779 m->parent = &s->node_vtable;
1780 m->path = n->path;
1781 m->interface = s->node_vtable.interface;
1782 m->member = v->x.property.member;
1783 m->vtable = v;
1784
1785 r = hashmap_put(bus->vtable_properties, m, m);
1786 if (r < 0) {
1787 free(m);
1788 goto fail;
1789 }
1790
1791 break;
1792 }
1793
1794 case _SD_BUS_VTABLE_SIGNAL:
1795
1796 if (!member_name_is_valid(v->x.signal.member) ||
1797 !signature_is_valid(strempty(v->x.signal.signature), false) ||
1798 v->flags & SD_BUS_VTABLE_UNPRIVILEGED) {
1799 r = -EINVAL;
1800 goto fail;
1801 }
1802
1803 break;
1804
1805 default:
1806 r = -EINVAL;
1807 goto fail;
1808 }
1809 }
1810
1811 s->node_vtable.node = n;
1812 LIST_INSERT_AFTER(vtables, n->vtables, existing, &s->node_vtable);
1813 bus->nodes_modified = true;
1814
1815 if (slot)
1816 *slot = s;
1817
1818 return 0;
1819
1820 fail:
1821 sd_bus_slot_unref(s);
1822 bus_node_gc(bus, n);
1823
1824 return r;
1825 }
1826
1827 _public_ int sd_bus_add_object_vtable(
1828 sd_bus *bus,
1829 sd_bus_slot **slot,
1830 const char *path,
1831 const char *interface,
1832 const sd_bus_vtable *vtable,
1833 void *userdata) {
1834
1835 return add_object_vtable_internal(bus, slot, path, interface, vtable, false, NULL, userdata);
1836 }
1837
1838 _public_ int sd_bus_add_fallback_vtable(
1839 sd_bus *bus,
1840 sd_bus_slot **slot,
1841 const char *prefix,
1842 const char *interface,
1843 const sd_bus_vtable *vtable,
1844 sd_bus_object_find_t find,
1845 void *userdata) {
1846
1847 return add_object_vtable_internal(bus, slot, prefix, interface, vtable, true, find, userdata);
1848 }
1849
1850 _public_ int sd_bus_add_node_enumerator(
1851 sd_bus *bus,
1852 sd_bus_slot **slot,
1853 const char *path,
1854 sd_bus_node_enumerator_t callback,
1855 void *userdata) {
1856
1857 sd_bus_slot *s;
1858 struct node *n;
1859 int r;
1860
1861 assert_return(bus, -EINVAL);
1862 assert_return(object_path_is_valid(path), -EINVAL);
1863 assert_return(callback, -EINVAL);
1864 assert_return(!bus_pid_changed(bus), -ECHILD);
1865
1866 n = bus_node_allocate(bus, path);
1867 if (!n)
1868 return -ENOMEM;
1869
1870 s = bus_slot_allocate(bus, !slot, BUS_NODE_ENUMERATOR, sizeof(struct node_enumerator), userdata);
1871 if (!s) {
1872 r = -ENOMEM;
1873 goto fail;
1874 }
1875
1876 s->node_enumerator.callback = callback;
1877
1878 s->node_enumerator.node = n;
1879 LIST_PREPEND(enumerators, n->enumerators, &s->node_enumerator);
1880 bus->nodes_modified = true;
1881
1882 if (slot)
1883 *slot = s;
1884
1885 return 0;
1886
1887 fail:
1888 sd_bus_slot_unref(s);
1889 bus_node_gc(bus, n);
1890
1891 return r;
1892 }
1893
1894 static int emit_properties_changed_on_interface(
1895 sd_bus *bus,
1896 const char *prefix,
1897 const char *path,
1898 const char *interface,
1899 bool require_fallback,
1900 bool *found_interface,
1901 char **names) {
1902
1903 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1904 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
1905 bool has_invalidating = false, has_changing = false;
1906 struct vtable_member key = {};
1907 struct node_vtable *c;
1908 struct node *n;
1909 char **property;
1910 void *u = NULL;
1911 int r;
1912
1913 assert(bus);
1914 assert(prefix);
1915 assert(path);
1916 assert(interface);
1917 assert(found_interface);
1918
1919 n = hashmap_get(bus->nodes, prefix);
1920 if (!n)
1921 return 0;
1922
1923 r = sd_bus_message_new_signal(bus, &m, path, "org.freedesktop.DBus.Properties", "PropertiesChanged");
1924 if (r < 0)
1925 return r;
1926
1927 r = sd_bus_message_append(m, "s", interface);
1928 if (r < 0)
1929 return r;
1930
1931 r = sd_bus_message_open_container(m, 'a', "{sv}");
1932 if (r < 0)
1933 return r;
1934
1935 key.path = prefix;
1936 key.interface = interface;
1937
1938 LIST_FOREACH(vtables, c, n->vtables) {
1939 if (require_fallback && !c->is_fallback)
1940 continue;
1941
1942 if (!streq(c->interface, interface))
1943 continue;
1944
1945 r = node_vtable_get_userdata(bus, path, c, &u, &error);
1946 if (r < 0)
1947 return r;
1948 if (bus->nodes_modified)
1949 return 0;
1950 if (r == 0)
1951 continue;
1952
1953 *found_interface = true;
1954
1955 if (names) {
1956 /* If the caller specified a list of
1957 * properties we include exactly those in the
1958 * PropertiesChanged message */
1959
1960 STRV_FOREACH(property, names) {
1961 struct vtable_member *v;
1962
1963 assert_return(member_name_is_valid(*property), -EINVAL);
1964
1965 key.member = *property;
1966 v = hashmap_get(bus->vtable_properties, &key);
1967 if (!v)
1968 return -ENOENT;
1969
1970 /* If there are two vtables for the same
1971 * interface, let's handle this property when
1972 * we come to that vtable. */
1973 if (c != v->parent)
1974 continue;
1975
1976 assert_return(v->vtable->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE ||
1977 v->vtable->flags & SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION, -EDOM);
1978
1979 assert_return(!(v->vtable->flags & SD_BUS_VTABLE_HIDDEN), -EDOM);
1980
1981 if (v->vtable->flags & SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION) {
1982 has_invalidating = true;
1983 continue;
1984 }
1985
1986 has_changing = true;
1987
1988 r = vtable_append_one_property(bus, m, m->path, c, v->vtable, u, &error);
1989 if (r < 0)
1990 return r;
1991 if (bus->nodes_modified)
1992 return 0;
1993 }
1994 } else {
1995 const sd_bus_vtable *v;
1996
1997 /* If the caller specified no properties list
1998 * we include all properties that are marked
1999 * as changing in the message. */
2000
2001 for (v = c->vtable+1; v->type != _SD_BUS_VTABLE_END; v++) {
2002 if (!IN_SET(v->type, _SD_BUS_VTABLE_PROPERTY, _SD_BUS_VTABLE_WRITABLE_PROPERTY))
2003 continue;
2004
2005 if (v->flags & SD_BUS_VTABLE_HIDDEN)
2006 continue;
2007
2008 if (v->flags & SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION) {
2009 has_invalidating = true;
2010 continue;
2011 }
2012
2013 if (!(v->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE))
2014 continue;
2015
2016 has_changing = true;
2017
2018 r = vtable_append_one_property(bus, m, m->path, c, v, u, &error);
2019 if (r < 0)
2020 return r;
2021 if (bus->nodes_modified)
2022 return 0;
2023 }
2024 }
2025 }
2026
2027 if (!has_invalidating && !has_changing)
2028 return 0;
2029
2030 r = sd_bus_message_close_container(m);
2031 if (r < 0)
2032 return r;
2033
2034 r = sd_bus_message_open_container(m, 'a', "s");
2035 if (r < 0)
2036 return r;
2037
2038 if (has_invalidating) {
2039 LIST_FOREACH(vtables, c, n->vtables) {
2040 if (require_fallback && !c->is_fallback)
2041 continue;
2042
2043 if (!streq(c->interface, interface))
2044 continue;
2045
2046 r = node_vtable_get_userdata(bus, path, c, &u, &error);
2047 if (r < 0)
2048 return r;
2049 if (bus->nodes_modified)
2050 return 0;
2051 if (r == 0)
2052 continue;
2053
2054 if (names) {
2055 STRV_FOREACH(property, names) {
2056 struct vtable_member *v;
2057
2058 key.member = *property;
2059 assert_se(v = hashmap_get(bus->vtable_properties, &key));
2060 assert(c == v->parent);
2061
2062 if (!(v->vtable->flags & SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION))
2063 continue;
2064
2065 r = sd_bus_message_append(m, "s", *property);
2066 if (r < 0)
2067 return r;
2068 }
2069 } else {
2070 const sd_bus_vtable *v;
2071
2072 for (v = c->vtable+1; v->type != _SD_BUS_VTABLE_END; v++) {
2073 if (!IN_SET(v->type, _SD_BUS_VTABLE_PROPERTY, _SD_BUS_VTABLE_WRITABLE_PROPERTY))
2074 continue;
2075
2076 if (v->flags & SD_BUS_VTABLE_HIDDEN)
2077 continue;
2078
2079 if (!(v->flags & SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION))
2080 continue;
2081
2082 r = sd_bus_message_append(m, "s", v->x.property.member);
2083 if (r < 0)
2084 return r;
2085 }
2086 }
2087 }
2088 }
2089
2090 r = sd_bus_message_close_container(m);
2091 if (r < 0)
2092 return r;
2093
2094 r = sd_bus_send(bus, m, NULL);
2095 if (r < 0)
2096 return r;
2097
2098 return 1;
2099 }
2100
2101 _public_ int sd_bus_emit_properties_changed_strv(
2102 sd_bus *bus,
2103 const char *path,
2104 const char *interface,
2105 char **names) {
2106
2107 BUS_DONT_DESTROY(bus);
2108 bool found_interface = false;
2109 char *prefix;
2110 int r;
2111
2112 assert_return(bus, -EINVAL);
2113 assert_return(object_path_is_valid(path), -EINVAL);
2114 assert_return(interface_name_is_valid(interface), -EINVAL);
2115 assert_return(!bus_pid_changed(bus), -ECHILD);
2116
2117 if (!BUS_IS_OPEN(bus->state))
2118 return -ENOTCONN;
2119
2120 /* A non-NULL but empty names list means nothing needs to be
2121 generated. A NULL list OTOH indicates that all properties
2122 that are set to EMITS_CHANGE or EMITS_INVALIDATION shall be
2123 included in the PropertiesChanged message. */
2124 if (names && names[0] == NULL)
2125 return 0;
2126
2127 do {
2128 bus->nodes_modified = false;
2129
2130 r = emit_properties_changed_on_interface(bus, path, path, interface, false, &found_interface, names);
2131 if (r != 0)
2132 return r;
2133 if (bus->nodes_modified)
2134 continue;
2135
2136 prefix = alloca(strlen(path) + 1);
2137 OBJECT_PATH_FOREACH_PREFIX(prefix, path) {
2138 r = emit_properties_changed_on_interface(bus, prefix, path, interface, true, &found_interface, names);
2139 if (r != 0)
2140 return r;
2141 if (bus->nodes_modified)
2142 break;
2143 }
2144
2145 } while (bus->nodes_modified);
2146
2147 return found_interface ? 0 : -ENOENT;
2148 }
2149
2150 _public_ int sd_bus_emit_properties_changed(
2151 sd_bus *bus,
2152 const char *path,
2153 const char *interface,
2154 const char *name, ...) {
2155
2156 char **names;
2157
2158 assert_return(bus, -EINVAL);
2159 assert_return(object_path_is_valid(path), -EINVAL);
2160 assert_return(interface_name_is_valid(interface), -EINVAL);
2161 assert_return(!bus_pid_changed(bus), -ECHILD);
2162
2163 if (!BUS_IS_OPEN(bus->state))
2164 return -ENOTCONN;
2165
2166 if (!name)
2167 return 0;
2168
2169 names = strv_from_stdarg_alloca(name);
2170
2171 return sd_bus_emit_properties_changed_strv(bus, path, interface, names);
2172 }
2173
2174 static int object_added_append_all_prefix(
2175 sd_bus *bus,
2176 sd_bus_message *m,
2177 Set *s,
2178 const char *prefix,
2179 const char *path,
2180 bool require_fallback) {
2181
2182 const char *previous_interface = NULL;
2183 struct node_vtable *c;
2184 struct node *n;
2185 int r;
2186
2187 assert(bus);
2188 assert(m);
2189 assert(s);
2190 assert(prefix);
2191 assert(path);
2192
2193 n = hashmap_get(bus->nodes, prefix);
2194 if (!n)
2195 return 0;
2196
2197 LIST_FOREACH(vtables, c, n->vtables) {
2198 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2199 void *u = NULL;
2200
2201 if (require_fallback && !c->is_fallback)
2202 continue;
2203
2204 r = node_vtable_get_userdata(bus, path, c, &u, &error);
2205 if (r < 0)
2206 return r;
2207 if (bus->nodes_modified)
2208 return 0;
2209 if (r == 0)
2210 continue;
2211
2212 if (!streq_ptr(c->interface, previous_interface)) {
2213 /* If a child-node already handled this interface, we
2214 * skip it on any of its parents. The child vtables
2215 * always fully override any conflicting vtables of
2216 * any parent node. */
2217 if (set_get(s, c->interface))
2218 continue;
2219
2220 r = set_put(s, c->interface);
2221 if (r < 0)
2222 return r;
2223
2224 if (previous_interface) {
2225 r = sd_bus_message_close_container(m);
2226 if (r < 0)
2227 return r;
2228 r = sd_bus_message_close_container(m);
2229 if (r < 0)
2230 return r;
2231 }
2232
2233 r = sd_bus_message_open_container(m, 'e', "sa{sv}");
2234 if (r < 0)
2235 return r;
2236 r = sd_bus_message_append(m, "s", c->interface);
2237 if (r < 0)
2238 return r;
2239 r = sd_bus_message_open_container(m, 'a', "{sv}");
2240 if (r < 0)
2241 return r;
2242
2243 previous_interface = c->interface;
2244 }
2245
2246 r = vtable_append_all_properties(bus, m, path, c, u, &error);
2247 if (r < 0)
2248 return r;
2249 if (bus->nodes_modified)
2250 return 0;
2251 }
2252
2253 if (previous_interface) {
2254 r = sd_bus_message_close_container(m);
2255 if (r < 0)
2256 return r;
2257 r = sd_bus_message_close_container(m);
2258 if (r < 0)
2259 return r;
2260 }
2261
2262 return 0;
2263 }
2264
2265 static int object_added_append_all(sd_bus *bus, sd_bus_message *m, const char *path) {
2266 _cleanup_set_free_ Set *s = NULL;
2267 char *prefix;
2268 int r;
2269
2270 assert(bus);
2271 assert(m);
2272 assert(path);
2273
2274 /*
2275 * This appends all interfaces registered on path @path. We first add
2276 * the builtin interfaces, which are always available and handled by
2277 * sd-bus. Then, we add all interfaces registered on the exact node,
2278 * followed by all fallback interfaces registered on any parent prefix.
2279 *
2280 * If an interface is registered multiple times on the same node with
2281 * different vtables, we merge all the properties across all vtables.
2282 * However, if a child node has the same interface registered as one of
2283 * its parent nodes has as fallback, we make the child overwrite the
2284 * parent instead of extending it. Therefore, we keep a "Set" of all
2285 * handled interfaces during parent traversal, so we skip interfaces on
2286 * a parent that were overwritten by a child.
2287 */
2288
2289 s = set_new(&string_hash_ops);
2290 if (!s)
2291 return -ENOMEM;
2292
2293 r = sd_bus_message_append(m, "{sa{sv}}", "org.freedesktop.DBus.Peer", 0);
2294 if (r < 0)
2295 return r;
2296 r = sd_bus_message_append(m, "{sa{sv}}", "org.freedesktop.DBus.Introspectable", 0);
2297 if (r < 0)
2298 return r;
2299 r = sd_bus_message_append(m, "{sa{sv}}", "org.freedesktop.DBus.Properties", 0);
2300 if (r < 0)
2301 return r;
2302 r = sd_bus_message_append(m, "{sa{sv}}", "org.freedesktop.DBus.ObjectManager", 0);
2303 if (r < 0)
2304 return r;
2305
2306 r = object_added_append_all_prefix(bus, m, s, path, path, false);
2307 if (r < 0)
2308 return r;
2309 if (bus->nodes_modified)
2310 return 0;
2311
2312 prefix = alloca(strlen(path) + 1);
2313 OBJECT_PATH_FOREACH_PREFIX(prefix, path) {
2314 r = object_added_append_all_prefix(bus, m, s, prefix, path, true);
2315 if (r < 0)
2316 return r;
2317 if (bus->nodes_modified)
2318 return 0;
2319 }
2320
2321 return 0;
2322 }
2323
2324 _public_ int sd_bus_emit_object_added(sd_bus *bus, const char *path) {
2325 BUS_DONT_DESTROY(bus);
2326
2327 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2328 struct node *object_manager;
2329 int r;
2330
2331 /*
2332 * This emits an InterfacesAdded signal on the given path, by iterating
2333 * all registered vtables and fallback vtables on the path. All
2334 * properties are queried and included in the signal.
2335 * This call is equivalent to sd_bus_emit_interfaces_added() with an
2336 * explicit list of registered interfaces. However, unlike
2337 * interfaces_added(), this call can figure out the list of supported
2338 * interfaces itself. Furthermore, it properly adds the builtin
2339 * org.freedesktop.DBus.* interfaces.
2340 */
2341
2342 assert_return(bus, -EINVAL);
2343 assert_return(object_path_is_valid(path), -EINVAL);
2344 assert_return(!bus_pid_changed(bus), -ECHILD);
2345
2346 if (!BUS_IS_OPEN(bus->state))
2347 return -ENOTCONN;
2348
2349 r = bus_find_parent_object_manager(bus, &object_manager, path);
2350 if (r < 0)
2351 return r;
2352 if (r == 0)
2353 return -ESRCH;
2354
2355 do {
2356 bus->nodes_modified = false;
2357 m = sd_bus_message_unref(m);
2358
2359 r = sd_bus_message_new_signal(bus, &m, object_manager->path, "org.freedesktop.DBus.ObjectManager", "InterfacesAdded");
2360 if (r < 0)
2361 return r;
2362
2363 r = sd_bus_message_append_basic(m, 'o', path);
2364 if (r < 0)
2365 return r;
2366
2367 r = sd_bus_message_open_container(m, 'a', "{sa{sv}}");
2368 if (r < 0)
2369 return r;
2370
2371 r = object_added_append_all(bus, m, path);
2372 if (r < 0)
2373 return r;
2374
2375 if (bus->nodes_modified)
2376 continue;
2377
2378 r = sd_bus_message_close_container(m);
2379 if (r < 0)
2380 return r;
2381
2382 } while (bus->nodes_modified);
2383
2384 return sd_bus_send(bus, m, NULL);
2385 }
2386
2387 static int object_removed_append_all_prefix(
2388 sd_bus *bus,
2389 sd_bus_message *m,
2390 Set *s,
2391 const char *prefix,
2392 const char *path,
2393 bool require_fallback) {
2394
2395 const char *previous_interface = NULL;
2396 struct node_vtable *c;
2397 struct node *n;
2398 int r;
2399
2400 assert(bus);
2401 assert(m);
2402 assert(s);
2403 assert(prefix);
2404 assert(path);
2405
2406 n = hashmap_get(bus->nodes, prefix);
2407 if (!n)
2408 return 0;
2409
2410 LIST_FOREACH(vtables, c, n->vtables) {
2411 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2412 void *u = NULL;
2413
2414 if (require_fallback && !c->is_fallback)
2415 continue;
2416 if (streq_ptr(c->interface, previous_interface))
2417 continue;
2418
2419 /* If a child-node already handled this interface, we
2420 * skip it on any of its parents. The child vtables
2421 * always fully override any conflicting vtables of
2422 * any parent node. */
2423 if (set_get(s, c->interface))
2424 continue;
2425
2426 r = node_vtable_get_userdata(bus, path, c, &u, &error);
2427 if (r < 0)
2428 return r;
2429 if (bus->nodes_modified)
2430 return 0;
2431 if (r == 0)
2432 continue;
2433
2434 r = set_put(s, c->interface);
2435 if (r < 0)
2436 return r;
2437
2438 r = sd_bus_message_append(m, "s", c->interface);
2439 if (r < 0)
2440 return r;
2441
2442 previous_interface = c->interface;
2443 }
2444
2445 return 0;
2446 }
2447
2448 static int object_removed_append_all(sd_bus *bus, sd_bus_message *m, const char *path) {
2449 _cleanup_set_free_ Set *s = NULL;
2450 char *prefix;
2451 int r;
2452
2453 assert(bus);
2454 assert(m);
2455 assert(path);
2456
2457 /* see sd_bus_emit_object_added() for details */
2458
2459 s = set_new(&string_hash_ops);
2460 if (!s)
2461 return -ENOMEM;
2462
2463 r = sd_bus_message_append(m, "s", "org.freedesktop.DBus.Peer");
2464 if (r < 0)
2465 return r;
2466 r = sd_bus_message_append(m, "s", "org.freedesktop.DBus.Introspectable");
2467 if (r < 0)
2468 return r;
2469 r = sd_bus_message_append(m, "s", "org.freedesktop.DBus.Properties");
2470 if (r < 0)
2471 return r;
2472 r = sd_bus_message_append(m, "s", "org.freedesktop.DBus.ObjectManager");
2473 if (r < 0)
2474 return r;
2475
2476 r = object_removed_append_all_prefix(bus, m, s, path, path, false);
2477 if (r < 0)
2478 return r;
2479 if (bus->nodes_modified)
2480 return 0;
2481
2482 prefix = alloca(strlen(path) + 1);
2483 OBJECT_PATH_FOREACH_PREFIX(prefix, path) {
2484 r = object_removed_append_all_prefix(bus, m, s, prefix, path, true);
2485 if (r < 0)
2486 return r;
2487 if (bus->nodes_modified)
2488 return 0;
2489 }
2490
2491 return 0;
2492 }
2493
2494 _public_ int sd_bus_emit_object_removed(sd_bus *bus, const char *path) {
2495 BUS_DONT_DESTROY(bus);
2496
2497 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2498 struct node *object_manager;
2499 int r;
2500
2501 /*
2502 * This is like sd_bus_emit_object_added(), but emits an
2503 * InterfacesRemoved signal on the given path. This only includes any
2504 * registered interfaces but skips the properties. Note that this will
2505 * call into the find() callbacks of any registered vtable. Therefore,
2506 * you must call this function before destroying/unlinking your object.
2507 * Otherwise, the list of interfaces will be incomplete. However, note
2508 * that this will *NOT* call into any property callback. Therefore, the
2509 * object might be in an "destructed" state, as long as we can find it.
2510 */
2511
2512 assert_return(bus, -EINVAL);
2513 assert_return(object_path_is_valid(path), -EINVAL);
2514 assert_return(!bus_pid_changed(bus), -ECHILD);
2515
2516 if (!BUS_IS_OPEN(bus->state))
2517 return -ENOTCONN;
2518
2519 r = bus_find_parent_object_manager(bus, &object_manager, path);
2520 if (r < 0)
2521 return r;
2522 if (r == 0)
2523 return -ESRCH;
2524
2525 do {
2526 bus->nodes_modified = false;
2527 m = sd_bus_message_unref(m);
2528
2529 r = sd_bus_message_new_signal(bus, &m, object_manager->path, "org.freedesktop.DBus.ObjectManager", "InterfacesRemoved");
2530 if (r < 0)
2531 return r;
2532
2533 r = sd_bus_message_append_basic(m, 'o', path);
2534 if (r < 0)
2535 return r;
2536
2537 r = sd_bus_message_open_container(m, 'a', "s");
2538 if (r < 0)
2539 return r;
2540
2541 r = object_removed_append_all(bus, m, path);
2542 if (r < 0)
2543 return r;
2544
2545 if (bus->nodes_modified)
2546 continue;
2547
2548 r = sd_bus_message_close_container(m);
2549 if (r < 0)
2550 return r;
2551
2552 } while (bus->nodes_modified);
2553
2554 return sd_bus_send(bus, m, NULL);
2555 }
2556
2557 static int interfaces_added_append_one_prefix(
2558 sd_bus *bus,
2559 sd_bus_message *m,
2560 const char *prefix,
2561 const char *path,
2562 const char *interface,
2563 bool require_fallback) {
2564
2565 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2566 bool found_interface = false;
2567 struct node_vtable *c;
2568 struct node *n;
2569 void *u = NULL;
2570 int r;
2571
2572 assert(bus);
2573 assert(m);
2574 assert(prefix);
2575 assert(path);
2576 assert(interface);
2577
2578 n = hashmap_get(bus->nodes, prefix);
2579 if (!n)
2580 return 0;
2581
2582 LIST_FOREACH(vtables, c, n->vtables) {
2583 if (require_fallback && !c->is_fallback)
2584 continue;
2585
2586 if (!streq(c->interface, interface))
2587 continue;
2588
2589 r = node_vtable_get_userdata(bus, path, c, &u, &error);
2590 if (r < 0)
2591 return r;
2592 if (bus->nodes_modified)
2593 return 0;
2594 if (r == 0)
2595 continue;
2596
2597 if (!found_interface) {
2598 r = sd_bus_message_append_basic(m, 's', interface);
2599 if (r < 0)
2600 return r;
2601
2602 r = sd_bus_message_open_container(m, 'a', "{sv}");
2603 if (r < 0)
2604 return r;
2605
2606 found_interface = true;
2607 }
2608
2609 r = vtable_append_all_properties(bus, m, path, c, u, &error);
2610 if (r < 0)
2611 return r;
2612 if (bus->nodes_modified)
2613 return 0;
2614 }
2615
2616 if (found_interface) {
2617 r = sd_bus_message_close_container(m);
2618 if (r < 0)
2619 return r;
2620 }
2621
2622 return found_interface;
2623 }
2624
2625 static int interfaces_added_append_one(
2626 sd_bus *bus,
2627 sd_bus_message *m,
2628 const char *path,
2629 const char *interface) {
2630
2631 char *prefix;
2632 int r;
2633
2634 assert(bus);
2635 assert(m);
2636 assert(path);
2637 assert(interface);
2638
2639 r = interfaces_added_append_one_prefix(bus, m, path, path, interface, false);
2640 if (r != 0)
2641 return r;
2642 if (bus->nodes_modified)
2643 return 0;
2644
2645 prefix = alloca(strlen(path) + 1);
2646 OBJECT_PATH_FOREACH_PREFIX(prefix, path) {
2647 r = interfaces_added_append_one_prefix(bus, m, prefix, path, interface, true);
2648 if (r != 0)
2649 return r;
2650 if (bus->nodes_modified)
2651 return 0;
2652 }
2653
2654 return -ENOENT;
2655 }
2656
2657 _public_ int sd_bus_emit_interfaces_added_strv(sd_bus *bus, const char *path, char **interfaces) {
2658 BUS_DONT_DESTROY(bus);
2659
2660 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2661 struct node *object_manager;
2662 char **i;
2663 int r;
2664
2665 assert_return(bus, -EINVAL);
2666 assert_return(object_path_is_valid(path), -EINVAL);
2667 assert_return(!bus_pid_changed(bus), -ECHILD);
2668
2669 if (!BUS_IS_OPEN(bus->state))
2670 return -ENOTCONN;
2671
2672 if (strv_isempty(interfaces))
2673 return 0;
2674
2675 r = bus_find_parent_object_manager(bus, &object_manager, path);
2676 if (r < 0)
2677 return r;
2678 if (r == 0)
2679 return -ESRCH;
2680
2681 do {
2682 bus->nodes_modified = false;
2683 m = sd_bus_message_unref(m);
2684
2685 r = sd_bus_message_new_signal(bus, &m, object_manager->path, "org.freedesktop.DBus.ObjectManager", "InterfacesAdded");
2686 if (r < 0)
2687 return r;
2688
2689 r = sd_bus_message_append_basic(m, 'o', path);
2690 if (r < 0)
2691 return r;
2692
2693 r = sd_bus_message_open_container(m, 'a', "{sa{sv}}");
2694 if (r < 0)
2695 return r;
2696
2697 STRV_FOREACH(i, interfaces) {
2698 assert_return(interface_name_is_valid(*i), -EINVAL);
2699
2700 r = sd_bus_message_open_container(m, 'e', "sa{sv}");
2701 if (r < 0)
2702 return r;
2703
2704 r = interfaces_added_append_one(bus, m, path, *i);
2705 if (r < 0)
2706 return r;
2707
2708 if (bus->nodes_modified)
2709 break;
2710
2711 r = sd_bus_message_close_container(m);
2712 if (r < 0)
2713 return r;
2714 }
2715
2716 if (bus->nodes_modified)
2717 continue;
2718
2719 r = sd_bus_message_close_container(m);
2720 if (r < 0)
2721 return r;
2722
2723 } while (bus->nodes_modified);
2724
2725 return sd_bus_send(bus, m, NULL);
2726 }
2727
2728 _public_ int sd_bus_emit_interfaces_added(sd_bus *bus, const char *path, const char *interface, ...) {
2729 char **interfaces;
2730
2731 assert_return(bus, -EINVAL);
2732 assert_return(object_path_is_valid(path), -EINVAL);
2733 assert_return(!bus_pid_changed(bus), -ECHILD);
2734
2735 if (!BUS_IS_OPEN(bus->state))
2736 return -ENOTCONN;
2737
2738 interfaces = strv_from_stdarg_alloca(interface);
2739
2740 return sd_bus_emit_interfaces_added_strv(bus, path, interfaces);
2741 }
2742
2743 _public_ int sd_bus_emit_interfaces_removed_strv(sd_bus *bus, const char *path, char **interfaces) {
2744 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2745 struct node *object_manager;
2746 int r;
2747
2748 assert_return(bus, -EINVAL);
2749 assert_return(object_path_is_valid(path), -EINVAL);
2750 assert_return(!bus_pid_changed(bus), -ECHILD);
2751
2752 if (!BUS_IS_OPEN(bus->state))
2753 return -ENOTCONN;
2754
2755 if (strv_isempty(interfaces))
2756 return 0;
2757
2758 r = bus_find_parent_object_manager(bus, &object_manager, path);
2759 if (r < 0)
2760 return r;
2761 if (r == 0)
2762 return -ESRCH;
2763
2764 r = sd_bus_message_new_signal(bus, &m, object_manager->path, "org.freedesktop.DBus.ObjectManager", "InterfacesRemoved");
2765 if (r < 0)
2766 return r;
2767
2768 r = sd_bus_message_append_basic(m, 'o', path);
2769 if (r < 0)
2770 return r;
2771
2772 r = sd_bus_message_append_strv(m, interfaces);
2773 if (r < 0)
2774 return r;
2775
2776 return sd_bus_send(bus, m, NULL);
2777 }
2778
2779 _public_ int sd_bus_emit_interfaces_removed(sd_bus *bus, const char *path, const char *interface, ...) {
2780 char **interfaces;
2781
2782 assert_return(bus, -EINVAL);
2783 assert_return(object_path_is_valid(path), -EINVAL);
2784 assert_return(!bus_pid_changed(bus), -ECHILD);
2785
2786 if (!BUS_IS_OPEN(bus->state))
2787 return -ENOTCONN;
2788
2789 interfaces = strv_from_stdarg_alloca(interface);
2790
2791 return sd_bus_emit_interfaces_removed_strv(bus, path, interfaces);
2792 }
2793
2794 _public_ int sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **slot, const char *path) {
2795 sd_bus_slot *s;
2796 struct node *n;
2797 int r;
2798
2799 assert_return(bus, -EINVAL);
2800 assert_return(object_path_is_valid(path), -EINVAL);
2801 assert_return(!bus_pid_changed(bus), -ECHILD);
2802
2803 n = bus_node_allocate(bus, path);
2804 if (!n)
2805 return -ENOMEM;
2806
2807 s = bus_slot_allocate(bus, !slot, BUS_NODE_OBJECT_MANAGER, sizeof(struct node_object_manager), NULL);
2808 if (!s) {
2809 r = -ENOMEM;
2810 goto fail;
2811 }
2812
2813 s->node_object_manager.node = n;
2814 LIST_PREPEND(object_managers, n->object_managers, &s->node_object_manager);
2815 bus->nodes_modified = true;
2816
2817 if (slot)
2818 *slot = s;
2819
2820 return 0;
2821
2822 fail:
2823 sd_bus_slot_unref(s);
2824 bus_node_gc(bus, n);
2825
2826 return r;
2827 }
Unnamed repository; edit this file 'description' to name the repository.