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