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