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