1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 #include "alloc-util.h"
4 #include "bus-internal.h"
5 #include "bus-introspect.h"
6 #include "bus-message.h"
7 #include "bus-objects.h"
8 #include "bus-signature.h"
12 #include "missing_capability.h"
14 #include "string-util.h"
17 static int node_vtable_get_userdata(
20 struct node_vtable
*c
,
22 sd_bus_error
*error
) {
25 void *u
, *found_u
= NULL
;
32 s
= container_of(c
, sd_bus_slot
, node_vtable
);
35 bus
->current_slot
= sd_bus_slot_ref(s
);
36 bus
->current_userdata
= u
;
37 r
= c
->find(bus
, path
, c
->interface
, u
, &found_u
, error
);
38 bus
->current_userdata
= NULL
;
39 bus
->current_slot
= sd_bus_slot_unref(s
);
43 if (sd_bus_error_is_set(error
))
44 return -sd_bus_error_get_errno(error
);
56 static void *vtable_method_convert_userdata(const sd_bus_vtable
*p
, void *u
) {
59 return (uint8_t*) u
+ p
->x
.method
.offset
;
62 static void *vtable_property_convert_userdata(const sd_bus_vtable
*p
, void *u
) {
65 return (uint8_t*) u
+ p
->x
.property
.offset
;
68 static int vtable_property_get_userdata(
71 struct vtable_member
*p
,
73 sd_bus_error
*error
) {
83 r
= node_vtable_get_userdata(bus
, path
, p
->parent
, &u
, error
);
86 if (bus
->nodes_modified
)
89 *userdata
= vtable_property_convert_userdata(p
->vtable
, u
);
93 static int add_enumerated_to_set(
96 struct node_enumerator
*first
,
98 sd_bus_error
*error
) {
100 struct node_enumerator
*c
;
107 LIST_FOREACH(enumerators
, c
, first
) {
108 char **children
= NULL
, **k
;
111 if (bus
->nodes_modified
)
114 slot
= container_of(c
, sd_bus_slot
, node_enumerator
);
116 bus
->current_slot
= sd_bus_slot_ref(slot
);
117 bus
->current_userdata
= slot
->userdata
;
118 r
= c
->callback(bus
, prefix
, slot
->userdata
, &children
, error
);
119 bus
->current_userdata
= NULL
;
120 bus
->current_slot
= sd_bus_slot_unref(slot
);
124 if (sd_bus_error_is_set(error
))
125 return -sd_bus_error_get_errno(error
);
127 STRV_FOREACH(k
, children
) {
133 if (!object_path_is_valid(*k
)) {
139 if (!object_path_startswith(*k
, prefix
)) {
144 r
= set_consume(s
, *k
);
158 /* if set, add_subtree() works recursively */
159 CHILDREN_RECURSIVE
= 1 << 0,
160 /* if set, add_subtree() scans object-manager hierarchies recursively */
161 CHILDREN_SUBHIERARCHIES
= 1 << 1,
164 static int add_subtree_to_set(
170 sd_bus_error
*error
) {
180 r
= add_enumerated_to_set(bus
, prefix
, n
->enumerators
, s
, error
);
183 if (bus
->nodes_modified
)
186 LIST_FOREACH(siblings
, i
, n
->child
) {
189 if (!object_path_startswith(i
->path
, prefix
))
196 r
= set_consume(s
, t
);
197 if (r
< 0 && r
!= -EEXIST
)
200 if ((flags
& CHILDREN_RECURSIVE
) &&
201 ((flags
& CHILDREN_SUBHIERARCHIES
) || !i
->object_managers
)) {
202 r
= add_subtree_to_set(bus
, prefix
, i
, flags
, s
, error
);
205 if (bus
->nodes_modified
)
213 static int get_child_nodes(
219 sd_bus_error
*error
) {
229 s
= set_new(&string_hash_ops
);
233 r
= add_subtree_to_set(bus
, prefix
, n
, flags
, s
, error
);
243 static int node_callbacks_run(
246 struct node_callback
*first
,
247 bool require_fallback
,
248 bool *found_object
) {
250 struct node_callback
*c
;
255 assert(found_object
);
257 LIST_FOREACH(callbacks
, c
, first
) {
258 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
261 if (bus
->nodes_modified
)
264 if (require_fallback
&& !c
->is_fallback
)
267 *found_object
= true;
269 if (c
->last_iteration
== bus
->iteration_counter
)
272 c
->last_iteration
= bus
->iteration_counter
;
274 r
= sd_bus_message_rewind(m
, true);
278 slot
= container_of(c
, sd_bus_slot
, node_callback
);
280 bus
->current_slot
= sd_bus_slot_ref(slot
);
281 bus
->current_handler
= c
->callback
;
282 bus
->current_userdata
= slot
->userdata
;
283 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
284 bus
->current_userdata
= NULL
;
285 bus
->current_handler
= NULL
;
286 bus
->current_slot
= sd_bus_slot_unref(slot
);
288 r
= bus_maybe_reply_error(m
, r
, &error_buffer
);
296 #define CAPABILITY_SHIFT(x) (((x) >> __builtin_ctzll(_SD_BUS_VTABLE_CAPABILITY_MASK)) & 0xFFFF)
298 static int check_access(sd_bus
*bus
, sd_bus_message
*m
, struct vtable_member
*c
, sd_bus_error
*error
) {
306 /* If the entire bus is trusted let's grant access */
310 /* If the member is marked UNPRIVILEGED let's grant access */
311 if (c
->vtable
->flags
& SD_BUS_VTABLE_UNPRIVILEGED
)
314 /* Check have the caller has the requested capability
315 * set. Note that the flags value contains the capability
316 * number plus one, which we need to subtract here. We do this
317 * so that we have 0 as special value for "default
319 cap
= CAPABILITY_SHIFT(c
->vtable
->flags
);
321 cap
= CAPABILITY_SHIFT(c
->parent
->vtable
[0].flags
);
327 r
= sd_bus_query_sender_privilege(m
, cap
);
333 return sd_bus_error_setf(error
, SD_BUS_ERROR_ACCESS_DENIED
, "Access to %s.%s() not permitted.", c
->interface
, c
->member
);
336 static int method_callbacks_run(
339 struct vtable_member
*c
,
340 bool require_fallback
,
341 bool *found_object
) {
343 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
344 const char *signature
;
351 assert(found_object
);
353 if (require_fallback
&& !c
->parent
->is_fallback
)
356 r
= check_access(bus
, m
, c
, &error
);
358 return bus_maybe_reply_error(m
, r
, &error
);
360 r
= node_vtable_get_userdata(bus
, m
->path
, c
->parent
, &u
, &error
);
362 return bus_maybe_reply_error(m
, r
, &error
);
363 if (bus
->nodes_modified
)
366 u
= vtable_method_convert_userdata(c
->vtable
, u
);
368 *found_object
= true;
370 if (c
->last_iteration
== bus
->iteration_counter
)
373 c
->last_iteration
= bus
->iteration_counter
;
375 r
= sd_bus_message_rewind(m
, true);
379 signature
= sd_bus_message_get_signature(m
, true);
383 if (!streq(strempty(c
->vtable
->x
.method
.signature
), signature
))
384 return sd_bus_reply_method_errorf(
386 SD_BUS_ERROR_INVALID_ARGS
,
387 "Invalid arguments '%s' to call %s.%s(), expecting '%s'.",
388 signature
, c
->interface
, c
->member
, strempty(c
->vtable
->x
.method
.signature
));
390 /* Keep track what the signature of the reply to this message
391 * should be, so that this can be enforced when sealing the
393 m
->enforced_reply_signature
= strempty(c
->vtable
->x
.method
.result
);
395 if (c
->vtable
->x
.method
.handler
) {
398 slot
= container_of(c
->parent
, sd_bus_slot
, node_vtable
);
400 bus
->current_slot
= sd_bus_slot_ref(slot
);
401 bus
->current_handler
= c
->vtable
->x
.method
.handler
;
402 bus
->current_userdata
= u
;
403 r
= c
->vtable
->x
.method
.handler(m
, u
, &error
);
404 bus
->current_userdata
= NULL
;
405 bus
->current_handler
= NULL
;
406 bus
->current_slot
= sd_bus_slot_unref(slot
);
408 return bus_maybe_reply_error(m
, r
, &error
);
411 /* If the method callback is NULL, make this a successful NOP */
412 r
= sd_bus_reply_method_return(m
, NULL
);
419 static int invoke_property_get(
422 const sd_bus_vtable
*v
,
424 const char *interface
,
425 const char *property
,
426 sd_bus_message
*reply
,
428 sd_bus_error
*error
) {
441 if (v
->x
.property
.get
) {
443 bus
->current_slot
= sd_bus_slot_ref(slot
);
444 bus
->current_userdata
= userdata
;
445 r
= v
->x
.property
.get(bus
, path
, interface
, property
, reply
, userdata
, error
);
446 bus
->current_userdata
= NULL
;
447 bus
->current_slot
= sd_bus_slot_unref(slot
);
451 if (sd_bus_error_is_set(error
))
452 return -sd_bus_error_get_errno(error
);
456 /* Automatic handling if no callback is defined. */
458 if (streq(v
->x
.property
.signature
, "as"))
459 return sd_bus_message_append_strv(reply
, *(char***) userdata
);
461 assert(signature_is_single(v
->x
.property
.signature
, false));
462 assert(bus_type_is_basic(v
->x
.property
.signature
[0]));
464 switch (v
->x
.property
.signature
[0]) {
466 case SD_BUS_TYPE_STRING
:
467 case SD_BUS_TYPE_SIGNATURE
:
468 p
= strempty(*(char**) userdata
);
471 case SD_BUS_TYPE_OBJECT_PATH
:
472 p
= *(char**) userdata
;
481 return sd_bus_message_append_basic(reply
, v
->x
.property
.signature
[0], p
);
484 static int invoke_property_set(
487 const sd_bus_vtable
*v
,
489 const char *interface
,
490 const char *property
,
491 sd_bus_message
*value
,
493 sd_bus_error
*error
) {
505 if (v
->x
.property
.set
) {
507 bus
->current_slot
= sd_bus_slot_ref(slot
);
508 bus
->current_userdata
= userdata
;
509 r
= v
->x
.property
.set(bus
, path
, interface
, property
, value
, userdata
, error
);
510 bus
->current_userdata
= NULL
;
511 bus
->current_slot
= sd_bus_slot_unref(slot
);
515 if (sd_bus_error_is_set(error
))
516 return -sd_bus_error_get_errno(error
);
520 /* Automatic handling if no callback is defined. */
522 assert(signature_is_single(v
->x
.property
.signature
, false));
523 assert(bus_type_is_basic(v
->x
.property
.signature
[0]));
525 switch (v
->x
.property
.signature
[0]) {
527 case SD_BUS_TYPE_STRING
:
528 case SD_BUS_TYPE_OBJECT_PATH
:
529 case SD_BUS_TYPE_SIGNATURE
: {
533 r
= sd_bus_message_read_basic(value
, v
->x
.property
.signature
[0], &p
);
541 free(*(char**) userdata
);
542 *(char**) userdata
= n
;
548 r
= sd_bus_message_read_basic(value
, v
->x
.property
.signature
[0], userdata
);
558 static int property_get_set_callbacks_run(
561 struct vtable_member
*c
,
562 bool require_fallback
,
564 bool *found_object
) {
566 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
567 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
575 assert(found_object
);
577 if (require_fallback
&& !c
->parent
->is_fallback
)
580 r
= vtable_property_get_userdata(bus
, m
->path
, c
, &u
, &error
);
582 return bus_maybe_reply_error(m
, r
, &error
);
583 if (bus
->nodes_modified
)
586 slot
= container_of(c
->parent
, sd_bus_slot
, node_vtable
);
588 *found_object
= true;
590 r
= sd_bus_message_new_method_return(m
, &reply
);
595 /* Note that we do not protect against reexecution
596 * here (using the last_iteration check, see below),
597 * should the node tree have changed and we got called
598 * again. We assume that property Get() calls are
599 * ultimately without side-effects or if they aren't
600 * then at least idempotent. */
602 r
= sd_bus_message_open_container(reply
, 'v', c
->vtable
->x
.property
.signature
);
606 /* Note that we do not do an access check here. Read
607 * access to properties is always unrestricted, since
608 * PropertiesChanged signals broadcast contents
611 r
= invoke_property_get(bus
, slot
, c
->vtable
, m
->path
, c
->interface
, c
->member
, reply
, u
, &error
);
613 return bus_maybe_reply_error(m
, r
, &error
);
615 if (bus
->nodes_modified
)
618 r
= sd_bus_message_close_container(reply
);
623 const char *signature
= NULL
;
626 if (c
->vtable
->type
!= _SD_BUS_VTABLE_WRITABLE_PROPERTY
)
627 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_PROPERTY_READ_ONLY
, "Property '%s' is not writable.", c
->member
);
629 /* Avoid that we call the set routine more than once
630 * if the processing of this message got restarted
631 * because the node tree changed. */
632 if (c
->last_iteration
== bus
->iteration_counter
)
635 c
->last_iteration
= bus
->iteration_counter
;
637 r
= sd_bus_message_peek_type(m
, &type
, &signature
);
642 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INVALID_SIGNATURE
,
643 "Incorrect signature when setting property '%s', expected 'v', got '%c'.",
645 if (!streq(strempty(signature
), strempty(c
->vtable
->x
.property
.signature
)))
646 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INVALID_ARGS
,
647 "Incorrect parameters for property '%s', expected '%s', got '%s'.",
648 c
->member
, strempty(c
->vtable
->x
.property
.signature
), strempty(signature
));
650 r
= sd_bus_message_enter_container(m
, 'v', c
->vtable
->x
.property
.signature
);
654 r
= check_access(bus
, m
, c
, &error
);
656 return bus_maybe_reply_error(m
, r
, &error
);
658 r
= invoke_property_set(bus
, slot
, c
->vtable
, m
->path
, c
->interface
, c
->member
, m
, u
, &error
);
660 return bus_maybe_reply_error(m
, r
, &error
);
662 if (bus
->nodes_modified
)
665 r
= sd_bus_message_exit_container(m
);
670 r
= sd_bus_send(bus
, reply
, NULL
);
677 static int vtable_append_one_property(
679 sd_bus_message
*reply
,
681 struct node_vtable
*c
,
682 const sd_bus_vtable
*v
,
684 sd_bus_error
*error
) {
695 r
= sd_bus_message_open_container(reply
, 'e', "sv");
699 r
= sd_bus_message_append(reply
, "s", v
->x
.property
.member
);
703 r
= sd_bus_message_open_container(reply
, 'v', v
->x
.property
.signature
);
707 slot
= container_of(c
, sd_bus_slot
, node_vtable
);
709 r
= invoke_property_get(bus
, slot
, v
, path
, c
->interface
, v
->x
.property
.member
, reply
, vtable_property_convert_userdata(v
, userdata
), error
);
712 if (bus
->nodes_modified
)
715 r
= sd_bus_message_close_container(reply
);
719 r
= sd_bus_message_close_container(reply
);
726 static int vtable_append_all_properties(
728 sd_bus_message
*reply
,
730 struct node_vtable
*c
,
732 sd_bus_error
*error
) {
734 const sd_bus_vtable
*v
;
742 if (c
->vtable
[0].flags
& SD_BUS_VTABLE_HIDDEN
)
746 for (v
= bus_vtable_next(c
->vtable
, v
); v
->type
!= _SD_BUS_VTABLE_END
; v
= bus_vtable_next(c
->vtable
, v
)) {
747 if (!IN_SET(v
->type
, _SD_BUS_VTABLE_PROPERTY
, _SD_BUS_VTABLE_WRITABLE_PROPERTY
))
750 if (v
->flags
& SD_BUS_VTABLE_HIDDEN
)
753 if (v
->flags
& SD_BUS_VTABLE_PROPERTY_EXPLICIT
)
756 r
= vtable_append_one_property(bus
, reply
, path
, c
, v
, userdata
, error
);
759 if (bus
->nodes_modified
)
766 static int property_get_all_callbacks_run(
769 struct node_vtable
*first
,
770 bool require_fallback
,
772 bool *found_object
) {
774 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
775 struct node_vtable
*c
;
776 bool found_interface
;
781 assert(found_object
);
783 r
= sd_bus_message_new_method_return(m
, &reply
);
787 r
= sd_bus_message_open_container(reply
, 'a', "{sv}");
791 found_interface
= !iface
||
792 streq(iface
, "org.freedesktop.DBus.Properties") ||
793 streq(iface
, "org.freedesktop.DBus.Peer") ||
794 streq(iface
, "org.freedesktop.DBus.Introspectable");
796 LIST_FOREACH(vtables
, c
, first
) {
797 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
800 if (require_fallback
&& !c
->is_fallback
)
803 r
= node_vtable_get_userdata(bus
, m
->path
, c
, &u
, &error
);
805 return bus_maybe_reply_error(m
, r
, &error
);
806 if (bus
->nodes_modified
)
811 *found_object
= true;
813 if (iface
&& !streq(c
->interface
, iface
))
815 found_interface
= true;
817 r
= vtable_append_all_properties(bus
, reply
, m
->path
, c
, u
, &error
);
819 return bus_maybe_reply_error(m
, r
, &error
);
820 if (bus
->nodes_modified
)
827 if (!found_interface
) {
828 r
= sd_bus_reply_method_errorf(
830 SD_BUS_ERROR_UNKNOWN_INTERFACE
,
831 "Unknown interface '%s'.", iface
);
838 r
= sd_bus_message_close_container(reply
);
842 r
= sd_bus_send(bus
, reply
, NULL
);
849 static int bus_node_exists(
853 bool require_fallback
) {
855 struct node_vtable
*c
;
856 struct node_callback
*k
;
863 /* Tests if there's anything attached directly to this node
864 * for the specified path */
866 if (!require_fallback
&& (n
->enumerators
|| n
->object_managers
))
869 LIST_FOREACH(callbacks
, k
, n
->callbacks
) {
870 if (require_fallback
&& !k
->is_fallback
)
876 LIST_FOREACH(vtables
, c
, n
->vtables
) {
877 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
879 if (require_fallback
&& !c
->is_fallback
)
882 r
= node_vtable_get_userdata(bus
, path
, c
, NULL
, &error
);
885 if (bus
->nodes_modified
)
896 bool require_fallback
,
897 bool ignore_nodes_modified
,
900 sd_bus_error
*error
) {
902 _cleanup_set_free_free_ Set
*s
= NULL
;
903 const char *previous_interface
= NULL
;
904 _cleanup_(introspect_free
) struct introspect intro
= {};
905 struct node_vtable
*c
;
910 n
= hashmap_get(bus
->nodes
, path
);
915 r
= get_child_nodes(bus
, path
, n
, 0, &s
, error
);
918 if (bus
->nodes_modified
&& !ignore_nodes_modified
)
921 r
= introspect_begin(&intro
, bus
->trusted
);
925 r
= introspect_write_default_interfaces(&intro
, !require_fallback
&& n
->object_managers
);
929 empty
= set_isempty(s
);
931 LIST_FOREACH(vtables
, c
, n
->vtables
) {
932 if (require_fallback
&& !c
->is_fallback
)
935 r
= node_vtable_get_userdata(bus
, path
, c
, NULL
, error
);
938 if (bus
->nodes_modified
&& !ignore_nodes_modified
)
945 if (c
->vtable
[0].flags
& SD_BUS_VTABLE_HIDDEN
)
948 if (!streq_ptr(previous_interface
, c
->interface
)) {
949 if (previous_interface
)
950 fputs(" </interface>\n", intro
.f
);
952 fprintf(intro
.f
, " <interface name=\"%s\">\n", c
->interface
);
955 r
= introspect_write_interface(&intro
, c
->vtable
);
959 previous_interface
= c
->interface
;
962 if (previous_interface
)
963 fputs(" </interface>\n", intro
.f
);
966 /* Nothing?, let's see if we exist at all, and if not
967 * refuse to do anything */
968 r
= bus_node_exists(bus
, n
, path
, require_fallback
);
971 if (bus
->nodes_modified
&& !ignore_nodes_modified
)
976 *found_object
= true;
978 r
= introspect_write_child_nodes(&intro
, s
, path
);
982 r
= introspect_finish(&intro
, ret
);
989 static int process_introspect(
993 bool require_fallback
,
994 bool *found_object
) {
996 _cleanup_free_
char *s
= NULL
;
997 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
998 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1004 assert(found_object
);
1006 r
= introspect_path(bus
, m
->path
, n
, require_fallback
, false, found_object
, &s
, &error
);
1008 return bus_maybe_reply_error(m
, r
, &error
);
1010 /* nodes_modified == true */
1013 r
= sd_bus_message_new_method_return(m
, &reply
);
1017 r
= sd_bus_message_append(reply
, "s", s
);
1021 r
= sd_bus_send(bus
, reply
, NULL
);
1028 static int object_manager_serialize_path(
1030 sd_bus_message
*reply
,
1033 bool require_fallback
,
1034 sd_bus_error
*error
) {
1036 const char *previous_interface
= NULL
;
1037 bool found_something
= false;
1038 struct node_vtable
*i
;
1048 n
= hashmap_get(bus
->nodes
, prefix
);
1052 LIST_FOREACH(vtables
, i
, n
->vtables
) {
1055 if (require_fallback
&& !i
->is_fallback
)
1058 r
= node_vtable_get_userdata(bus
, path
, i
, &u
, error
);
1061 if (bus
->nodes_modified
)
1066 if (!found_something
) {
1068 /* Open the object part */
1070 r
= sd_bus_message_open_container(reply
, 'e', "oa{sa{sv}}");
1074 r
= sd_bus_message_append(reply
, "o", path
);
1078 r
= sd_bus_message_open_container(reply
, 'a', "{sa{sv}}");
1082 r
= sd_bus_message_append(reply
, "{sa{sv}}", "org.freedesktop.DBus.Peer", 0);
1086 r
= sd_bus_message_append(reply
, "{sa{sv}}", "org.freedesktop.DBus.Introspectable", 0);
1090 r
= sd_bus_message_append(reply
, "{sa{sv}}", "org.freedesktop.DBus.Properties", 0);
1094 r
= sd_bus_message_append(reply
, "{sa{sv}}", "org.freedesktop.DBus.ObjectManager", 0);
1098 found_something
= true;
1101 if (!streq_ptr(previous_interface
, i
->interface
)) {
1103 /* Maybe close the previous interface part */
1105 if (previous_interface
) {
1106 r
= sd_bus_message_close_container(reply
);
1110 r
= sd_bus_message_close_container(reply
);
1115 /* Open the new interface part */
1117 r
= sd_bus_message_open_container(reply
, 'e', "sa{sv}");
1121 r
= sd_bus_message_append(reply
, "s", i
->interface
);
1125 r
= sd_bus_message_open_container(reply
, 'a', "{sv}");
1130 r
= vtable_append_all_properties(bus
, reply
, path
, i
, u
, error
);
1133 if (bus
->nodes_modified
)
1136 previous_interface
= i
->interface
;
1139 if (previous_interface
) {
1140 r
= sd_bus_message_close_container(reply
);
1144 r
= sd_bus_message_close_container(reply
);
1149 if (found_something
) {
1150 r
= sd_bus_message_close_container(reply
);
1154 r
= sd_bus_message_close_container(reply
);
1162 static int object_manager_serialize_path_and_fallbacks(
1164 sd_bus_message
*reply
,
1166 sd_bus_error
*error
) {
1168 _cleanup_free_
char *prefix
= NULL
;
1177 /* First, add all vtables registered for this path */
1178 r
= object_manager_serialize_path(bus
, reply
, path
, path
, false, error
);
1181 if (bus
->nodes_modified
)
1184 /* Second, add fallback vtables registered for any of the prefixes */
1186 assert(pl
<= BUS_PATH_SIZE_MAX
);
1187 prefix
= new(char, pl
+ 1);
1191 OBJECT_PATH_FOREACH_PREFIX(prefix
, path
) {
1192 r
= object_manager_serialize_path(bus
, reply
, prefix
, path
, true, error
);
1195 if (bus
->nodes_modified
)
1202 static int process_get_managed_objects(
1206 bool require_fallback
,
1207 bool *found_object
) {
1209 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1210 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1211 _cleanup_set_free_free_ Set
*s
= NULL
;
1219 assert(found_object
);
1221 /* Spec says, GetManagedObjects() is only implemented on the root of a
1222 * sub-tree. Therefore, we require a registered object-manager on
1223 * exactly the queried path, otherwise, we refuse to respond. */
1225 if (require_fallback
|| !n
->object_managers
)
1228 r
= get_child_nodes(bus
, m
->path
, n
, CHILDREN_RECURSIVE
, &s
, &error
);
1230 return bus_maybe_reply_error(m
, r
, &error
);
1231 if (bus
->nodes_modified
)
1234 r
= sd_bus_message_new_method_return(m
, &reply
);
1238 r
= sd_bus_message_open_container(reply
, 'a', "{oa{sa{sv}}}");
1242 SET_FOREACH(path
, s
, i
) {
1243 r
= object_manager_serialize_path_and_fallbacks(bus
, reply
, path
, &error
);
1245 return bus_maybe_reply_error(m
, r
, &error
);
1247 if (bus
->nodes_modified
)
1251 r
= sd_bus_message_close_container(reply
);
1255 r
= sd_bus_send(bus
, reply
, NULL
);
1262 static int object_find_and_run(
1266 bool require_fallback
,
1267 bool *found_object
) {
1270 struct vtable_member vtable_key
, *v
;
1276 assert(found_object
);
1278 n
= hashmap_get(bus
->nodes
, p
);
1282 /* First, try object callbacks */
1283 r
= node_callbacks_run(bus
, m
, n
->callbacks
, require_fallback
, found_object
);
1286 if (bus
->nodes_modified
)
1289 if (!m
->interface
|| !m
->member
)
1292 /* Then, look for a known method */
1293 vtable_key
.path
= (char*) p
;
1294 vtable_key
.interface
= m
->interface
;
1295 vtable_key
.member
= m
->member
;
1297 v
= hashmap_get(bus
->vtable_methods
, &vtable_key
);
1299 r
= method_callbacks_run(bus
, m
, v
, require_fallback
, found_object
);
1302 if (bus
->nodes_modified
)
1306 /* Then, look for a known property */
1307 if (streq(m
->interface
, "org.freedesktop.DBus.Properties")) {
1310 get
= streq(m
->member
, "Get");
1312 if (get
|| streq(m
->member
, "Set")) {
1314 r
= sd_bus_message_rewind(m
, true);
1318 vtable_key
.path
= (char*) p
;
1320 r
= sd_bus_message_read(m
, "ss", &vtable_key
.interface
, &vtable_key
.member
);
1322 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INVALID_ARGS
, "Expected interface and member parameters");
1324 v
= hashmap_get(bus
->vtable_properties
, &vtable_key
);
1326 r
= property_get_set_callbacks_run(bus
, m
, v
, require_fallback
, get
, found_object
);
1331 } else if (streq(m
->member
, "GetAll")) {
1334 r
= sd_bus_message_rewind(m
, true);
1338 r
= sd_bus_message_read(m
, "s", &iface
);
1340 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INVALID_ARGS
, "Expected interface parameter");
1345 r
= property_get_all_callbacks_run(bus
, m
, n
->vtables
, require_fallback
, iface
, found_object
);
1350 } else if (sd_bus_message_is_method_call(m
, "org.freedesktop.DBus.Introspectable", "Introspect")) {
1352 if (!isempty(sd_bus_message_get_signature(m
, true)))
1353 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INVALID_ARGS
, "Expected no parameters");
1355 r
= process_introspect(bus
, m
, n
, require_fallback
, found_object
);
1359 } else if (sd_bus_message_is_method_call(m
, "org.freedesktop.DBus.ObjectManager", "GetManagedObjects")) {
1361 if (!isempty(sd_bus_message_get_signature(m
, true)))
1362 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INVALID_ARGS
, "Expected no parameters");
1364 r
= process_get_managed_objects(bus
, m
, n
, require_fallback
, found_object
);
1369 if (bus
->nodes_modified
)
1372 if (!*found_object
) {
1373 r
= bus_node_exists(bus
, n
, m
->path
, require_fallback
);
1375 return bus_maybe_reply_error(m
, r
, NULL
);
1376 if (bus
->nodes_modified
)
1379 *found_object
= true;
1385 int bus_process_object(sd_bus
*bus
, sd_bus_message
*m
) {
1386 _cleanup_free_
char *prefix
= NULL
;
1389 bool found_object
= false;
1394 if (bus
->is_monitor
)
1397 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
1400 if (hashmap_isempty(bus
->nodes
))
1403 /* Never respond to broadcast messages */
1404 if (bus
->bus_client
&& !m
->destination
)
1410 pl
= strlen(m
->path
);
1411 assert(pl
<= BUS_PATH_SIZE_MAX
);
1412 prefix
= new(char, pl
+ 1);
1417 bus
->nodes_modified
= false;
1419 r
= object_find_and_run(bus
, m
, m
->path
, false, &found_object
);
1423 /* Look for fallback prefixes */
1424 OBJECT_PATH_FOREACH_PREFIX(prefix
, m
->path
) {
1426 if (bus
->nodes_modified
)
1429 r
= object_find_and_run(bus
, m
, prefix
, true, &found_object
);
1434 } while (bus
->nodes_modified
);
1439 if (sd_bus_message_is_method_call(m
, "org.freedesktop.DBus.Properties", "Get") ||
1440 sd_bus_message_is_method_call(m
, "org.freedesktop.DBus.Properties", "Set"))
1441 r
= sd_bus_reply_method_errorf(
1443 SD_BUS_ERROR_UNKNOWN_PROPERTY
,
1444 "Unknown property or interface.");
1446 r
= sd_bus_reply_method_errorf(
1448 SD_BUS_ERROR_UNKNOWN_METHOD
,
1449 "Unknown method '%s' or interface '%s'.", m
->member
, m
->interface
);
1457 static struct node
*bus_node_allocate(sd_bus
*bus
, const char *path
) {
1458 struct node
*n
, *parent
;
1460 _cleanup_free_
char *s
= NULL
;
1466 assert(path
[0] == '/');
1468 n
= hashmap_get(bus
->nodes
, path
);
1472 r
= hashmap_ensure_allocated(&bus
->nodes
, &string_hash_ops
);
1480 if (streq(path
, "/"))
1483 e
= strrchr(path
, '/');
1486 p
= strndupa(path
, MAX(1, e
- path
));
1488 parent
= bus_node_allocate(bus
, p
);
1493 n
= new0(struct node
, 1);
1498 n
->path
= TAKE_PTR(s
);
1500 r
= hashmap_put(bus
->nodes
, n
->path
, n
);
1507 LIST_PREPEND(siblings
, parent
->child
, n
);
1512 void bus_node_gc(sd_bus
*b
, struct node
*n
) {
1525 assert_se(hashmap_remove(b
->nodes
, n
->path
) == n
);
1528 LIST_REMOVE(siblings
, n
->parent
->child
, n
);
1531 bus_node_gc(b
, n
->parent
);
1535 static int bus_find_parent_object_manager(sd_bus
*bus
, struct node
**out
, const char *path
) {
1541 n
= hashmap_get(bus
->nodes
, path
);
1543 _cleanup_free_
char *prefix
= NULL
;
1547 assert(pl
<= BUS_PATH_SIZE_MAX
);
1548 prefix
= new(char, pl
+ 1);
1552 OBJECT_PATH_FOREACH_PREFIX(prefix
, path
) {
1553 n
= hashmap_get(bus
->nodes
, prefix
);
1559 while (n
&& !n
->object_managers
)
1567 static int bus_add_object(
1572 sd_bus_message_handler_t callback
,
1579 assert_return(bus
, -EINVAL
);
1580 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
1581 assert_return(object_path_is_valid(path
), -EINVAL
);
1582 assert_return(callback
, -EINVAL
);
1583 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1585 n
= bus_node_allocate(bus
, path
);
1589 s
= bus_slot_allocate(bus
, !slot
, BUS_NODE_CALLBACK
, sizeof(struct node_callback
), userdata
);
1595 s
->node_callback
.callback
= callback
;
1596 s
->node_callback
.is_fallback
= fallback
;
1598 s
->node_callback
.node
= n
;
1599 LIST_PREPEND(callbacks
, n
->callbacks
, &s
->node_callback
);
1600 bus
->nodes_modified
= true;
1608 sd_bus_slot_unref(s
);
1609 bus_node_gc(bus
, n
);
1614 _public_
int sd_bus_add_object(
1618 sd_bus_message_handler_t callback
,
1621 return bus_add_object(bus
, slot
, false, path
, callback
, userdata
);
1624 _public_
int sd_bus_add_fallback(
1628 sd_bus_message_handler_t callback
,
1631 return bus_add_object(bus
, slot
, true, prefix
, callback
, userdata
);
1634 static void vtable_member_hash_func(const struct vtable_member
*m
, struct siphash
*state
) {
1637 string_hash_func(m
->path
, state
);
1638 string_hash_func(m
->interface
, state
);
1639 string_hash_func(m
->member
, state
);
1642 static int vtable_member_compare_func(const struct vtable_member
*x
, const struct vtable_member
*y
) {
1648 r
= strcmp(x
->path
, y
->path
);
1652 r
= strcmp(x
->interface
, y
->interface
);
1656 return strcmp(x
->member
, y
->member
);
1659 DEFINE_PRIVATE_HASH_OPS(vtable_member_hash_ops
, struct vtable_member
, vtable_member_hash_func
, vtable_member_compare_func
);
1662 NAMES_FIRST_PART
= 1 << 0, /* first part of argument name list (input names). It is reset by names_are_valid() */
1663 NAMES_PRESENT
= 1 << 1, /* at least one argument name is present, so the names will checked.
1664 This flag is set and used internally by names_are_valid(), but needs to be stored across calls for 2-parts list */
1665 NAMES_SINGLE_PART
= 1 << 2, /* argument name list consisting of a single part */
1668 static bool names_are_valid(const char *signature
, const char **names
, names_flags
*flags
) {
1671 if ((*flags
& NAMES_FIRST_PART
|| *flags
& NAMES_SINGLE_PART
) && **names
!= '\0')
1672 *flags
|= NAMES_PRESENT
;
1674 for (;*flags
& NAMES_PRESENT
;) {
1680 r
= signature_element_length(signature
, &l
);
1684 if (**names
!= '\0') {
1685 if (!member_name_is_valid(*names
))
1687 *names
+= strlen(*names
) + 1;
1688 } else if (*flags
& NAMES_PRESENT
)
1693 /* let's check if there are more argument names specified than the signature allows */
1694 if (*flags
& NAMES_PRESENT
&& **names
!= '\0' && !(*flags
& NAMES_FIRST_PART
))
1696 *flags
&= ~NAMES_FIRST_PART
;
1700 /* the current version of this struct is defined in sd-bus-vtable.h, but we need to list here the historical versions
1701 to make sure the calling code is compatible with one of these */
1702 struct sd_bus_vtable_221
{
1707 size_t element_size
;
1711 const char *signature
;
1713 sd_bus_message_handler_t handler
;
1718 const char *signature
;
1722 const char *signature
;
1723 sd_bus_property_get_t get
;
1724 sd_bus_property_set_t set
;
1729 /* Structure size up to v241 */
1730 #define VTABLE_ELEMENT_SIZE_221 sizeof(struct sd_bus_vtable_221)
1732 /* Size of the structure when "features" field was added. If the structure definition is augmented, a copy of
1733 * the structure definition will need to be made (similarly to the sd_bus_vtable_221 above), and this
1734 * definition updated to refer to it. */
1735 #define VTABLE_ELEMENT_SIZE_242 sizeof(struct sd_bus_vtable)
1737 static int vtable_features(const sd_bus_vtable
*vtable
) {
1738 if (vtable
[0].x
.start
.element_size
< VTABLE_ELEMENT_SIZE_242
||
1739 !vtable
[0].x
.start
.vtable_format_reference
)
1741 return vtable
[0].x
.start
.features
;
1744 bool bus_vtable_has_names(const sd_bus_vtable
*vtable
) {
1745 return vtable_features(vtable
) & _SD_BUS_VTABLE_PARAM_NAMES
;
1748 const sd_bus_vtable
* bus_vtable_next(const sd_bus_vtable
*vtable
, const sd_bus_vtable
*v
) {
1749 return (const sd_bus_vtable
*) ((char*) v
+ vtable
[0].x
.start
.element_size
);
1752 static int add_object_vtable_internal(
1756 const char *interface
,
1757 const sd_bus_vtable
*vtable
,
1759 sd_bus_object_find_t find
,
1762 sd_bus_slot
*s
= NULL
;
1763 struct node_vtable
*i
, *existing
= NULL
;
1764 const sd_bus_vtable
*v
;
1767 const char *names
= "";
1770 assert_return(bus
, -EINVAL
);
1771 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
1772 assert_return(object_path_is_valid(path
), -EINVAL
);
1773 assert_return(interface_name_is_valid(interface
), -EINVAL
);
1774 assert_return(vtable
, -EINVAL
);
1775 assert_return(vtable
[0].type
== _SD_BUS_VTABLE_START
, -EINVAL
);
1776 assert_return(vtable
[0].x
.start
.element_size
== VTABLE_ELEMENT_SIZE_221
||
1777 vtable
[0].x
.start
.element_size
>= VTABLE_ELEMENT_SIZE_242
,
1779 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1780 assert_return(!streq(interface
, "org.freedesktop.DBus.Properties") &&
1781 !streq(interface
, "org.freedesktop.DBus.Introspectable") &&
1782 !streq(interface
, "org.freedesktop.DBus.Peer") &&
1783 !streq(interface
, "org.freedesktop.DBus.ObjectManager"), -EINVAL
);
1785 r
= hashmap_ensure_allocated(&bus
->vtable_methods
, &vtable_member_hash_ops
);
1789 r
= hashmap_ensure_allocated(&bus
->vtable_properties
, &vtable_member_hash_ops
);
1793 n
= bus_node_allocate(bus
, path
);
1797 LIST_FOREACH(vtables
, i
, n
->vtables
) {
1798 if (i
->is_fallback
!= fallback
) {
1803 if (streq(i
->interface
, interface
)) {
1805 if (i
->vtable
== vtable
) {
1814 s
= bus_slot_allocate(bus
, !slot
, BUS_NODE_VTABLE
, sizeof(struct node_vtable
), userdata
);
1820 s
->node_vtable
.is_fallback
= fallback
;
1821 s
->node_vtable
.vtable
= vtable
;
1822 s
->node_vtable
.find
= find
;
1824 s
->node_vtable
.interface
= strdup(interface
);
1825 if (!s
->node_vtable
.interface
) {
1830 v
= s
->node_vtable
.vtable
;
1831 for (v
= bus_vtable_next(vtable
, v
); v
->type
!= _SD_BUS_VTABLE_END
; v
= bus_vtable_next(vtable
, v
)) {
1835 case _SD_BUS_VTABLE_METHOD
: {
1836 struct vtable_member
*m
;
1837 nf
= NAMES_FIRST_PART
;
1839 if (bus_vtable_has_names(vtable
))
1840 names
= strempty(v
->x
.method
.names
);
1842 if (!member_name_is_valid(v
->x
.method
.member
) ||
1843 !signature_is_valid(strempty(v
->x
.method
.signature
), false) ||
1844 !signature_is_valid(strempty(v
->x
.method
.result
), false) ||
1845 !names_are_valid(strempty(v
->x
.method
.signature
), &names
, &nf
) ||
1846 !names_are_valid(strempty(v
->x
.method
.result
), &names
, &nf
) ||
1847 !(v
->x
.method
.handler
|| (isempty(v
->x
.method
.signature
) && isempty(v
->x
.method
.result
))) ||
1848 v
->flags
& (SD_BUS_VTABLE_PROPERTY_CONST
|SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
|SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION
)) {
1853 m
= new0(struct vtable_member
, 1);
1859 m
->parent
= &s
->node_vtable
;
1861 m
->interface
= s
->node_vtable
.interface
;
1862 m
->member
= v
->x
.method
.member
;
1865 r
= hashmap_put(bus
->vtable_methods
, m
, m
);
1874 case _SD_BUS_VTABLE_WRITABLE_PROPERTY
:
1876 if (!(v
->x
.property
.set
|| bus_type_is_basic(v
->x
.property
.signature
[0]))) {
1881 if (v
->flags
& SD_BUS_VTABLE_PROPERTY_CONST
) {
1887 case _SD_BUS_VTABLE_PROPERTY
: {
1888 struct vtable_member
*m
;
1890 if (!member_name_is_valid(v
->x
.property
.member
) ||
1891 !signature_is_single(v
->x
.property
.signature
, false) ||
1892 !(v
->x
.property
.get
|| bus_type_is_basic(v
->x
.property
.signature
[0]) || streq(v
->x
.property
.signature
, "as")) ||
1893 (v
->flags
& SD_BUS_VTABLE_METHOD_NO_REPLY
) ||
1894 (!!(v
->flags
& SD_BUS_VTABLE_PROPERTY_CONST
) + !!(v
->flags
& SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
) + !!(v
->flags
& SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION
)) > 1 ||
1895 ((v
->flags
& SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
) && (v
->flags
& SD_BUS_VTABLE_PROPERTY_EXPLICIT
)) ||
1896 (v
->flags
& SD_BUS_VTABLE_UNPRIVILEGED
&& v
->type
== _SD_BUS_VTABLE_PROPERTY
)) {
1901 m
= new0(struct vtable_member
, 1);
1907 m
->parent
= &s
->node_vtable
;
1909 m
->interface
= s
->node_vtable
.interface
;
1910 m
->member
= v
->x
.property
.member
;
1913 r
= hashmap_put(bus
->vtable_properties
, m
, m
);
1922 case _SD_BUS_VTABLE_SIGNAL
:
1923 nf
= NAMES_SINGLE_PART
;
1925 if (bus_vtable_has_names(vtable
))
1926 names
= strempty(v
->x
.signal
.names
);
1928 if (!member_name_is_valid(v
->x
.signal
.member
) ||
1929 !signature_is_valid(strempty(v
->x
.signal
.signature
), false) ||
1930 !names_are_valid(strempty(v
->x
.signal
.signature
), &names
, &nf
) ||
1931 v
->flags
& SD_BUS_VTABLE_UNPRIVILEGED
) {
1944 s
->node_vtable
.node
= n
;
1945 LIST_INSERT_AFTER(vtables
, n
->vtables
, existing
, &s
->node_vtable
);
1946 bus
->nodes_modified
= true;
1954 sd_bus_slot_unref(s
);
1955 bus_node_gc(bus
, n
);
1960 /* This symbol exists solely to tell the linker that the "new" vtable format is used. */
1961 _public_
const unsigned sd_bus_object_vtable_format
= 242;
1963 _public_
int sd_bus_add_object_vtable(
1967 const char *interface
,
1968 const sd_bus_vtable
*vtable
,
1971 return add_object_vtable_internal(bus
, slot
, path
, interface
, vtable
, false, NULL
, userdata
);
1974 _public_
int sd_bus_add_fallback_vtable(
1978 const char *interface
,
1979 const sd_bus_vtable
*vtable
,
1980 sd_bus_object_find_t find
,
1983 return add_object_vtable_internal(bus
, slot
, prefix
, interface
, vtable
, true, find
, userdata
);
1986 _public_
int sd_bus_add_node_enumerator(
1990 sd_bus_node_enumerator_t callback
,
1997 assert_return(bus
, -EINVAL
);
1998 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
1999 assert_return(object_path_is_valid(path
), -EINVAL
);
2000 assert_return(callback
, -EINVAL
);
2001 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2003 n
= bus_node_allocate(bus
, path
);
2007 s
= bus_slot_allocate(bus
, !slot
, BUS_NODE_ENUMERATOR
, sizeof(struct node_enumerator
), userdata
);
2013 s
->node_enumerator
.callback
= callback
;
2015 s
->node_enumerator
.node
= n
;
2016 LIST_PREPEND(enumerators
, n
->enumerators
, &s
->node_enumerator
);
2017 bus
->nodes_modified
= true;
2025 sd_bus_slot_unref(s
);
2026 bus_node_gc(bus
, n
);
2031 static int emit_properties_changed_on_interface(
2035 const char *interface
,
2036 bool require_fallback
,
2037 bool *found_interface
,
2040 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
2041 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2042 bool has_invalidating
= false, has_changing
= false;
2043 struct vtable_member key
= {};
2044 struct node_vtable
*c
;
2054 assert(found_interface
);
2056 n
= hashmap_get(bus
->nodes
, prefix
);
2060 r
= sd_bus_message_new_signal(bus
, &m
, path
, "org.freedesktop.DBus.Properties", "PropertiesChanged");
2064 r
= sd_bus_message_append(m
, "s", interface
);
2068 r
= sd_bus_message_open_container(m
, 'a', "{sv}");
2073 key
.interface
= interface
;
2075 LIST_FOREACH(vtables
, c
, n
->vtables
) {
2076 if (require_fallback
&& !c
->is_fallback
)
2079 if (!streq(c
->interface
, interface
))
2082 r
= node_vtable_get_userdata(bus
, path
, c
, &u
, &error
);
2085 if (bus
->nodes_modified
)
2090 *found_interface
= true;
2093 /* If the caller specified a list of
2094 * properties we include exactly those in the
2095 * PropertiesChanged message */
2097 STRV_FOREACH(property
, names
) {
2098 struct vtable_member
*v
;
2100 assert_return(member_name_is_valid(*property
), -EINVAL
);
2102 key
.member
= *property
;
2103 v
= hashmap_get(bus
->vtable_properties
, &key
);
2107 /* If there are two vtables for the same
2108 * interface, let's handle this property when
2109 * we come to that vtable. */
2113 assert_return(v
->vtable
->flags
& SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
||
2114 v
->vtable
->flags
& SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION
, -EDOM
);
2116 assert_return(!(v
->vtable
->flags
& SD_BUS_VTABLE_HIDDEN
), -EDOM
);
2118 if (v
->vtable
->flags
& SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION
) {
2119 has_invalidating
= true;
2123 has_changing
= true;
2125 r
= vtable_append_one_property(bus
, m
, m
->path
, c
, v
->vtable
, u
, &error
);
2128 if (bus
->nodes_modified
)
2132 const sd_bus_vtable
*v
;
2134 /* If the caller specified no properties list
2135 * we include all properties that are marked
2136 * as changing in the message. */
2139 for (v
= bus_vtable_next(c
->vtable
, v
); v
->type
!= _SD_BUS_VTABLE_END
; v
= bus_vtable_next(c
->vtable
, v
)) {
2140 if (!IN_SET(v
->type
, _SD_BUS_VTABLE_PROPERTY
, _SD_BUS_VTABLE_WRITABLE_PROPERTY
))
2143 if (v
->flags
& SD_BUS_VTABLE_HIDDEN
)
2146 if (v
->flags
& SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION
) {
2147 has_invalidating
= true;
2151 if (!(v
->flags
& SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
))
2154 has_changing
= true;
2156 r
= vtable_append_one_property(bus
, m
, m
->path
, c
, v
, u
, &error
);
2159 if (bus
->nodes_modified
)
2165 if (!has_invalidating
&& !has_changing
)
2168 r
= sd_bus_message_close_container(m
);
2172 r
= sd_bus_message_open_container(m
, 'a', "s");
2176 if (has_invalidating
) {
2177 LIST_FOREACH(vtables
, c
, n
->vtables
) {
2178 if (require_fallback
&& !c
->is_fallback
)
2181 if (!streq(c
->interface
, interface
))
2184 r
= node_vtable_get_userdata(bus
, path
, c
, &u
, &error
);
2187 if (bus
->nodes_modified
)
2193 STRV_FOREACH(property
, names
) {
2194 struct vtable_member
*v
;
2196 key
.member
= *property
;
2197 assert_se(v
= hashmap_get(bus
->vtable_properties
, &key
));
2198 assert(c
== v
->parent
);
2200 if (!(v
->vtable
->flags
& SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION
))
2203 r
= sd_bus_message_append(m
, "s", *property
);
2208 const sd_bus_vtable
*v
;
2211 for (v
= bus_vtable_next(c
->vtable
, v
); v
->type
!= _SD_BUS_VTABLE_END
; v
= bus_vtable_next(c
->vtable
, v
)) {
2212 if (!IN_SET(v
->type
, _SD_BUS_VTABLE_PROPERTY
, _SD_BUS_VTABLE_WRITABLE_PROPERTY
))
2215 if (v
->flags
& SD_BUS_VTABLE_HIDDEN
)
2218 if (!(v
->flags
& SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION
))
2221 r
= sd_bus_message_append(m
, "s", v
->x
.property
.member
);
2229 r
= sd_bus_message_close_container(m
);
2233 r
= sd_bus_send(bus
, m
, NULL
);
2240 _public_
int sd_bus_emit_properties_changed_strv(
2243 const char *interface
,
2246 _cleanup_free_
char *prefix
= NULL
;
2247 bool found_interface
= false;
2251 assert_return(bus
, -EINVAL
);
2252 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2253 assert_return(object_path_is_valid(path
), -EINVAL
);
2254 assert_return(interface_name_is_valid(interface
), -EINVAL
);
2255 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2257 if (!BUS_IS_OPEN(bus
->state
))
2260 /* A non-NULL but empty names list means nothing needs to be
2261 generated. A NULL list OTOH indicates that all properties
2262 that are set to EMITS_CHANGE or EMITS_INVALIDATION shall be
2263 included in the PropertiesChanged message. */
2264 if (names
&& names
[0] == NULL
)
2267 BUS_DONT_DESTROY(bus
);
2270 assert(pl
<= BUS_PATH_SIZE_MAX
);
2271 prefix
= new(char, pl
+ 1);
2276 bus
->nodes_modified
= false;
2278 r
= emit_properties_changed_on_interface(bus
, path
, path
, interface
, false, &found_interface
, names
);
2281 if (bus
->nodes_modified
)
2284 OBJECT_PATH_FOREACH_PREFIX(prefix
, path
) {
2285 r
= emit_properties_changed_on_interface(bus
, prefix
, path
, interface
, true, &found_interface
, names
);
2288 if (bus
->nodes_modified
)
2292 } while (bus
->nodes_modified
);
2294 return found_interface
? 0 : -ENOENT
;
2297 _public_
int sd_bus_emit_properties_changed(
2300 const char *interface
,
2301 const char *name
, ...) {
2305 assert_return(bus
, -EINVAL
);
2306 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2307 assert_return(object_path_is_valid(path
), -EINVAL
);
2308 assert_return(interface_name_is_valid(interface
), -EINVAL
);
2309 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2311 if (!BUS_IS_OPEN(bus
->state
))
2317 names
= strv_from_stdarg_alloca(name
);
2319 return sd_bus_emit_properties_changed_strv(bus
, path
, interface
, names
);
2322 static int object_added_append_all_prefix(
2328 bool require_fallback
) {
2330 const char *previous_interface
= NULL
;
2331 struct node_vtable
*c
;
2341 n
= hashmap_get(bus
->nodes
, prefix
);
2345 LIST_FOREACH(vtables
, c
, n
->vtables
) {
2346 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
2349 if (require_fallback
&& !c
->is_fallback
)
2352 r
= node_vtable_get_userdata(bus
, path
, c
, &u
, &error
);
2355 if (bus
->nodes_modified
)
2360 if (!streq_ptr(c
->interface
, previous_interface
)) {
2361 /* If a child-node already handled this interface, we
2362 * skip it on any of its parents. The child vtables
2363 * always fully override any conflicting vtables of
2364 * any parent node. */
2365 if (set_get(s
, c
->interface
))
2368 r
= set_put(s
, c
->interface
);
2372 if (previous_interface
) {
2373 r
= sd_bus_message_close_container(m
);
2376 r
= sd_bus_message_close_container(m
);
2381 r
= sd_bus_message_open_container(m
, 'e', "sa{sv}");
2384 r
= sd_bus_message_append(m
, "s", c
->interface
);
2387 r
= sd_bus_message_open_container(m
, 'a', "{sv}");
2391 previous_interface
= c
->interface
;
2394 r
= vtable_append_all_properties(bus
, m
, path
, c
, u
, &error
);
2397 if (bus
->nodes_modified
)
2401 if (previous_interface
) {
2402 r
= sd_bus_message_close_container(m
);
2405 r
= sd_bus_message_close_container(m
);
2413 static int object_added_append_all(sd_bus
*bus
, sd_bus_message
*m
, const char *path
) {
2414 _cleanup_set_free_ Set
*s
= NULL
;
2415 _cleanup_free_
char *prefix
= NULL
;
2424 * This appends all interfaces registered on path @path. We first add
2425 * the builtin interfaces, which are always available and handled by
2426 * sd-bus. Then, we add all interfaces registered on the exact node,
2427 * followed by all fallback interfaces registered on any parent prefix.
2429 * If an interface is registered multiple times on the same node with
2430 * different vtables, we merge all the properties across all vtables.
2431 * However, if a child node has the same interface registered as one of
2432 * its parent nodes has as fallback, we make the child overwrite the
2433 * parent instead of extending it. Therefore, we keep a "Set" of all
2434 * handled interfaces during parent traversal, so we skip interfaces on
2435 * a parent that were overwritten by a child.
2438 s
= set_new(&string_hash_ops
);
2442 r
= sd_bus_message_append(m
, "{sa{sv}}", "org.freedesktop.DBus.Peer", 0);
2445 r
= sd_bus_message_append(m
, "{sa{sv}}", "org.freedesktop.DBus.Introspectable", 0);
2448 r
= sd_bus_message_append(m
, "{sa{sv}}", "org.freedesktop.DBus.Properties", 0);
2451 r
= sd_bus_message_append(m
, "{sa{sv}}", "org.freedesktop.DBus.ObjectManager", 0);
2455 r
= object_added_append_all_prefix(bus
, m
, s
, path
, path
, false);
2458 if (bus
->nodes_modified
)
2462 assert(pl
<= BUS_PATH_SIZE_MAX
);
2463 prefix
= new(char, pl
+ 1);
2467 OBJECT_PATH_FOREACH_PREFIX(prefix
, path
) {
2468 r
= object_added_append_all_prefix(bus
, m
, s
, prefix
, path
, true);
2471 if (bus
->nodes_modified
)
2478 _public_
int sd_bus_emit_object_added(sd_bus
*bus
, const char *path
) {
2479 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2480 struct node
*object_manager
;
2484 * This emits an InterfacesAdded signal on the given path, by iterating
2485 * all registered vtables and fallback vtables on the path. All
2486 * properties are queried and included in the signal.
2487 * This call is equivalent to sd_bus_emit_interfaces_added() with an
2488 * explicit list of registered interfaces. However, unlike
2489 * interfaces_added(), this call can figure out the list of supported
2490 * interfaces itself. Furthermore, it properly adds the builtin
2491 * org.freedesktop.DBus.* interfaces.
2494 assert_return(bus
, -EINVAL
);
2495 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2496 assert_return(object_path_is_valid(path
), -EINVAL
);
2497 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2499 if (!BUS_IS_OPEN(bus
->state
))
2502 r
= bus_find_parent_object_manager(bus
, &object_manager
, path
);
2508 BUS_DONT_DESTROY(bus
);
2511 bus
->nodes_modified
= false;
2512 m
= sd_bus_message_unref(m
);
2514 r
= sd_bus_message_new_signal(bus
, &m
, object_manager
->path
, "org.freedesktop.DBus.ObjectManager", "InterfacesAdded");
2518 r
= sd_bus_message_append_basic(m
, 'o', path
);
2522 r
= sd_bus_message_open_container(m
, 'a', "{sa{sv}}");
2526 r
= object_added_append_all(bus
, m
, path
);
2530 if (bus
->nodes_modified
)
2533 r
= sd_bus_message_close_container(m
);
2537 } while (bus
->nodes_modified
);
2539 return sd_bus_send(bus
, m
, NULL
);
2542 static int object_removed_append_all_prefix(
2548 bool require_fallback
) {
2550 const char *previous_interface
= NULL
;
2551 struct node_vtable
*c
;
2561 n
= hashmap_get(bus
->nodes
, prefix
);
2565 LIST_FOREACH(vtables
, c
, n
->vtables
) {
2566 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
2569 if (require_fallback
&& !c
->is_fallback
)
2571 if (streq_ptr(c
->interface
, previous_interface
))
2574 /* If a child-node already handled this interface, we
2575 * skip it on any of its parents. The child vtables
2576 * always fully override any conflicting vtables of
2577 * any parent node. */
2578 if (set_get(s
, c
->interface
))
2581 r
= node_vtable_get_userdata(bus
, path
, c
, &u
, &error
);
2584 if (bus
->nodes_modified
)
2589 r
= set_put(s
, c
->interface
);
2593 r
= sd_bus_message_append(m
, "s", c
->interface
);
2597 previous_interface
= c
->interface
;
2603 static int object_removed_append_all(sd_bus
*bus
, sd_bus_message
*m
, const char *path
) {
2604 _cleanup_set_free_ Set
*s
= NULL
;
2605 _cleanup_free_
char *prefix
= NULL
;
2613 /* see sd_bus_emit_object_added() for details */
2615 s
= set_new(&string_hash_ops
);
2619 r
= sd_bus_message_append(m
, "s", "org.freedesktop.DBus.Peer");
2622 r
= sd_bus_message_append(m
, "s", "org.freedesktop.DBus.Introspectable");
2625 r
= sd_bus_message_append(m
, "s", "org.freedesktop.DBus.Properties");
2628 r
= sd_bus_message_append(m
, "s", "org.freedesktop.DBus.ObjectManager");
2632 r
= object_removed_append_all_prefix(bus
, m
, s
, path
, path
, false);
2635 if (bus
->nodes_modified
)
2639 assert(pl
<= BUS_PATH_SIZE_MAX
);
2640 prefix
= new(char, pl
+ 1);
2644 OBJECT_PATH_FOREACH_PREFIX(prefix
, path
) {
2645 r
= object_removed_append_all_prefix(bus
, m
, s
, prefix
, path
, true);
2648 if (bus
->nodes_modified
)
2655 _public_
int sd_bus_emit_object_removed(sd_bus
*bus
, const char *path
) {
2656 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2657 struct node
*object_manager
;
2661 * This is like sd_bus_emit_object_added(), but emits an
2662 * InterfacesRemoved signal on the given path. This only includes any
2663 * registered interfaces but skips the properties. Note that this will
2664 * call into the find() callbacks of any registered vtable. Therefore,
2665 * you must call this function before destroying/unlinking your object.
2666 * Otherwise, the list of interfaces will be incomplete. However, note
2667 * that this will *NOT* call into any property callback. Therefore, the
2668 * object might be in an "destructed" state, as long as we can find it.
2671 assert_return(bus
, -EINVAL
);
2672 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2673 assert_return(object_path_is_valid(path
), -EINVAL
);
2674 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2676 if (!BUS_IS_OPEN(bus
->state
))
2679 r
= bus_find_parent_object_manager(bus
, &object_manager
, path
);
2685 BUS_DONT_DESTROY(bus
);
2688 bus
->nodes_modified
= false;
2689 m
= sd_bus_message_unref(m
);
2691 r
= sd_bus_message_new_signal(bus
, &m
, object_manager
->path
, "org.freedesktop.DBus.ObjectManager", "InterfacesRemoved");
2695 r
= sd_bus_message_append_basic(m
, 'o', path
);
2699 r
= sd_bus_message_open_container(m
, 'a', "s");
2703 r
= object_removed_append_all(bus
, m
, path
);
2707 if (bus
->nodes_modified
)
2710 r
= sd_bus_message_close_container(m
);
2714 } while (bus
->nodes_modified
);
2716 return sd_bus_send(bus
, m
, NULL
);
2719 static int interfaces_added_append_one_prefix(
2724 const char *interface
,
2725 bool require_fallback
) {
2727 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
2728 bool found_interface
= false;
2729 struct node_vtable
*c
;
2740 n
= hashmap_get(bus
->nodes
, prefix
);
2744 LIST_FOREACH(vtables
, c
, n
->vtables
) {
2745 if (require_fallback
&& !c
->is_fallback
)
2748 if (!streq(c
->interface
, interface
))
2751 r
= node_vtable_get_userdata(bus
, path
, c
, &u
, &error
);
2754 if (bus
->nodes_modified
)
2759 if (!found_interface
) {
2760 r
= sd_bus_message_append_basic(m
, 's', interface
);
2764 r
= sd_bus_message_open_container(m
, 'a', "{sv}");
2768 found_interface
= true;
2771 r
= vtable_append_all_properties(bus
, m
, path
, c
, u
, &error
);
2774 if (bus
->nodes_modified
)
2778 if (found_interface
) {
2779 r
= sd_bus_message_close_container(m
);
2784 return found_interface
;
2787 static int interfaces_added_append_one(
2791 const char *interface
) {
2793 _cleanup_free_
char *prefix
= NULL
;
2802 r
= interfaces_added_append_one_prefix(bus
, m
, path
, path
, interface
, false);
2805 if (bus
->nodes_modified
)
2809 assert(pl
<= BUS_PATH_SIZE_MAX
);
2810 prefix
= new(char, pl
+ 1);
2814 OBJECT_PATH_FOREACH_PREFIX(prefix
, path
) {
2815 r
= interfaces_added_append_one_prefix(bus
, m
, prefix
, path
, interface
, true);
2818 if (bus
->nodes_modified
)
2825 _public_
int sd_bus_emit_interfaces_added_strv(sd_bus
*bus
, const char *path
, char **interfaces
) {
2826 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2827 struct node
*object_manager
;
2831 assert_return(bus
, -EINVAL
);
2832 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2833 assert_return(object_path_is_valid(path
), -EINVAL
);
2834 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2836 if (!BUS_IS_OPEN(bus
->state
))
2839 if (strv_isempty(interfaces
))
2842 r
= bus_find_parent_object_manager(bus
, &object_manager
, path
);
2848 BUS_DONT_DESTROY(bus
);
2851 bus
->nodes_modified
= false;
2852 m
= sd_bus_message_unref(m
);
2854 r
= sd_bus_message_new_signal(bus
, &m
, object_manager
->path
, "org.freedesktop.DBus.ObjectManager", "InterfacesAdded");
2858 r
= sd_bus_message_append_basic(m
, 'o', path
);
2862 r
= sd_bus_message_open_container(m
, 'a', "{sa{sv}}");
2866 STRV_FOREACH(i
, interfaces
) {
2867 assert_return(interface_name_is_valid(*i
), -EINVAL
);
2869 r
= sd_bus_message_open_container(m
, 'e', "sa{sv}");
2873 r
= interfaces_added_append_one(bus
, m
, path
, *i
);
2877 if (bus
->nodes_modified
)
2880 r
= sd_bus_message_close_container(m
);
2885 if (bus
->nodes_modified
)
2888 r
= sd_bus_message_close_container(m
);
2892 } while (bus
->nodes_modified
);
2894 return sd_bus_send(bus
, m
, NULL
);
2897 _public_
int sd_bus_emit_interfaces_added(sd_bus
*bus
, const char *path
, const char *interface
, ...) {
2900 assert_return(bus
, -EINVAL
);
2901 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2902 assert_return(object_path_is_valid(path
), -EINVAL
);
2903 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2905 if (!BUS_IS_OPEN(bus
->state
))
2908 interfaces
= strv_from_stdarg_alloca(interface
);
2910 return sd_bus_emit_interfaces_added_strv(bus
, path
, interfaces
);
2913 _public_
int sd_bus_emit_interfaces_removed_strv(sd_bus
*bus
, const char *path
, char **interfaces
) {
2914 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2915 struct node
*object_manager
;
2918 assert_return(bus
, -EINVAL
);
2919 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2920 assert_return(object_path_is_valid(path
), -EINVAL
);
2921 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2923 if (!BUS_IS_OPEN(bus
->state
))
2926 if (strv_isempty(interfaces
))
2929 r
= bus_find_parent_object_manager(bus
, &object_manager
, path
);
2935 r
= sd_bus_message_new_signal(bus
, &m
, object_manager
->path
, "org.freedesktop.DBus.ObjectManager", "InterfacesRemoved");
2939 r
= sd_bus_message_append_basic(m
, 'o', path
);
2943 r
= sd_bus_message_append_strv(m
, interfaces
);
2947 return sd_bus_send(bus
, m
, NULL
);
2950 _public_
int sd_bus_emit_interfaces_removed(sd_bus
*bus
, const char *path
, const char *interface
, ...) {
2953 assert_return(bus
, -EINVAL
);
2954 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2955 assert_return(object_path_is_valid(path
), -EINVAL
);
2956 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2958 if (!BUS_IS_OPEN(bus
->state
))
2961 interfaces
= strv_from_stdarg_alloca(interface
);
2963 return sd_bus_emit_interfaces_removed_strv(bus
, path
, interfaces
);
2966 _public_
int sd_bus_add_object_manager(sd_bus
*bus
, sd_bus_slot
**slot
, const char *path
) {
2971 assert_return(bus
, -EINVAL
);
2972 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2973 assert_return(object_path_is_valid(path
), -EINVAL
);
2974 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2976 n
= bus_node_allocate(bus
, path
);
2980 s
= bus_slot_allocate(bus
, !slot
, BUS_NODE_OBJECT_MANAGER
, sizeof(struct node_object_manager
), NULL
);
2986 s
->node_object_manager
.node
= n
;
2987 LIST_PREPEND(object_managers
, n
->object_managers
, &s
->node_object_manager
);
2988 bus
->nodes_modified
= true;
2996 sd_bus_slot_unref(s
);
2997 bus_node_gc(bus
, n
);