]> 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
sd-bus: add methods and signals parameter names. Fixes: #1564
[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 char *prefix;
1138 int r;
1139
1140 assert(bus);
1141 assert(reply);
1142 assert(path);
1143 assert(error);
1144
1145 /* First, add all vtables registered for this path */
1146 r = object_manager_serialize_path(bus, reply, path, path, false, error);
1147 if (r < 0)
1148 return r;
1149 if (bus->nodes_modified)
1150 return 0;
1151
1152 /* Second, add fallback vtables registered for any of the prefixes */
1153 prefix = alloca(strlen(path) + 1);
1154 OBJECT_PATH_FOREACH_PREFIX(prefix, path) {
1155 r = object_manager_serialize_path(bus, reply, prefix, path, true, error);
1156 if (r < 0)
1157 return r;
1158 if (bus->nodes_modified)
1159 return 0;
1160 }
1161
1162 return 0;
1163 }
1164
1165 static int process_get_managed_objects(
1166 sd_bus *bus,
1167 sd_bus_message *m,
1168 struct node *n,
1169 bool require_fallback,
1170 bool *found_object) {
1171
1172 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1173 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1174 _cleanup_set_free_free_ Set *s = NULL;
1175 Iterator i;
1176 char *path;
1177 int r;
1178
1179 assert(bus);
1180 assert(m);
1181 assert(n);
1182 assert(found_object);
1183
1184 /* Spec says, GetManagedObjects() is only implemented on the root of a
1185 * sub-tree. Therefore, we require a registered object-manager on
1186 * exactly the queried path, otherwise, we refuse to respond. */
1187
1188 if (require_fallback || !n->object_managers)
1189 return 0;
1190
1191 r = get_child_nodes(bus, m->path, n, CHILDREN_RECURSIVE, &s, &error);
1192 if (r < 0)
1193 return bus_maybe_reply_error(m, r, &error);
1194 if (bus->nodes_modified)
1195 return 0;
1196
1197 r = sd_bus_message_new_method_return(m, &reply);
1198 if (r < 0)
1199 return r;
1200
1201 r = sd_bus_message_open_container(reply, 'a', "{oa{sa{sv}}}");
1202 if (r < 0)
1203 return r;
1204
1205 SET_FOREACH(path, s, i) {
1206 r = object_manager_serialize_path_and_fallbacks(bus, reply, path, &error);
1207 if (r < 0)
1208 return bus_maybe_reply_error(m, r, &error);
1209
1210 if (bus->nodes_modified)
1211 return 0;
1212 }
1213
1214 r = sd_bus_message_close_container(reply);
1215 if (r < 0)
1216 return r;
1217
1218 r = sd_bus_send(bus, reply, NULL);
1219 if (r < 0)
1220 return r;
1221
1222 return 1;
1223 }
1224
1225 static int object_find_and_run(
1226 sd_bus *bus,
1227 sd_bus_message *m,
1228 const char *p,
1229 bool require_fallback,
1230 bool *found_object) {
1231
1232 struct node *n;
1233 struct vtable_member vtable_key, *v;
1234 int r;
1235
1236 assert(bus);
1237 assert(m);
1238 assert(p);
1239 assert(found_object);
1240
1241 n = hashmap_get(bus->nodes, p);
1242 if (!n)
1243 return 0;
1244
1245 /* First, try object callbacks */
1246 r = node_callbacks_run(bus, m, n->callbacks, require_fallback, found_object);
1247 if (r != 0)
1248 return r;
1249 if (bus->nodes_modified)
1250 return 0;
1251
1252 if (!m->interface || !m->member)
1253 return 0;
1254
1255 /* Then, look for a known method */
1256 vtable_key.path = (char*) p;
1257 vtable_key.interface = m->interface;
1258 vtable_key.member = m->member;
1259
1260 v = hashmap_get(bus->vtable_methods, &vtable_key);
1261 if (v) {
1262 r = method_callbacks_run(bus, m, v, require_fallback, found_object);
1263 if (r != 0)
1264 return r;
1265 if (bus->nodes_modified)
1266 return 0;
1267 }
1268
1269 /* Then, look for a known property */
1270 if (streq(m->interface, "org.freedesktop.DBus.Properties")) {
1271 bool get = false;
1272
1273 get = streq(m->member, "Get");
1274
1275 if (get || streq(m->member, "Set")) {
1276
1277 r = sd_bus_message_rewind(m, true);
1278 if (r < 0)
1279 return r;
1280
1281 vtable_key.path = (char*) p;
1282
1283 r = sd_bus_message_read(m, "ss", &vtable_key.interface, &vtable_key.member);
1284 if (r < 0)
1285 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INVALID_ARGS, "Expected interface and member parameters");
1286
1287 v = hashmap_get(bus->vtable_properties, &vtable_key);
1288 if (v) {
1289 r = property_get_set_callbacks_run(bus, m, v, require_fallback, get, found_object);
1290 if (r != 0)
1291 return r;
1292 }
1293
1294 } else if (streq(m->member, "GetAll")) {
1295 const char *iface;
1296
1297 r = sd_bus_message_rewind(m, true);
1298 if (r < 0)
1299 return r;
1300
1301 r = sd_bus_message_read(m, "s", &iface);
1302 if (r < 0)
1303 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INVALID_ARGS, "Expected interface parameter");
1304
1305 if (iface[0] == 0)
1306 iface = NULL;
1307
1308 r = property_get_all_callbacks_run(bus, m, n->vtables, require_fallback, iface, found_object);
1309 if (r != 0)
1310 return r;
1311 }
1312
1313 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
1314
1315 if (!isempty(sd_bus_message_get_signature(m, true)))
1316 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INVALID_ARGS, "Expected no parameters");
1317
1318 r = process_introspect(bus, m, n, require_fallback, found_object);
1319 if (r != 0)
1320 return r;
1321
1322 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.ObjectManager", "GetManagedObjects")) {
1323
1324 if (!isempty(sd_bus_message_get_signature(m, true)))
1325 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INVALID_ARGS, "Expected no parameters");
1326
1327 r = process_get_managed_objects(bus, m, n, require_fallback, found_object);
1328 if (r != 0)
1329 return r;
1330 }
1331
1332 if (bus->nodes_modified)
1333 return 0;
1334
1335 if (!*found_object) {
1336 r = bus_node_exists(bus, n, m->path, require_fallback);
1337 if (r < 0)
1338 return bus_maybe_reply_error(m, r, NULL);
1339 if (bus->nodes_modified)
1340 return 0;
1341 if (r > 0)
1342 *found_object = true;
1343 }
1344
1345 return 0;
1346 }
1347
1348 int bus_process_object(sd_bus *bus, sd_bus_message *m) {
1349 int r;
1350 size_t pl;
1351 bool found_object = false;
1352
1353 assert(bus);
1354 assert(m);
1355
1356 if (bus->is_monitor)
1357 return 0;
1358
1359 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
1360 return 0;
1361
1362 if (hashmap_isempty(bus->nodes))
1363 return 0;
1364
1365 /* Never respond to broadcast messages */
1366 if (bus->bus_client && !m->destination)
1367 return 0;
1368
1369 assert(m->path);
1370 assert(m->member);
1371
1372 pl = strlen(m->path);
1373 do {
1374 char prefix[pl+1];
1375
1376 bus->nodes_modified = false;
1377
1378 r = object_find_and_run(bus, m, m->path, false, &found_object);
1379 if (r != 0)
1380 return r;
1381
1382 /* Look for fallback prefixes */
1383 OBJECT_PATH_FOREACH_PREFIX(prefix, m->path) {
1384
1385 if (bus->nodes_modified)
1386 break;
1387
1388 r = object_find_and_run(bus, m, prefix, true, &found_object);
1389 if (r != 0)
1390 return r;
1391 }
1392
1393 } while (bus->nodes_modified);
1394
1395 if (!found_object)
1396 return 0;
1397
1398 if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "Get") ||
1399 sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "Set"))
1400 r = sd_bus_reply_method_errorf(
1401 m,
1402 SD_BUS_ERROR_UNKNOWN_PROPERTY,
1403 "Unknown property or interface.");
1404 else
1405 r = sd_bus_reply_method_errorf(
1406 m,
1407 SD_BUS_ERROR_UNKNOWN_METHOD,
1408 "Unknown method '%s' or interface '%s'.", m->member, m->interface);
1409
1410 if (r < 0)
1411 return r;
1412
1413 return 1;
1414 }
1415
1416 static struct node *bus_node_allocate(sd_bus *bus, const char *path) {
1417 struct node *n, *parent;
1418 const char *e;
1419 _cleanup_free_ char *s = NULL;
1420 char *p;
1421 int r;
1422
1423 assert(bus);
1424 assert(path);
1425 assert(path[0] == '/');
1426
1427 n = hashmap_get(bus->nodes, path);
1428 if (n)
1429 return n;
1430
1431 r = hashmap_ensure_allocated(&bus->nodes, &string_hash_ops);
1432 if (r < 0)
1433 return NULL;
1434
1435 s = strdup(path);
1436 if (!s)
1437 return NULL;
1438
1439 if (streq(path, "/"))
1440 parent = NULL;
1441 else {
1442 e = strrchr(path, '/');
1443 assert(e);
1444
1445 p = strndupa(path, MAX(1, e - path));
1446
1447 parent = bus_node_allocate(bus, p);
1448 if (!parent)
1449 return NULL;
1450 }
1451
1452 n = new0(struct node, 1);
1453 if (!n)
1454 return NULL;
1455
1456 n->parent = parent;
1457 n->path = TAKE_PTR(s);
1458
1459 r = hashmap_put(bus->nodes, n->path, n);
1460 if (r < 0) {
1461 free(n->path);
1462 return mfree(n);
1463 }
1464
1465 if (parent)
1466 LIST_PREPEND(siblings, parent->child, n);
1467
1468 return n;
1469 }
1470
1471 void bus_node_gc(sd_bus *b, struct node *n) {
1472 assert(b);
1473
1474 if (!n)
1475 return;
1476
1477 if (n->child ||
1478 n->callbacks ||
1479 n->vtables ||
1480 n->enumerators ||
1481 n->object_managers)
1482 return;
1483
1484 assert_se(hashmap_remove(b->nodes, n->path) == n);
1485
1486 if (n->parent)
1487 LIST_REMOVE(siblings, n->parent->child, n);
1488
1489 free(n->path);
1490 bus_node_gc(b, n->parent);
1491 free(n);
1492 }
1493
1494 static int bus_find_parent_object_manager(sd_bus *bus, struct node **out, const char *path) {
1495 struct node *n;
1496
1497 assert(bus);
1498 assert(path);
1499
1500 n = hashmap_get(bus->nodes, path);
1501 if (!n) {
1502 char *prefix;
1503
1504 prefix = alloca(strlen(path) + 1);
1505 OBJECT_PATH_FOREACH_PREFIX(prefix, path) {
1506 n = hashmap_get(bus->nodes, prefix);
1507 if (n)
1508 break;
1509 }
1510 }
1511
1512 while (n && !n->object_managers)
1513 n = n->parent;
1514
1515 if (out)
1516 *out = n;
1517 return !!n;
1518 }
1519
1520 static int bus_add_object(
1521 sd_bus *bus,
1522 sd_bus_slot **slot,
1523 bool fallback,
1524 const char *path,
1525 sd_bus_message_handler_t callback,
1526 void *userdata) {
1527
1528 sd_bus_slot *s;
1529 struct node *n;
1530 int r;
1531
1532 assert_return(bus, -EINVAL);
1533 assert_return(bus = bus_resolve(bus), -ENOPKG);
1534 assert_return(object_path_is_valid(path), -EINVAL);
1535 assert_return(callback, -EINVAL);
1536 assert_return(!bus_pid_changed(bus), -ECHILD);
1537
1538 n = bus_node_allocate(bus, path);
1539 if (!n)
1540 return -ENOMEM;
1541
1542 s = bus_slot_allocate(bus, !slot, BUS_NODE_CALLBACK, sizeof(struct node_callback), userdata);
1543 if (!s) {
1544 r = -ENOMEM;
1545 goto fail;
1546 }
1547
1548 s->node_callback.callback = callback;
1549 s->node_callback.is_fallback = fallback;
1550
1551 s->node_callback.node = n;
1552 LIST_PREPEND(callbacks, n->callbacks, &s->node_callback);
1553 bus->nodes_modified = true;
1554
1555 if (slot)
1556 *slot = s;
1557
1558 return 0;
1559
1560 fail:
1561 sd_bus_slot_unref(s);
1562 bus_node_gc(bus, n);
1563
1564 return r;
1565 }
1566
1567 _public_ int sd_bus_add_object(
1568 sd_bus *bus,
1569 sd_bus_slot **slot,
1570 const char *path,
1571 sd_bus_message_handler_t callback,
1572 void *userdata) {
1573
1574 return bus_add_object(bus, slot, false, path, callback, userdata);
1575 }
1576
1577 _public_ int sd_bus_add_fallback(
1578 sd_bus *bus,
1579 sd_bus_slot **slot,
1580 const char *prefix,
1581 sd_bus_message_handler_t callback,
1582 void *userdata) {
1583
1584 return bus_add_object(bus, slot, true, prefix, callback, userdata);
1585 }
1586
1587 static void vtable_member_hash_func(const struct vtable_member *m, struct siphash *state) {
1588 assert(m);
1589
1590 string_hash_func(m->path, state);
1591 string_hash_func(m->interface, state);
1592 string_hash_func(m->member, state);
1593 }
1594
1595 static int vtable_member_compare_func(const struct vtable_member *x, const struct vtable_member *y) {
1596 int r;
1597
1598 assert(x);
1599 assert(y);
1600
1601 r = strcmp(x->path, y->path);
1602 if (r != 0)
1603 return r;
1604
1605 r = strcmp(x->interface, y->interface);
1606 if (r != 0)
1607 return r;
1608
1609 return strcmp(x->member, y->member);
1610 }
1611
1612 DEFINE_PRIVATE_HASH_OPS(vtable_member_hash_ops, struct vtable_member, vtable_member_hash_func, vtable_member_compare_func);
1613
1614 typedef enum {
1615 NAMES_FIRST_PART = 1 << 0, /* first part of argument name list (input names). It is reset by names_are_valid() */
1616 NAMES_PRESENT = 1 << 1, /* at least one argument name is present, so the names will checked.
1617 This flag is set and used internally by names_are_valid(), but needs to be stored across calls for 2-parts list */
1618 NAMES_SINGLE_PART = 1 << 2, /* argument name list consisting of a single part */
1619 } names_flags;
1620
1621 static bool names_are_valid(const char *signature, const char **names, names_flags *flags) {
1622 int r;
1623
1624 if ((*flags & NAMES_FIRST_PART || *flags & NAMES_SINGLE_PART) && **names != '\0')
1625 *flags |= NAMES_PRESENT;
1626
1627 for (;*flags & NAMES_PRESENT;) {
1628 size_t l;
1629
1630 if (!*signature)
1631 break;
1632
1633 r = signature_element_length(signature, &l);
1634 if (r < 0)
1635 return false;
1636
1637 if (**names != '\0') {
1638 if (!member_name_is_valid(*names))
1639 return false;
1640 *names += strlen(*names) + 1;
1641 } else if (*flags & NAMES_PRESENT)
1642 return false;
1643
1644 signature += l;
1645 }
1646 /* let's check if there are more argument names specified than the signature allows */
1647 if (*flags & NAMES_PRESENT && **names != '\0' && !(*flags & NAMES_FIRST_PART))
1648 return false;
1649 *flags &= ~NAMES_FIRST_PART;
1650 return true;
1651 }
1652
1653 /* the current version of this struct is defined in sd-bus-vtable.h, but we need to list here the historical versions
1654 to make sure the calling code is compatible with one of these */
1655 struct sd_bus_vtable_original {
1656 uint8_t type:8;
1657 uint64_t flags:56;
1658 union {
1659 struct {
1660 size_t element_size;
1661 } start;
1662 struct {
1663 const char *member;
1664 const char *signature;
1665 const char *result;
1666 sd_bus_message_handler_t handler;
1667 size_t offset;
1668 } method;
1669 struct {
1670 const char *member;
1671 const char *signature;
1672 } signal;
1673 struct {
1674 const char *member;
1675 const char *signature;
1676 sd_bus_property_get_t get;
1677 sd_bus_property_set_t set;
1678 size_t offset;
1679 } property;
1680 } x;
1681 };
1682 /* Structure size up to v241 */
1683 #define VTABLE_ELEMENT_SIZE_ORIGINAL sizeof(struct sd_bus_vtable_original)
1684 /* Current structure size */
1685 #define VTABLE_ELEMENT_SIZE sizeof(struct sd_bus_vtable)
1686
1687 static int vtable_features(const sd_bus_vtable *vtable) {
1688 if (vtable[0].x.start.element_size == VTABLE_ELEMENT_SIZE_ORIGINAL)
1689 return 0;
1690 return vtable[0].x.start.features;
1691 }
1692
1693 bool bus_vtable_has_names(const sd_bus_vtable *vtable) {
1694 return vtable_features(vtable) & _SD_BUS_VTABLE_PARAM_NAMES;
1695 }
1696
1697 const sd_bus_vtable* bus_vtable_next(const sd_bus_vtable *vtable, const sd_bus_vtable *v) {
1698 if (vtable[0].x.start.element_size == VTABLE_ELEMENT_SIZE_ORIGINAL) {
1699 const struct sd_bus_vtable_original *v2 = (const struct sd_bus_vtable_original *)v;
1700 v2++;
1701 v = (const sd_bus_vtable*)v2;
1702 } else /* current version */
1703 v++;
1704 return v;
1705 }
1706
1707 static int add_object_vtable_internal(
1708 sd_bus *bus,
1709 sd_bus_slot **slot,
1710 const char *path,
1711 const char *interface,
1712 const sd_bus_vtable *vtable,
1713 bool fallback,
1714 sd_bus_object_find_t find,
1715 void *userdata) {
1716
1717 sd_bus_slot *s = NULL;
1718 struct node_vtable *i, *existing = NULL;
1719 const sd_bus_vtable *v;
1720 struct node *n;
1721 int r;
1722 const char *names = "";
1723 names_flags nf;
1724
1725 assert_return(bus, -EINVAL);
1726 assert_return(bus = bus_resolve(bus), -ENOPKG);
1727 assert_return(object_path_is_valid(path), -EINVAL);
1728 assert_return(interface_name_is_valid(interface), -EINVAL);
1729 assert_return(vtable, -EINVAL);
1730 assert_return(vtable[0].type == _SD_BUS_VTABLE_START, -EINVAL);
1731 assert_return(IN_SET(vtable[0].x.start.element_size, VTABLE_ELEMENT_SIZE_ORIGINAL, VTABLE_ELEMENT_SIZE), -EINVAL);
1732 assert_return(!bus_pid_changed(bus), -ECHILD);
1733 assert_return(!streq(interface, "org.freedesktop.DBus.Properties") &&
1734 !streq(interface, "org.freedesktop.DBus.Introspectable") &&
1735 !streq(interface, "org.freedesktop.DBus.Peer") &&
1736 !streq(interface, "org.freedesktop.DBus.ObjectManager"), -EINVAL);
1737
1738 r = hashmap_ensure_allocated(&bus->vtable_methods, &vtable_member_hash_ops);
1739 if (r < 0)
1740 return r;
1741
1742 r = hashmap_ensure_allocated(&bus->vtable_properties, &vtable_member_hash_ops);
1743 if (r < 0)
1744 return r;
1745
1746 n = bus_node_allocate(bus, path);
1747 if (!n)
1748 return -ENOMEM;
1749
1750 LIST_FOREACH(vtables, i, n->vtables) {
1751 if (i->is_fallback != fallback) {
1752 r = -EPROTOTYPE;
1753 goto fail;
1754 }
1755
1756 if (streq(i->interface, interface)) {
1757
1758 if (i->vtable == vtable) {
1759 r = -EEXIST;
1760 goto fail;
1761 }
1762
1763 existing = i;
1764 }
1765 }
1766
1767 s = bus_slot_allocate(bus, !slot, BUS_NODE_VTABLE, sizeof(struct node_vtable), userdata);
1768 if (!s) {
1769 r = -ENOMEM;
1770 goto fail;
1771 }
1772
1773 s->node_vtable.is_fallback = fallback;
1774 s->node_vtable.vtable = vtable;
1775 s->node_vtable.find = find;
1776
1777 s->node_vtable.interface = strdup(interface);
1778 if (!s->node_vtable.interface) {
1779 r = -ENOMEM;
1780 goto fail;
1781 }
1782
1783 v = s->node_vtable.vtable;
1784 for (v = bus_vtable_next(vtable, v); v->type != _SD_BUS_VTABLE_END; v = bus_vtable_next(vtable, v)) {
1785
1786 switch (v->type) {
1787
1788 case _SD_BUS_VTABLE_METHOD: {
1789 struct vtable_member *m;
1790 nf = NAMES_FIRST_PART;
1791
1792 if (bus_vtable_has_names(vtable))
1793 names = strempty(v->x.method.names);
1794
1795 if (!member_name_is_valid(v->x.method.member) ||
1796 !signature_is_valid(strempty(v->x.method.signature), false) ||
1797 !signature_is_valid(strempty(v->x.method.result), false) ||
1798 !names_are_valid(strempty(v->x.method.signature), &names, &nf) ||
1799 !names_are_valid(strempty(v->x.method.result), &names, &nf) ||
1800 !(v->x.method.handler || (isempty(v->x.method.signature) && isempty(v->x.method.result))) ||
1801 v->flags & (SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE|SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION)) {
1802 r = -EINVAL;
1803 goto fail;
1804 }
1805
1806 m = new0(struct vtable_member, 1);
1807 if (!m) {
1808 r = -ENOMEM;
1809 goto fail;
1810 }
1811
1812 m->parent = &s->node_vtable;
1813 m->path = n->path;
1814 m->interface = s->node_vtable.interface;
1815 m->member = v->x.method.member;
1816 m->vtable = v;
1817
1818 r = hashmap_put(bus->vtable_methods, m, m);
1819 if (r < 0) {
1820 free(m);
1821 goto fail;
1822 }
1823
1824 break;
1825 }
1826
1827 case _SD_BUS_VTABLE_WRITABLE_PROPERTY:
1828
1829 if (!(v->x.property.set || bus_type_is_basic(v->x.property.signature[0]))) {
1830 r = -EINVAL;
1831 goto fail;
1832 }
1833
1834 if (v->flags & SD_BUS_VTABLE_PROPERTY_CONST) {
1835 r = -EINVAL;
1836 goto fail;
1837 }
1838
1839 _fallthrough_;
1840 case _SD_BUS_VTABLE_PROPERTY: {
1841 struct vtable_member *m;
1842
1843 if (!member_name_is_valid(v->x.property.member) ||
1844 !signature_is_single(v->x.property.signature, false) ||
1845 !(v->x.property.get || bus_type_is_basic(v->x.property.signature[0]) || streq(v->x.property.signature, "as")) ||
1846 (v->flags & SD_BUS_VTABLE_METHOD_NO_REPLY) ||
1847 (!!(v->flags & SD_BUS_VTABLE_PROPERTY_CONST) + !!(v->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE) + !!(v->flags & SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION)) > 1 ||
1848 ((v->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE) && (v->flags & SD_BUS_VTABLE_PROPERTY_EXPLICIT)) ||
1849 (v->flags & SD_BUS_VTABLE_UNPRIVILEGED && v->type == _SD_BUS_VTABLE_PROPERTY)) {
1850 r = -EINVAL;
1851 goto fail;
1852 }
1853
1854 m = new0(struct vtable_member, 1);
1855 if (!m) {
1856 r = -ENOMEM;
1857 goto fail;
1858 }
1859
1860 m->parent = &s->node_vtable;
1861 m->path = n->path;
1862 m->interface = s->node_vtable.interface;
1863 m->member = v->x.property.member;
1864 m->vtable = v;
1865
1866 r = hashmap_put(bus->vtable_properties, m, m);
1867 if (r < 0) {
1868 free(m);
1869 goto fail;
1870 }
1871
1872 break;
1873 }
1874
1875 case _SD_BUS_VTABLE_SIGNAL:
1876 nf = NAMES_SINGLE_PART;
1877
1878 if (bus_vtable_has_names(vtable))
1879 names = strempty(v->x.signal.names);
1880
1881 if (!member_name_is_valid(v->x.signal.member) ||
1882 !signature_is_valid(strempty(v->x.signal.signature), false) ||
1883 !names_are_valid(strempty(v->x.signal.signature), &names, &nf) ||
1884 v->flags & SD_BUS_VTABLE_UNPRIVILEGED) {
1885 r = -EINVAL;
1886 goto fail;
1887 }
1888
1889 break;
1890
1891 default:
1892 r = -EINVAL;
1893 goto fail;
1894 }
1895 }
1896
1897 s->node_vtable.node = n;
1898 LIST_INSERT_AFTER(vtables, n->vtables, existing, &s->node_vtable);
1899 bus->nodes_modified = true;
1900
1901 if (slot)
1902 *slot = s;
1903
1904 return 0;
1905
1906 fail:
1907 sd_bus_slot_unref(s);
1908 bus_node_gc(bus, n);
1909
1910 return r;
1911 }
1912
1913 _public_ int sd_bus_add_object_vtable(
1914 sd_bus *bus,
1915 sd_bus_slot **slot,
1916 const char *path,
1917 const char *interface,
1918 const sd_bus_vtable *vtable,
1919 void *userdata) {
1920
1921 return add_object_vtable_internal(bus, slot, path, interface, vtable, false, NULL, userdata);
1922 }
1923
1924 _public_ int sd_bus_add_fallback_vtable(
1925 sd_bus *bus,
1926 sd_bus_slot **slot,
1927 const char *prefix,
1928 const char *interface,
1929 const sd_bus_vtable *vtable,
1930 sd_bus_object_find_t find,
1931 void *userdata) {
1932
1933 return add_object_vtable_internal(bus, slot, prefix, interface, vtable, true, find, userdata);
1934 }
1935
1936 _public_ int sd_bus_add_node_enumerator(
1937 sd_bus *bus,
1938 sd_bus_slot **slot,
1939 const char *path,
1940 sd_bus_node_enumerator_t callback,
1941 void *userdata) {
1942
1943 sd_bus_slot *s;
1944 struct node *n;
1945 int r;
1946
1947 assert_return(bus, -EINVAL);
1948 assert_return(bus = bus_resolve(bus), -ENOPKG);
1949 assert_return(object_path_is_valid(path), -EINVAL);
1950 assert_return(callback, -EINVAL);
1951 assert_return(!bus_pid_changed(bus), -ECHILD);
1952
1953 n = bus_node_allocate(bus, path);
1954 if (!n)
1955 return -ENOMEM;
1956
1957 s = bus_slot_allocate(bus, !slot, BUS_NODE_ENUMERATOR, sizeof(struct node_enumerator), userdata);
1958 if (!s) {
1959 r = -ENOMEM;
1960 goto fail;
1961 }
1962
1963 s->node_enumerator.callback = callback;
1964
1965 s->node_enumerator.node = n;
1966 LIST_PREPEND(enumerators, n->enumerators, &s->node_enumerator);
1967 bus->nodes_modified = true;
1968
1969 if (slot)
1970 *slot = s;
1971
1972 return 0;
1973
1974 fail:
1975 sd_bus_slot_unref(s);
1976 bus_node_gc(bus, n);
1977
1978 return r;
1979 }
1980
1981 static int emit_properties_changed_on_interface(
1982 sd_bus *bus,
1983 const char *prefix,
1984 const char *path,
1985 const char *interface,
1986 bool require_fallback,
1987 bool *found_interface,
1988 char **names) {
1989
1990 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1991 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
1992 bool has_invalidating = false, has_changing = false;
1993 struct vtable_member key = {};
1994 struct node_vtable *c;
1995 struct node *n;
1996 char **property;
1997 void *u = NULL;
1998 int r;
1999
2000 assert(bus);
2001 assert(prefix);
2002 assert(path);
2003 assert(interface);
2004 assert(found_interface);
2005
2006 n = hashmap_get(bus->nodes, prefix);
2007 if (!n)
2008 return 0;
2009
2010 r = sd_bus_message_new_signal(bus, &m, path, "org.freedesktop.DBus.Properties", "PropertiesChanged");
2011 if (r < 0)
2012 return r;
2013
2014 r = sd_bus_message_append(m, "s", interface);
2015 if (r < 0)
2016 return r;
2017
2018 r = sd_bus_message_open_container(m, 'a', "{sv}");
2019 if (r < 0)
2020 return r;
2021
2022 key.path = prefix;
2023 key.interface = interface;
2024
2025 LIST_FOREACH(vtables, c, n->vtables) {
2026 if (require_fallback && !c->is_fallback)
2027 continue;
2028
2029 if (!streq(c->interface, interface))
2030 continue;
2031
2032 r = node_vtable_get_userdata(bus, path, c, &u, &error);
2033 if (r < 0)
2034 return r;
2035 if (bus->nodes_modified)
2036 return 0;
2037 if (r == 0)
2038 continue;
2039
2040 *found_interface = true;
2041
2042 if (names) {
2043 /* If the caller specified a list of
2044 * properties we include exactly those in the
2045 * PropertiesChanged message */
2046
2047 STRV_FOREACH(property, names) {
2048 struct vtable_member *v;
2049
2050 assert_return(member_name_is_valid(*property), -EINVAL);
2051
2052 key.member = *property;
2053 v = hashmap_get(bus->vtable_properties, &key);
2054 if (!v)
2055 return -ENOENT;
2056
2057 /* If there are two vtables for the same
2058 * interface, let's handle this property when
2059 * we come to that vtable. */
2060 if (c != v->parent)
2061 continue;
2062
2063 assert_return(v->vtable->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE ||
2064 v->vtable->flags & SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION, -EDOM);
2065
2066 assert_return(!(v->vtable->flags & SD_BUS_VTABLE_HIDDEN), -EDOM);
2067
2068 if (v->vtable->flags & SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION) {
2069 has_invalidating = true;
2070 continue;
2071 }
2072
2073 has_changing = true;
2074
2075 r = vtable_append_one_property(bus, m, m->path, c, v->vtable, u, &error);
2076 if (r < 0)
2077 return r;
2078 if (bus->nodes_modified)
2079 return 0;
2080 }
2081 } else {
2082 const sd_bus_vtable *v;
2083
2084 /* If the caller specified no properties list
2085 * we include all properties that are marked
2086 * as changing in the message. */
2087
2088 v = c->vtable;
2089 for (v = bus_vtable_next(c->vtable, v); v->type != _SD_BUS_VTABLE_END; v = bus_vtable_next(c->vtable, v)) {
2090 if (!IN_SET(v->type, _SD_BUS_VTABLE_PROPERTY, _SD_BUS_VTABLE_WRITABLE_PROPERTY))
2091 continue;
2092
2093 if (v->flags & SD_BUS_VTABLE_HIDDEN)
2094 continue;
2095
2096 if (v->flags & SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION) {
2097 has_invalidating = true;
2098 continue;
2099 }
2100
2101 if (!(v->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE))
2102 continue;
2103
2104 has_changing = true;
2105
2106 r = vtable_append_one_property(bus, m, m->path, c, v, u, &error);
2107 if (r < 0)
2108 return r;
2109 if (bus->nodes_modified)
2110 return 0;
2111 }
2112 }
2113 }
2114
2115 if (!has_invalidating && !has_changing)
2116 return 0;
2117
2118 r = sd_bus_message_close_container(m);
2119 if (r < 0)
2120 return r;
2121
2122 r = sd_bus_message_open_container(m, 'a', "s");
2123 if (r < 0)
2124 return r;
2125
2126 if (has_invalidating) {
2127 LIST_FOREACH(vtables, c, n->vtables) {
2128 if (require_fallback && !c->is_fallback)
2129 continue;
2130
2131 if (!streq(c->interface, interface))
2132 continue;
2133
2134 r = node_vtable_get_userdata(bus, path, c, &u, &error);
2135 if (r < 0)
2136 return r;
2137 if (bus->nodes_modified)
2138 return 0;
2139 if (r == 0)
2140 continue;
2141
2142 if (names) {
2143 STRV_FOREACH(property, names) {
2144 struct vtable_member *v;
2145
2146 key.member = *property;
2147 assert_se(v = hashmap_get(bus->vtable_properties, &key));
2148 assert(c == v->parent);
2149
2150 if (!(v->vtable->flags & SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION))
2151 continue;
2152
2153 r = sd_bus_message_append(m, "s", *property);
2154 if (r < 0)
2155 return r;
2156 }
2157 } else {
2158 const sd_bus_vtable *v;
2159
2160 v = c->vtable;
2161 for (v = bus_vtable_next(c->vtable, v); v->type != _SD_BUS_VTABLE_END; v = bus_vtable_next(c->vtable, v)) {
2162 if (!IN_SET(v->type, _SD_BUS_VTABLE_PROPERTY, _SD_BUS_VTABLE_WRITABLE_PROPERTY))
2163 continue;
2164
2165 if (v->flags & SD_BUS_VTABLE_HIDDEN)
2166 continue;
2167
2168 if (!(v->flags & SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION))
2169 continue;
2170
2171 r = sd_bus_message_append(m, "s", v->x.property.member);
2172 if (r < 0)
2173 return r;
2174 }
2175 }
2176 }
2177 }
2178
2179 r = sd_bus_message_close_container(m);
2180 if (r < 0)
2181 return r;
2182
2183 r = sd_bus_send(bus, m, NULL);
2184 if (r < 0)
2185 return r;
2186
2187 return 1;
2188 }
2189
2190 _public_ int sd_bus_emit_properties_changed_strv(
2191 sd_bus *bus,
2192 const char *path,
2193 const char *interface,
2194 char **names) {
2195
2196 bool found_interface = false;
2197 char *prefix;
2198 int r;
2199
2200 assert_return(bus, -EINVAL);
2201 assert_return(bus = bus_resolve(bus), -ENOPKG);
2202 assert_return(object_path_is_valid(path), -EINVAL);
2203 assert_return(interface_name_is_valid(interface), -EINVAL);
2204 assert_return(!bus_pid_changed(bus), -ECHILD);
2205
2206 if (!BUS_IS_OPEN(bus->state))
2207 return -ENOTCONN;
2208
2209 /* A non-NULL but empty names list means nothing needs to be
2210 generated. A NULL list OTOH indicates that all properties
2211 that are set to EMITS_CHANGE or EMITS_INVALIDATION shall be
2212 included in the PropertiesChanged message. */
2213 if (names && names[0] == NULL)
2214 return 0;
2215
2216 BUS_DONT_DESTROY(bus);
2217
2218 do {
2219 bus->nodes_modified = false;
2220
2221 r = emit_properties_changed_on_interface(bus, path, path, interface, false, &found_interface, names);
2222 if (r != 0)
2223 return r;
2224 if (bus->nodes_modified)
2225 continue;
2226
2227 prefix = alloca(strlen(path) + 1);
2228 OBJECT_PATH_FOREACH_PREFIX(prefix, path) {
2229 r = emit_properties_changed_on_interface(bus, prefix, path, interface, true, &found_interface, names);
2230 if (r != 0)
2231 return r;
2232 if (bus->nodes_modified)
2233 break;
2234 }
2235
2236 } while (bus->nodes_modified);
2237
2238 return found_interface ? 0 : -ENOENT;
2239 }
2240
2241 _public_ int sd_bus_emit_properties_changed(
2242 sd_bus *bus,
2243 const char *path,
2244 const char *interface,
2245 const char *name, ...) {
2246
2247 char **names;
2248
2249 assert_return(bus, -EINVAL);
2250 assert_return(bus = bus_resolve(bus), -ENOPKG);
2251 assert_return(object_path_is_valid(path), -EINVAL);
2252 assert_return(interface_name_is_valid(interface), -EINVAL);
2253 assert_return(!bus_pid_changed(bus), -ECHILD);
2254
2255 if (!BUS_IS_OPEN(bus->state))
2256 return -ENOTCONN;
2257
2258 if (!name)
2259 return 0;
2260
2261 names = strv_from_stdarg_alloca(name);
2262
2263 return sd_bus_emit_properties_changed_strv(bus, path, interface, names);
2264 }
2265
2266 static int object_added_append_all_prefix(
2267 sd_bus *bus,
2268 sd_bus_message *m,
2269 Set *s,
2270 const char *prefix,
2271 const char *path,
2272 bool require_fallback) {
2273
2274 const char *previous_interface = NULL;
2275 struct node_vtable *c;
2276 struct node *n;
2277 int r;
2278
2279 assert(bus);
2280 assert(m);
2281 assert(s);
2282 assert(prefix);
2283 assert(path);
2284
2285 n = hashmap_get(bus->nodes, prefix);
2286 if (!n)
2287 return 0;
2288
2289 LIST_FOREACH(vtables, c, n->vtables) {
2290 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2291 void *u = NULL;
2292
2293 if (require_fallback && !c->is_fallback)
2294 continue;
2295
2296 r = node_vtable_get_userdata(bus, path, c, &u, &error);
2297 if (r < 0)
2298 return r;
2299 if (bus->nodes_modified)
2300 return 0;
2301 if (r == 0)
2302 continue;
2303
2304 if (!streq_ptr(c->interface, previous_interface)) {
2305 /* If a child-node already handled this interface, we
2306 * skip it on any of its parents. The child vtables
2307 * always fully override any conflicting vtables of
2308 * any parent node. */
2309 if (set_get(s, c->interface))
2310 continue;
2311
2312 r = set_put(s, c->interface);
2313 if (r < 0)
2314 return r;
2315
2316 if (previous_interface) {
2317 r = sd_bus_message_close_container(m);
2318 if (r < 0)
2319 return r;
2320 r = sd_bus_message_close_container(m);
2321 if (r < 0)
2322 return r;
2323 }
2324
2325 r = sd_bus_message_open_container(m, 'e', "sa{sv}");
2326 if (r < 0)
2327 return r;
2328 r = sd_bus_message_append(m, "s", c->interface);
2329 if (r < 0)
2330 return r;
2331 r = sd_bus_message_open_container(m, 'a', "{sv}");
2332 if (r < 0)
2333 return r;
2334
2335 previous_interface = c->interface;
2336 }
2337
2338 r = vtable_append_all_properties(bus, m, path, c, u, &error);
2339 if (r < 0)
2340 return r;
2341 if (bus->nodes_modified)
2342 return 0;
2343 }
2344
2345 if (previous_interface) {
2346 r = sd_bus_message_close_container(m);
2347 if (r < 0)
2348 return r;
2349 r = sd_bus_message_close_container(m);
2350 if (r < 0)
2351 return r;
2352 }
2353
2354 return 0;
2355 }
2356
2357 static int object_added_append_all(sd_bus *bus, sd_bus_message *m, const char *path) {
2358 _cleanup_set_free_ Set *s = NULL;
2359 char *prefix;
2360 int r;
2361
2362 assert(bus);
2363 assert(m);
2364 assert(path);
2365
2366 /*
2367 * This appends all interfaces registered on path @path. We first add
2368 * the builtin interfaces, which are always available and handled by
2369 * sd-bus. Then, we add all interfaces registered on the exact node,
2370 * followed by all fallback interfaces registered on any parent prefix.
2371 *
2372 * If an interface is registered multiple times on the same node with
2373 * different vtables, we merge all the properties across all vtables.
2374 * However, if a child node has the same interface registered as one of
2375 * its parent nodes has as fallback, we make the child overwrite the
2376 * parent instead of extending it. Therefore, we keep a "Set" of all
2377 * handled interfaces during parent traversal, so we skip interfaces on
2378 * a parent that were overwritten by a child.
2379 */
2380
2381 s = set_new(&string_hash_ops);
2382 if (!s)
2383 return -ENOMEM;
2384
2385 r = sd_bus_message_append(m, "{sa{sv}}", "org.freedesktop.DBus.Peer", 0);
2386 if (r < 0)
2387 return r;
2388 r = sd_bus_message_append(m, "{sa{sv}}", "org.freedesktop.DBus.Introspectable", 0);
2389 if (r < 0)
2390 return r;
2391 r = sd_bus_message_append(m, "{sa{sv}}", "org.freedesktop.DBus.Properties", 0);
2392 if (r < 0)
2393 return r;
2394 r = sd_bus_message_append(m, "{sa{sv}}", "org.freedesktop.DBus.ObjectManager", 0);
2395 if (r < 0)
2396 return r;
2397
2398 r = object_added_append_all_prefix(bus, m, s, path, path, false);
2399 if (r < 0)
2400 return r;
2401 if (bus->nodes_modified)
2402 return 0;
2403
2404 prefix = alloca(strlen(path) + 1);
2405 OBJECT_PATH_FOREACH_PREFIX(prefix, path) {
2406 r = object_added_append_all_prefix(bus, m, s, prefix, path, true);
2407 if (r < 0)
2408 return r;
2409 if (bus->nodes_modified)
2410 return 0;
2411 }
2412
2413 return 0;
2414 }
2415
2416 _public_ int sd_bus_emit_object_added(sd_bus *bus, const char *path) {
2417 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2418 struct node *object_manager;
2419 int r;
2420
2421 /*
2422 * This emits an InterfacesAdded signal on the given path, by iterating
2423 * all registered vtables and fallback vtables on the path. All
2424 * properties are queried and included in the signal.
2425 * This call is equivalent to sd_bus_emit_interfaces_added() with an
2426 * explicit list of registered interfaces. However, unlike
2427 * interfaces_added(), this call can figure out the list of supported
2428 * interfaces itself. Furthermore, it properly adds the builtin
2429 * org.freedesktop.DBus.* interfaces.
2430 */
2431
2432 assert_return(bus, -EINVAL);
2433 assert_return(bus = bus_resolve(bus), -ENOPKG);
2434 assert_return(object_path_is_valid(path), -EINVAL);
2435 assert_return(!bus_pid_changed(bus), -ECHILD);
2436
2437 if (!BUS_IS_OPEN(bus->state))
2438 return -ENOTCONN;
2439
2440 r = bus_find_parent_object_manager(bus, &object_manager, path);
2441 if (r < 0)
2442 return r;
2443 if (r == 0)
2444 return -ESRCH;
2445
2446 BUS_DONT_DESTROY(bus);
2447
2448 do {
2449 bus->nodes_modified = false;
2450 m = sd_bus_message_unref(m);
2451
2452 r = sd_bus_message_new_signal(bus, &m, object_manager->path, "org.freedesktop.DBus.ObjectManager", "InterfacesAdded");
2453 if (r < 0)
2454 return r;
2455
2456 r = sd_bus_message_append_basic(m, 'o', path);
2457 if (r < 0)
2458 return r;
2459
2460 r = sd_bus_message_open_container(m, 'a', "{sa{sv}}");
2461 if (r < 0)
2462 return r;
2463
2464 r = object_added_append_all(bus, m, path);
2465 if (r < 0)
2466 return r;
2467
2468 if (bus->nodes_modified)
2469 continue;
2470
2471 r = sd_bus_message_close_container(m);
2472 if (r < 0)
2473 return r;
2474
2475 } while (bus->nodes_modified);
2476
2477 return sd_bus_send(bus, m, NULL);
2478 }
2479
2480 static int object_removed_append_all_prefix(
2481 sd_bus *bus,
2482 sd_bus_message *m,
2483 Set *s,
2484 const char *prefix,
2485 const char *path,
2486 bool require_fallback) {
2487
2488 const char *previous_interface = NULL;
2489 struct node_vtable *c;
2490 struct node *n;
2491 int r;
2492
2493 assert(bus);
2494 assert(m);
2495 assert(s);
2496 assert(prefix);
2497 assert(path);
2498
2499 n = hashmap_get(bus->nodes, prefix);
2500 if (!n)
2501 return 0;
2502
2503 LIST_FOREACH(vtables, c, n->vtables) {
2504 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2505 void *u = NULL;
2506
2507 if (require_fallback && !c->is_fallback)
2508 continue;
2509 if (streq_ptr(c->interface, previous_interface))
2510 continue;
2511
2512 /* If a child-node already handled this interface, we
2513 * skip it on any of its parents. The child vtables
2514 * always fully override any conflicting vtables of
2515 * any parent node. */
2516 if (set_get(s, c->interface))
2517 continue;
2518
2519 r = node_vtable_get_userdata(bus, path, c, &u, &error);
2520 if (r < 0)
2521 return r;
2522 if (bus->nodes_modified)
2523 return 0;
2524 if (r == 0)
2525 continue;
2526
2527 r = set_put(s, c->interface);
2528 if (r < 0)
2529 return r;
2530
2531 r = sd_bus_message_append(m, "s", c->interface);
2532 if (r < 0)
2533 return r;
2534
2535 previous_interface = c->interface;
2536 }
2537
2538 return 0;
2539 }
2540
2541 static int object_removed_append_all(sd_bus *bus, sd_bus_message *m, const char *path) {
2542 _cleanup_set_free_ Set *s = NULL;
2543 char *prefix;
2544 int r;
2545
2546 assert(bus);
2547 assert(m);
2548 assert(path);
2549
2550 /* see sd_bus_emit_object_added() for details */
2551
2552 s = set_new(&string_hash_ops);
2553 if (!s)
2554 return -ENOMEM;
2555
2556 r = sd_bus_message_append(m, "s", "org.freedesktop.DBus.Peer");
2557 if (r < 0)
2558 return r;
2559 r = sd_bus_message_append(m, "s", "org.freedesktop.DBus.Introspectable");
2560 if (r < 0)
2561 return r;
2562 r = sd_bus_message_append(m, "s", "org.freedesktop.DBus.Properties");
2563 if (r < 0)
2564 return r;
2565 r = sd_bus_message_append(m, "s", "org.freedesktop.DBus.ObjectManager");
2566 if (r < 0)
2567 return r;
2568
2569 r = object_removed_append_all_prefix(bus, m, s, path, path, false);
2570 if (r < 0)
2571 return r;
2572 if (bus->nodes_modified)
2573 return 0;
2574
2575 prefix = alloca(strlen(path) + 1);
2576 OBJECT_PATH_FOREACH_PREFIX(prefix, path) {
2577 r = object_removed_append_all_prefix(bus, m, s, prefix, path, true);
2578 if (r < 0)
2579 return r;
2580 if (bus->nodes_modified)
2581 return 0;
2582 }
2583
2584 return 0;
2585 }
2586
2587 _public_ int sd_bus_emit_object_removed(sd_bus *bus, const char *path) {
2588 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2589 struct node *object_manager;
2590 int r;
2591
2592 /*
2593 * This is like sd_bus_emit_object_added(), but emits an
2594 * InterfacesRemoved signal on the given path. This only includes any
2595 * registered interfaces but skips the properties. Note that this will
2596 * call into the find() callbacks of any registered vtable. Therefore,
2597 * you must call this function before destroying/unlinking your object.
2598 * Otherwise, the list of interfaces will be incomplete. However, note
2599 * that this will *NOT* call into any property callback. Therefore, the
2600 * object might be in an "destructed" state, as long as we can find it.
2601 */
2602
2603 assert_return(bus, -EINVAL);
2604 assert_return(bus = bus_resolve(bus), -ENOPKG);
2605 assert_return(object_path_is_valid(path), -EINVAL);
2606 assert_return(!bus_pid_changed(bus), -ECHILD);
2607
2608 if (!BUS_IS_OPEN(bus->state))
2609 return -ENOTCONN;
2610
2611 r = bus_find_parent_object_manager(bus, &object_manager, path);
2612 if (r < 0)
2613 return r;
2614 if (r == 0)
2615 return -ESRCH;
2616
2617 BUS_DONT_DESTROY(bus);
2618
2619 do {
2620 bus->nodes_modified = false;
2621 m = sd_bus_message_unref(m);
2622
2623 r = sd_bus_message_new_signal(bus, &m, object_manager->path, "org.freedesktop.DBus.ObjectManager", "InterfacesRemoved");
2624 if (r < 0)
2625 return r;
2626
2627 r = sd_bus_message_append_basic(m, 'o', path);
2628 if (r < 0)
2629 return r;
2630
2631 r = sd_bus_message_open_container(m, 'a', "s");
2632 if (r < 0)
2633 return r;
2634
2635 r = object_removed_append_all(bus, m, path);
2636 if (r < 0)
2637 return r;
2638
2639 if (bus->nodes_modified)
2640 continue;
2641
2642 r = sd_bus_message_close_container(m);
2643 if (r < 0)
2644 return r;
2645
2646 } while (bus->nodes_modified);
2647
2648 return sd_bus_send(bus, m, NULL);
2649 }
2650
2651 static int interfaces_added_append_one_prefix(
2652 sd_bus *bus,
2653 sd_bus_message *m,
2654 const char *prefix,
2655 const char *path,
2656 const char *interface,
2657 bool require_fallback) {
2658
2659 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2660 bool found_interface = false;
2661 struct node_vtable *c;
2662 struct node *n;
2663 void *u = NULL;
2664 int r;
2665
2666 assert(bus);
2667 assert(m);
2668 assert(prefix);
2669 assert(path);
2670 assert(interface);
2671
2672 n = hashmap_get(bus->nodes, prefix);
2673 if (!n)
2674 return 0;
2675
2676 LIST_FOREACH(vtables, c, n->vtables) {
2677 if (require_fallback && !c->is_fallback)
2678 continue;
2679
2680 if (!streq(c->interface, interface))
2681 continue;
2682
2683 r = node_vtable_get_userdata(bus, path, c, &u, &error);
2684 if (r < 0)
2685 return r;
2686 if (bus->nodes_modified)
2687 return 0;
2688 if (r == 0)
2689 continue;
2690
2691 if (!found_interface) {
2692 r = sd_bus_message_append_basic(m, 's', interface);
2693 if (r < 0)
2694 return r;
2695
2696 r = sd_bus_message_open_container(m, 'a', "{sv}");
2697 if (r < 0)
2698 return r;
2699
2700 found_interface = true;
2701 }
2702
2703 r = vtable_append_all_properties(bus, m, path, c, u, &error);
2704 if (r < 0)
2705 return r;
2706 if (bus->nodes_modified)
2707 return 0;
2708 }
2709
2710 if (found_interface) {
2711 r = sd_bus_message_close_container(m);
2712 if (r < 0)
2713 return r;
2714 }
2715
2716 return found_interface;
2717 }
2718
2719 static int interfaces_added_append_one(
2720 sd_bus *bus,
2721 sd_bus_message *m,
2722 const char *path,
2723 const char *interface) {
2724
2725 char *prefix;
2726 int r;
2727
2728 assert(bus);
2729 assert(m);
2730 assert(path);
2731 assert(interface);
2732
2733 r = interfaces_added_append_one_prefix(bus, m, path, path, interface, false);
2734 if (r != 0)
2735 return r;
2736 if (bus->nodes_modified)
2737 return 0;
2738
2739 prefix = alloca(strlen(path) + 1);
2740 OBJECT_PATH_FOREACH_PREFIX(prefix, path) {
2741 r = interfaces_added_append_one_prefix(bus, m, prefix, path, interface, true);
2742 if (r != 0)
2743 return r;
2744 if (bus->nodes_modified)
2745 return 0;
2746 }
2747
2748 return -ENOENT;
2749 }
2750
2751 _public_ int sd_bus_emit_interfaces_added_strv(sd_bus *bus, const char *path, char **interfaces) {
2752 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2753 struct node *object_manager;
2754 char **i;
2755 int r;
2756
2757 assert_return(bus, -EINVAL);
2758 assert_return(bus = bus_resolve(bus), -ENOPKG);
2759 assert_return(object_path_is_valid(path), -EINVAL);
2760 assert_return(!bus_pid_changed(bus), -ECHILD);
2761
2762 if (!BUS_IS_OPEN(bus->state))
2763 return -ENOTCONN;
2764
2765 if (strv_isempty(interfaces))
2766 return 0;
2767
2768 r = bus_find_parent_object_manager(bus, &object_manager, path);
2769 if (r < 0)
2770 return r;
2771 if (r == 0)
2772 return -ESRCH;
2773
2774 BUS_DONT_DESTROY(bus);
2775
2776 do {
2777 bus->nodes_modified = false;
2778 m = sd_bus_message_unref(m);
2779
2780 r = sd_bus_message_new_signal(bus, &m, object_manager->path, "org.freedesktop.DBus.ObjectManager", "InterfacesAdded");
2781 if (r < 0)
2782 return r;
2783
2784 r = sd_bus_message_append_basic(m, 'o', path);
2785 if (r < 0)
2786 return r;
2787
2788 r = sd_bus_message_open_container(m, 'a', "{sa{sv}}");
2789 if (r < 0)
2790 return r;
2791
2792 STRV_FOREACH(i, interfaces) {
2793 assert_return(interface_name_is_valid(*i), -EINVAL);
2794
2795 r = sd_bus_message_open_container(m, 'e', "sa{sv}");
2796 if (r < 0)
2797 return r;
2798
2799 r = interfaces_added_append_one(bus, m, path, *i);
2800 if (r < 0)
2801 return r;
2802
2803 if (bus->nodes_modified)
2804 break;
2805
2806 r = sd_bus_message_close_container(m);
2807 if (r < 0)
2808 return r;
2809 }
2810
2811 if (bus->nodes_modified)
2812 continue;
2813
2814 r = sd_bus_message_close_container(m);
2815 if (r < 0)
2816 return r;
2817
2818 } while (bus->nodes_modified);
2819
2820 return sd_bus_send(bus, m, NULL);
2821 }
2822
2823 _public_ int sd_bus_emit_interfaces_added(sd_bus *bus, const char *path, const char *interface, ...) {
2824 char **interfaces;
2825
2826 assert_return(bus, -EINVAL);
2827 assert_return(bus = bus_resolve(bus), -ENOPKG);
2828 assert_return(object_path_is_valid(path), -EINVAL);
2829 assert_return(!bus_pid_changed(bus), -ECHILD);
2830
2831 if (!BUS_IS_OPEN(bus->state))
2832 return -ENOTCONN;
2833
2834 interfaces = strv_from_stdarg_alloca(interface);
2835
2836 return sd_bus_emit_interfaces_added_strv(bus, path, interfaces);
2837 }
2838
2839 _public_ int sd_bus_emit_interfaces_removed_strv(sd_bus *bus, const char *path, char **interfaces) {
2840 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2841 struct node *object_manager;
2842 int r;
2843
2844 assert_return(bus, -EINVAL);
2845 assert_return(bus = bus_resolve(bus), -ENOPKG);
2846 assert_return(object_path_is_valid(path), -EINVAL);
2847 assert_return(!bus_pid_changed(bus), -ECHILD);
2848
2849 if (!BUS_IS_OPEN(bus->state))
2850 return -ENOTCONN;
2851
2852 if (strv_isempty(interfaces))
2853 return 0;
2854
2855 r = bus_find_parent_object_manager(bus, &object_manager, path);
2856 if (r < 0)
2857 return r;
2858 if (r == 0)
2859 return -ESRCH;
2860
2861 r = sd_bus_message_new_signal(bus, &m, object_manager->path, "org.freedesktop.DBus.ObjectManager", "InterfacesRemoved");
2862 if (r < 0)
2863 return r;
2864
2865 r = sd_bus_message_append_basic(m, 'o', path);
2866 if (r < 0)
2867 return r;
2868
2869 r = sd_bus_message_append_strv(m, interfaces);
2870 if (r < 0)
2871 return r;
2872
2873 return sd_bus_send(bus, m, NULL);
2874 }
2875
2876 _public_ int sd_bus_emit_interfaces_removed(sd_bus *bus, const char *path, const char *interface, ...) {
2877 char **interfaces;
2878
2879 assert_return(bus, -EINVAL);
2880 assert_return(bus = bus_resolve(bus), -ENOPKG);
2881 assert_return(object_path_is_valid(path), -EINVAL);
2882 assert_return(!bus_pid_changed(bus), -ECHILD);
2883
2884 if (!BUS_IS_OPEN(bus->state))
2885 return -ENOTCONN;
2886
2887 interfaces = strv_from_stdarg_alloca(interface);
2888
2889 return sd_bus_emit_interfaces_removed_strv(bus, path, interfaces);
2890 }
2891
2892 _public_ int sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **slot, const char *path) {
2893 sd_bus_slot *s;
2894 struct node *n;
2895 int r;
2896
2897 assert_return(bus, -EINVAL);
2898 assert_return(bus = bus_resolve(bus), -ENOPKG);
2899 assert_return(object_path_is_valid(path), -EINVAL);
2900 assert_return(!bus_pid_changed(bus), -ECHILD);
2901
2902 n = bus_node_allocate(bus, path);
2903 if (!n)
2904 return -ENOMEM;
2905
2906 s = bus_slot_allocate(bus, !slot, BUS_NODE_OBJECT_MANAGER, sizeof(struct node_object_manager), NULL);
2907 if (!s) {
2908 r = -ENOMEM;
2909 goto fail;
2910 }
2911
2912 s->node_object_manager.node = n;
2913 LIST_PREPEND(object_managers, n->object_managers, &s->node_object_manager);
2914 bus->nodes_modified = true;
2915
2916 if (slot)
2917 *slot = s;
2918
2919 return 0;
2920
2921 fail:
2922 sd_bus_slot_unref(s);
2923 bus_node_gc(bus, n);
2924
2925 return r;
2926 }
Unnamed repository; edit this file 'description' to name the repository.