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