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