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