1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Lennart Poettering
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.
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.
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/>.
29 #include "time-util.h"
30 #include "memfd-util.h"
33 #include "bus-message.h"
34 #include "bus-internal.h"
36 #include "bus-signature.h"
37 #include "bus-gvariant.h"
40 static int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored);
42 static void *adjust_pointer(const void *p, void *old_base, size_t sz, void *new_base) {
47 if (old_base == new_base)
50 if ((uint8_t*) p < (uint8_t*) old_base)
53 if ((uint8_t*) p >= (uint8_t*) old_base + sz)
56 return (uint8_t*) new_base + ((uint8_t*) p - (uint8_t*) old_base);
59 static void message_free_part(sd_bus_message *m, struct bus_body_part *part) {
63 if (part->memfd >= 0) {
64 /* If we can reuse the memfd, try that. For that it
65 * can't be sealed yet. */
68 assert(part->memfd_offset == 0);
69 assert(part->data == part->mmap_begin);
70 bus_kernel_push_memfd(m->bus, part->memfd, part->data, part->mapped, part->allocated);
73 assert_se(munmap(part->mmap_begin, part->mapped) == 0);
75 safe_close(part->memfd);
78 } else if (part->munmap_this)
79 munmap(part->mmap_begin, part->mapped);
80 else if (part->free_this)
87 static void message_reset_parts(sd_bus_message *m) {
88 struct bus_body_part *part;
93 while (m->n_body_parts > 0) {
94 struct bus_body_part *next = part->next;
95 message_free_part(m, part);
102 m->cached_rindex_part = NULL;
103 m->cached_rindex_part_begin = 0;
106 static void message_reset_containers(sd_bus_message *m) {
111 for (i = 0; i < m->n_containers; i++) {
112 free(m->containers[i].signature);
113 free(m->containers[i].offsets);
117 m->containers = NULL;
119 m->n_containers = m->containers_allocated = 0;
120 m->root_container.index = 0;
123 static void message_free(sd_bus_message *m) {
129 message_reset_parts(m);
131 if (m->release_kdbus)
132 bus_kernel_cmd_free(m->bus, (uint8_t *) m->kdbus - (uint8_t *) m->bus->kdbus_buffer);
137 sd_bus_unref(m->bus);
140 close_many(m->fds, m->n_fds);
144 if (m->iovec != m->iovec_fixed)
147 if (m->destination_ptr) {
148 free(m->destination_ptr);
149 m->destination_ptr = NULL;
152 message_reset_containers(m);
153 free(m->root_container.signature);
154 free(m->root_container.offsets);
156 free(m->root_container.peeked_signature);
158 bus_creds_done(&m->creds);
162 static void *message_extend_fields(sd_bus_message *m, size_t align, size_t sz, bool add_offset) {
164 size_t old_size, new_size, start;
171 old_size = sizeof(struct bus_header) + m->fields_size;
172 start = ALIGN_TO(old_size, align);
173 new_size = start + sz;
175 if (new_size < start ||
176 new_size > (size_t) ((uint32_t) -1))
179 if (old_size == new_size)
180 return (uint8_t*) m->header + old_size;
182 if (m->free_header) {
183 np = realloc(m->header, ALIGN8(new_size));
187 /* Initially, the header is allocated as part of of
188 * the sd_bus_message itself, let's replace it by
191 np = malloc(ALIGN8(new_size));
195 memcpy(np, m->header, sizeof(struct bus_header));
198 /* Zero out padding */
199 if (start > old_size)
200 memzero((uint8_t*) np + old_size, start - old_size);
204 m->fields_size = new_size - sizeof(struct bus_header);
206 /* Adjust quick access pointers */
207 m->path = adjust_pointer(m->path, op, old_size, m->header);
208 m->interface = adjust_pointer(m->interface, op, old_size, m->header);
209 m->member = adjust_pointer(m->member, op, old_size, m->header);
210 m->destination = adjust_pointer(m->destination, op, old_size, m->header);
211 m->sender = adjust_pointer(m->sender, op, old_size, m->header);
212 m->error.name = adjust_pointer(m->error.name, op, old_size, m->header);
214 m->free_header = true;
217 if (m->n_header_offsets >= ELEMENTSOF(m->header_offsets))
220 m->header_offsets[m->n_header_offsets++] = new_size - sizeof(struct bus_header);
223 return (uint8_t*) np + start;
230 static int message_append_field_string(
242 /* dbus1 only allows 8bit header field ids */
246 /* dbus1 doesn't allow strings over 32bit, let's enforce this
247 * globally, to not risk convertability */
249 if (l > (size_t) (uint32_t) -1)
252 /* Signature "(yv)" where the variant contains "s" */
254 if (BUS_MESSAGE_IS_GVARIANT(m)) {
256 /* (field id 64bit, ((string + NUL) + NUL + signature string 's') */
257 p = message_extend_fields(m, 8, 8 + l + 1 + 1 + 1, true);
261 *((uint64_t*) p) = h;
268 *ret = (char*) p + 8;
271 /* (field id byte + (signature length + signature 's' + NUL) + (string length + string + NUL)) */
272 p = message_extend_fields(m, 8, 4 + 4 + l + 1, false);
281 ((uint32_t*) p)[1] = l;
282 memcpy(p + 8, s, l + 1);
285 *ret = (char*) p + 8;
291 static int message_append_field_signature(
302 /* dbus1 only allows 8bit header field ids */
306 /* dbus1 doesn't allow signatures over 8bit, let's enforce
307 * this globally, to not risk convertability */
312 /* Signature "(yv)" where the variant contains "g" */
314 if (BUS_MESSAGE_IS_GVARIANT(m))
315 /* For gvariant the serialization is the same as for normal strings */
316 return message_append_field_string(m, h, 'g', s, ret);
318 /* (field id byte + (signature length + signature 'g' + NUL) + (string length + string + NUL)) */
319 p = message_extend_fields(m, 8, 4 + 1 + l + 1, false);
325 p[2] = SD_BUS_TYPE_SIGNATURE;
328 memcpy(p + 5, s, l + 1);
331 *ret = (const char*) p + 5;
337 static int message_append_field_uint32(sd_bus_message *m, uint64_t h, uint32_t x) {
342 /* dbus1 only allows 8bit header field ids */
346 if (BUS_MESSAGE_IS_GVARIANT(m)) {
347 /* (field id 64bit + ((value + NUL + signature string 'u') */
349 p = message_extend_fields(m, 8, 8 + 4 + 1 + 1, true);
353 *((uint64_t*) p) = h;
354 *((uint32_t*) (p + 8)) = x;
358 /* (field id byte + (signature length + signature 'u' + NUL) + value) */
359 p = message_extend_fields(m, 8, 4 + 4, false);
368 ((uint32_t*) p)[1] = x;
374 static int message_append_field_uint64(sd_bus_message *m, uint64_t h, uint64_t x) {
379 /* dbus1 only allows 8bit header field ids */
383 if (BUS_MESSAGE_IS_GVARIANT(m)) {
384 /* (field id 64bit + ((value + NUL + signature string 't') */
386 p = message_extend_fields(m, 8, 8 + 8 + 1 + 1, true);
390 *((uint64_t*) p) = h;
391 *((uint64_t*) (p + 8)) = x;
395 /* (field id byte + (signature length + signature 't' + NUL) + 4 byte padding + value) */
396 p = message_extend_fields(m, 8, 4 + 4 + 8, false);
409 ((uint64_t*) p)[1] = x;
415 static int message_append_reply_cookie(sd_bus_message *m, uint64_t cookie) {
418 if (BUS_MESSAGE_IS_GVARIANT(m))
419 return message_append_field_uint64(m, BUS_MESSAGE_HEADER_REPLY_SERIAL, cookie);
421 /* 64bit cookies are not supported on dbus1 */
422 if (cookie > 0xffffffffUL)
425 return message_append_field_uint32(m, BUS_MESSAGE_HEADER_REPLY_SERIAL, (uint32_t) cookie);
429 int bus_message_from_header(
432 size_t header_accessible,
434 size_t footer_accessible,
440 sd_bus_message **ret) {
442 _cleanup_free_ sd_bus_message *m = NULL;
443 struct bus_header *h;
447 assert(header || header_accessible <= 0);
448 assert(footer || footer_accessible <= 0);
449 assert(fds || n_fds <= 0);
452 if (header_accessible < sizeof(struct bus_header))
455 if (header_accessible > message_size)
457 if (footer_accessible > message_size)
461 if (!IN_SET(h->version, 1, 2))
464 if (h->type == _SD_BUS_MESSAGE_TYPE_INVALID)
467 if (!IN_SET(h->endian, BUS_LITTLE_ENDIAN, BUS_BIG_ENDIAN))
470 /* Note that we are happy with unknown flags in the flags header! */
472 a = ALIGN(sizeof(sd_bus_message)) + ALIGN(extra);
475 label_sz = strlen(label);
486 m->header_accessible = header_accessible;
488 m->footer_accessible = footer_accessible;
490 if (BUS_MESSAGE_IS_GVARIANT(m)) {
493 if (h->dbus2.cookie == 0)
496 /* dbus2 derives the sizes from the message size and
497 the offset table at the end, since it is formatted as
498 gvariant "yyyyuta{tv}v". Since the message itself is a
499 structure with precisely to variable sized entries,
500 there's only one offset in the table, which marks the
501 end of the fields array. */
503 ws = bus_gvariant_determine_word_size(message_size, 0);
504 if (footer_accessible < ws)
507 m->fields_size = bus_gvariant_read_word_le((uint8_t*) footer + footer_accessible - ws, ws);
508 if (ALIGN8(m->fields_size) > message_size - ws)
510 if (m->fields_size < sizeof(struct bus_header))
513 m->fields_size -= sizeof(struct bus_header);
514 m->body_size = message_size - (sizeof(struct bus_header) + ALIGN8(m->fields_size));
516 if (h->dbus1.serial == 0)
519 /* dbus1 has the sizes in the header */
520 m->fields_size = BUS_MESSAGE_BSWAP32(m, h->dbus1.fields_size);
521 m->body_size = BUS_MESSAGE_BSWAP32(m, h->dbus1.body_size);
523 if (sizeof(struct bus_header) + ALIGN8(m->fields_size) + m->body_size != message_size)
531 m->creds.label = (char*) m + ALIGN(sizeof(sd_bus_message)) + ALIGN(extra);
532 memcpy(m->creds.label, label, label_sz + 1);
534 m->creds.mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
537 m->bus = sd_bus_ref(bus);
544 int bus_message_from_malloc(
551 sd_bus_message **ret) {
557 r = bus_message_from_header(
559 buffer, length, /* in this case the initial bytes and the final bytes are the same */
568 sz = length - sizeof(struct bus_header) - ALIGN8(m->fields_size);
571 m->body.data = (uint8_t*) buffer + sizeof(struct bus_header) + ALIGN8(m->fields_size);
573 m->body.sealed = true;
578 m->iovec = m->iovec_fixed;
579 m->iovec[0].iov_base = buffer;
580 m->iovec[0].iov_len = length;
582 r = bus_message_parse_fields(m);
586 /* We take possession of the memory and fds now */
587 m->free_header = true;
598 static sd_bus_message *message_new(sd_bus *bus, uint8_t type) {
603 m = malloc0(ALIGN(sizeof(sd_bus_message)) + sizeof(struct bus_header));
608 m->header = (struct bus_header*) ((uint8_t*) m + ALIGN(sizeof(struct sd_bus_message)));
609 m->header->endian = BUS_NATIVE_ENDIAN;
610 m->header->type = type;
611 m->header->version = bus ? bus->message_version : 1;
612 m->allow_fds = !bus || bus->can_fds || (bus->state != BUS_HELLO && bus->state != BUS_RUNNING);
613 m->root_container.need_offsets = BUS_MESSAGE_IS_GVARIANT(m);
614 m->bus = sd_bus_ref(bus);
616 if (bus->allow_interactive_authorization)
617 m->header->flags |= BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION;
622 _public_ int sd_bus_message_new_signal(
626 const char *interface,
627 const char *member) {
632 assert_return(bus, -ENOTCONN);
633 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
634 assert_return(object_path_is_valid(path), -EINVAL);
635 assert_return(interface_name_is_valid(interface), -EINVAL);
636 assert_return(member_name_is_valid(member), -EINVAL);
637 assert_return(m, -EINVAL);
639 t = message_new(bus, SD_BUS_MESSAGE_SIGNAL);
643 t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
645 r = message_append_field_string(t, BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path);
648 r = message_append_field_string(t, BUS_MESSAGE_HEADER_INTERFACE, SD_BUS_TYPE_STRING, interface, &t->interface);
651 r = message_append_field_string(t, BUS_MESSAGE_HEADER_MEMBER, SD_BUS_TYPE_STRING, member, &t->member);
659 sd_bus_message_unref(t);
663 _public_ int sd_bus_message_new_method_call(
666 const char *destination,
668 const char *interface,
669 const char *member) {
674 assert_return(bus, -ENOTCONN);
675 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
676 assert_return(!destination || service_name_is_valid(destination), -EINVAL);
677 assert_return(object_path_is_valid(path), -EINVAL);
678 assert_return(!interface || interface_name_is_valid(interface), -EINVAL);
679 assert_return(member_name_is_valid(member), -EINVAL);
680 assert_return(m, -EINVAL);
682 t = message_new(bus, SD_BUS_MESSAGE_METHOD_CALL);
686 r = message_append_field_string(t, BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path);
689 r = message_append_field_string(t, BUS_MESSAGE_HEADER_MEMBER, SD_BUS_TYPE_STRING, member, &t->member);
694 r = message_append_field_string(t, BUS_MESSAGE_HEADER_INTERFACE, SD_BUS_TYPE_STRING, interface, &t->interface);
700 r = message_append_field_string(t, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &t->destination);
713 static int message_new_reply(
714 sd_bus_message *call,
716 sd_bus_message **m) {
721 assert_return(call, -EINVAL);
722 assert_return(call->sealed, -EPERM);
723 assert_return(call->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
724 assert_return(call->bus->state != BUS_UNSET, -ENOTCONN);
725 assert_return(m, -EINVAL);
727 t = message_new(call->bus, type);
731 t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
732 t->reply_cookie = BUS_MESSAGE_COOKIE(call);
733 if (t->reply_cookie == 0)
736 r = message_append_reply_cookie(t, t->reply_cookie);
741 r = message_append_field_string(t, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, call->sender, &t->destination);
746 t->dont_send = !!(call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED);
747 t->enforced_reply_signature = call->enforced_reply_signature;
757 _public_ int sd_bus_message_new_method_return(
758 sd_bus_message *call,
759 sd_bus_message **m) {
761 return message_new_reply(call, SD_BUS_MESSAGE_METHOD_RETURN, m);
764 _public_ int sd_bus_message_new_method_error(
765 sd_bus_message *call,
767 const sd_bus_error *e) {
772 assert_return(sd_bus_error_is_set(e), -EINVAL);
773 assert_return(m, -EINVAL);
775 r = message_new_reply(call, SD_BUS_MESSAGE_METHOD_ERROR, &t);
779 r = message_append_field_string(t, BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, e->name, &t->error.name);
784 r = message_append_basic(t, SD_BUS_TYPE_STRING, e->message, (const void**) &t->error.message);
789 t->error._need_free = -1;
799 _public_ int sd_bus_message_new_method_errorf(
800 sd_bus_message *call,
806 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
809 assert_return(name, -EINVAL);
810 assert_return(m, -EINVAL);
812 va_start(ap, format);
813 bus_error_setfv(&error, name, format, ap);
816 return sd_bus_message_new_method_error(call, m, &error);
819 _public_ int sd_bus_message_new_method_errno(
820 sd_bus_message *call,
823 const sd_bus_error *p) {
825 _cleanup_bus_error_free_ sd_bus_error berror = SD_BUS_ERROR_NULL;
827 if (sd_bus_error_is_set(p))
828 return sd_bus_message_new_method_error(call, m, p);
830 sd_bus_error_set_errno(&berror, error);
832 return sd_bus_message_new_method_error(call, m, &berror);
835 _public_ int sd_bus_message_new_method_errnof(
836 sd_bus_message *call,
842 _cleanup_bus_error_free_ sd_bus_error berror = SD_BUS_ERROR_NULL;
845 va_start(ap, format);
846 sd_bus_error_set_errnofv(&berror, error, format, ap);
849 return sd_bus_message_new_method_error(call, m, &berror);
852 void bus_message_set_sender_local(sd_bus *bus, sd_bus_message *m) {
856 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus.Local";
857 m->creds.well_known_names_local = true;
858 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
861 void bus_message_set_sender_driver(sd_bus *bus, sd_bus_message *m) {
865 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
866 m->creds.well_known_names_driver = true;
867 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
870 int bus_message_new_synthetic_error(
873 const sd_bus_error *e,
874 sd_bus_message **m) {
880 assert(sd_bus_error_is_set(e));
883 t = message_new(bus, SD_BUS_MESSAGE_METHOD_ERROR);
887 t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
888 t->reply_cookie = cookie;
890 r = message_append_reply_cookie(t, t->reply_cookie);
894 if (bus && bus->unique_name) {
895 r = message_append_field_string(t, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, bus->unique_name, &t->destination);
900 r = message_append_field_string(t, BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, e->name, &t->error.name);
905 r = message_append_basic(t, SD_BUS_TYPE_STRING, e->message, (const void**) &t->error.message);
910 t->error._need_free = -1;
912 bus_message_set_sender_driver(bus, t);
922 _public_ sd_bus_message* sd_bus_message_ref(sd_bus_message *m) {
923 assert_return(m, NULL);
925 assert(m->n_ref > 0);
931 _public_ sd_bus_message* sd_bus_message_unref(sd_bus_message *m) {
936 assert(m->n_ref > 0);
946 _public_ int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type) {
947 assert_return(m, -EINVAL);
948 assert_return(type, -EINVAL);
950 *type = m->header->type;
954 _public_ int sd_bus_message_get_cookie(sd_bus_message *m, uint64_t *cookie) {
957 assert_return(m, -EINVAL);
958 assert_return(cookie, -EINVAL);
960 c = BUS_MESSAGE_COOKIE(m);
964 *cookie = BUS_MESSAGE_COOKIE(m);
968 _public_ int sd_bus_message_get_reply_cookie(sd_bus_message *m, uint64_t *cookie) {
969 assert_return(m, -EINVAL);
970 assert_return(cookie, -EINVAL);
972 if (m->reply_cookie == 0)
975 *cookie = m->reply_cookie;
979 _public_ int sd_bus_message_get_expect_reply(sd_bus_message *m) {
980 assert_return(m, -EINVAL);
982 return m->header->type == SD_BUS_MESSAGE_METHOD_CALL &&
983 !(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED);
986 _public_ int sd_bus_message_get_auto_start(sd_bus_message *m) {
987 assert_return(m, -EINVAL);
989 return !(m->header->flags & BUS_MESSAGE_NO_AUTO_START);
992 _public_ int sd_bus_message_get_allow_interactive_authorization(sd_bus_message *m) {
993 assert_return(m, -EINVAL);
995 return m->header->type == SD_BUS_MESSAGE_METHOD_CALL &&
996 (m->header->flags & BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION);
999 _public_ const char *sd_bus_message_get_path(sd_bus_message *m) {
1000 assert_return(m, NULL);
1005 _public_ const char *sd_bus_message_get_interface(sd_bus_message *m) {
1006 assert_return(m, NULL);
1008 return m->interface;
1011 _public_ const char *sd_bus_message_get_member(sd_bus_message *m) {
1012 assert_return(m, NULL);
1017 _public_ const char *sd_bus_message_get_destination(sd_bus_message *m) {
1018 assert_return(m, NULL);
1020 return m->destination;
1023 _public_ const char *sd_bus_message_get_sender(sd_bus_message *m) {
1024 assert_return(m, NULL);
1029 _public_ const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) {
1030 assert_return(m, NULL);
1031 assert_return(sd_bus_error_is_set(&m->error), NULL);
1036 _public_ int sd_bus_message_get_monotonic_usec(sd_bus_message *m, uint64_t *usec) {
1037 assert_return(m, -EINVAL);
1038 assert_return(usec, -EINVAL);
1040 if (m->monotonic <= 0)
1043 *usec = m->monotonic;
1047 _public_ int sd_bus_message_get_realtime_usec(sd_bus_message *m, uint64_t *usec) {
1048 assert_return(m, -EINVAL);
1049 assert_return(usec, -EINVAL);
1051 if (m->realtime <= 0)
1054 *usec = m->realtime;
1058 _public_ int sd_bus_message_get_seqnum(sd_bus_message *m, uint64_t *seqnum) {
1059 assert_return(m, -EINVAL);
1060 assert_return(seqnum, -EINVAL);
1065 *seqnum = m->seqnum;
1069 _public_ sd_bus_creds *sd_bus_message_get_creds(sd_bus_message *m) {
1070 assert_return(m, NULL);
1072 if (m->creds.mask == 0)
1078 _public_ int sd_bus_message_is_signal(
1080 const char *interface,
1081 const char *member) {
1083 assert_return(m, -EINVAL);
1085 if (m->header->type != SD_BUS_MESSAGE_SIGNAL)
1088 if (interface && (!m->interface || !streq(m->interface, interface)))
1091 if (member && (!m->member || !streq(m->member, member)))
1097 _public_ int sd_bus_message_is_method_call(
1099 const char *interface,
1100 const char *member) {
1102 assert_return(m, -EINVAL);
1104 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
1107 if (interface && (!m->interface || !streq(m->interface, interface)))
1110 if (member && (!m->member || !streq(m->member, member)))
1116 _public_ int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) {
1117 assert_return(m, -EINVAL);
1119 if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
1122 if (name && (!m->error.name || !streq(m->error.name, name)))
1128 _public_ int sd_bus_message_set_expect_reply(sd_bus_message *m, int b) {
1129 assert_return(m, -EINVAL);
1130 assert_return(!m->sealed, -EPERM);
1131 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EPERM);
1134 m->header->flags &= ~BUS_MESSAGE_NO_REPLY_EXPECTED;
1136 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1141 _public_ int sd_bus_message_set_auto_start(sd_bus_message *m, int b) {
1142 assert_return(m, -EINVAL);
1143 assert_return(!m->sealed, -EPERM);
1146 m->header->flags &= ~BUS_MESSAGE_NO_AUTO_START;
1148 m->header->flags |= BUS_MESSAGE_NO_AUTO_START;
1153 _public_ int sd_bus_message_set_allow_interactive_authorization(sd_bus_message *m, int b) {
1154 assert_return(m, -EINVAL);
1155 assert_return(!m->sealed, -EPERM);
1158 m->header->flags |= BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION;
1160 m->header->flags &= ~BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION;
1165 static struct bus_container *message_get_container(sd_bus_message *m) {
1168 if (m->n_containers == 0)
1169 return &m->root_container;
1171 assert(m->containers);
1172 return m->containers + m->n_containers - 1;
1175 struct bus_body_part *message_append_part(sd_bus_message *m) {
1176 struct bus_body_part *part;
1183 if (m->n_body_parts <= 0) {
1187 assert(m->body_end);
1189 part = new0(struct bus_body_part, 1);
1195 m->body_end->next = part;
1205 static void part_zero(struct bus_body_part *part, size_t sz) {
1210 /* All other fields can be left in their defaults */
1211 assert(!part->data);
1212 assert(part->memfd < 0);
1215 part->is_zero = true;
1216 part->sealed = true;
1219 static int part_make_space(
1220 struct sd_bus_message *m,
1221 struct bus_body_part *part,
1230 assert(!part->sealed);
1235 if (!part->data && part->memfd < 0) {
1236 part->memfd = bus_kernel_pop_memfd(m->bus, &part->data, &part->mapped, &part->allocated);
1237 part->mmap_begin = part->data;
1240 if (part->memfd >= 0) {
1242 if (part->allocated == 0 || sz > part->allocated) {
1243 uint64_t new_allocated;
1245 new_allocated = PAGE_ALIGN(sz > 0 ? 2 * sz : 1);
1246 r = memfd_set_size(part->memfd, new_allocated);
1252 part->allocated = new_allocated;
1255 if (!part->data || sz > part->mapped) {
1258 psz = PAGE_ALIGN(sz > 0 ? sz : 1);
1259 if (part->mapped <= 0)
1260 n = mmap(NULL, psz, PROT_READ|PROT_WRITE, MAP_SHARED, part->memfd, 0);
1262 n = mremap(part->mmap_begin, part->mapped, psz, MREMAP_MAYMOVE);
1264 if (n == MAP_FAILED) {
1269 part->mmap_begin = part->data = n;
1271 part->memfd_offset = 0;
1274 part->munmap_this = true;
1276 if (part->allocated == 0 || sz > part->allocated) {
1277 size_t new_allocated;
1279 new_allocated = sz > 0 ? 2 * sz : 64;
1280 n = realloc(part->data, new_allocated);
1287 part->allocated = new_allocated;
1288 part->free_this = true;
1293 *q = part->data ? (uint8_t*) part->data + part->size : NULL;
1299 static int message_add_offset(sd_bus_message *m, size_t offset) {
1300 struct bus_container *c;
1303 assert(BUS_MESSAGE_IS_GVARIANT(m));
1305 /* Add offset to current container, unless this is the first
1306 * item in it, which will have the 0 offset, which we can
1308 c = message_get_container(m);
1310 if (!c->need_offsets)
1313 if (!GREEDY_REALLOC(c->offsets, c->offsets_allocated, c->n_offsets + 1))
1316 c->offsets[c->n_offsets++] = offset;
1320 static void message_extend_containers(sd_bus_message *m, size_t expand) {
1321 struct bus_container *c;
1328 /* Update counters */
1329 for (c = m->containers; c < m->containers + m->n_containers; c++) {
1332 *c->array_size += expand;
1336 static void *message_extend_body(
1341 bool force_inline) {
1343 size_t start_body, end_body, padding, added;
1354 start_body = ALIGN_TO((size_t) m->body_size, align);
1355 end_body = start_body + sz;
1357 padding = start_body - m->body_size;
1358 added = padding + sz;
1360 /* Check for 32bit overflows */
1361 if (end_body > (size_t) ((uint32_t) -1) ||
1362 end_body < start_body) {
1368 struct bus_body_part *part = NULL;
1372 m->n_body_parts <= 0 ||
1373 m->body_end->sealed ||
1374 (padding != ALIGN_TO(m->body_end->size, align) - m->body_end->size) ||
1375 (force_inline && m->body_end->size > MEMFD_MIN_SIZE); /* if this must be an inlined extension, let's create a new part if the previous part is large enough to be inlined */
1379 part = message_append_part(m);
1383 part_zero(part, padding);
1386 part = message_append_part(m);
1390 r = part_make_space(m, part, sz, &p);
1394 struct bus_container *c;
1396 size_t os, start_part, end_part;
1402 start_part = ALIGN_TO(part->size, align);
1403 end_part = start_part + sz;
1405 r = part_make_space(m, part, end_part, &p);
1410 memzero(p, padding);
1411 p = (uint8_t*) p + padding;
1414 /* Readjust pointers */
1415 for (c = m->containers; c < m->containers + m->n_containers; c++)
1416 c->array_size = adjust_pointer(c->array_size, op, os, part->data);
1418 m->error.message = (const char*) adjust_pointer(m->error.message, op, os, part->data);
1421 /* Return something that is not NULL and is aligned */
1422 p = (uint8_t *) NULL + align;
1424 m->body_size = end_body;
1425 message_extend_containers(m, added);
1428 r = message_add_offset(m, end_body);
1438 static int message_push_fd(sd_bus_message *m, int fd) {
1449 copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
1453 f = realloc(m->fds, sizeof(int) * (m->n_fds + 1));
1461 m->fds[m->n_fds] = copy;
1467 int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored) {
1468 _cleanup_close_ int fd = -1;
1469 struct bus_container *c;
1473 assert_return(m, -EINVAL);
1474 assert_return(!m->sealed, -EPERM);
1475 assert_return(bus_type_is_basic(type), -EINVAL);
1476 assert_return(!m->poisoned, -ESTALE);
1478 c = message_get_container(m);
1480 if (c->signature && c->signature[c->index]) {
1481 /* Container signature is already set */
1483 if (c->signature[c->index] != type)
1488 /* Maybe we can append to the signature? But only if this is the top-level container */
1489 if (c->enclosing != 0)
1492 e = strextend(&c->signature, CHAR_TO_STR(type), NULL);
1499 if (BUS_MESSAGE_IS_GVARIANT(m)) {
1505 case SD_BUS_TYPE_SIGNATURE:
1506 case SD_BUS_TYPE_STRING:
1509 /* Fall through... */
1510 case SD_BUS_TYPE_OBJECT_PATH:
1518 case SD_BUS_TYPE_BOOLEAN:
1520 u8 = p && *(int*) p;
1526 case SD_BUS_TYPE_UNIX_FD:
1531 fd = message_push_fd(m, *(int*) p);
1542 align = bus_gvariant_get_alignment(CHAR_TO_STR(type));
1543 sz = bus_gvariant_get_size(CHAR_TO_STR(type));
1550 a = message_extend_body(m, align, sz, true, false);
1557 *stored = (const uint8_t*) a;
1564 case SD_BUS_TYPE_STRING:
1565 /* To make things easy we'll serialize a NULL string
1566 * into the empty string */
1569 /* Fall through... */
1570 case SD_BUS_TYPE_OBJECT_PATH:
1576 sz = 4 + strlen(p) + 1;
1579 case SD_BUS_TYPE_SIGNATURE:
1584 sz = 1 + strlen(p) + 1;
1587 case SD_BUS_TYPE_BOOLEAN:
1589 u32 = p && *(int*) p;
1595 case SD_BUS_TYPE_UNIX_FD:
1600 fd = message_push_fd(m, *(int*) p);
1611 align = bus_type_get_alignment(type);
1612 sz = bus_type_get_size(type);
1619 a = message_extend_body(m, align, sz, false, false);
1623 if (type == SD_BUS_TYPE_STRING || type == SD_BUS_TYPE_OBJECT_PATH) {
1624 *(uint32_t*) a = sz - 5;
1625 memcpy((uint8_t*) a + 4, p, sz - 4);
1628 *stored = (const uint8_t*) a + 4;
1630 } else if (type == SD_BUS_TYPE_SIGNATURE) {
1631 *(uint8_t*) a = sz - 2;
1632 memcpy((uint8_t*) a + 1, p, sz - 1);
1635 *stored = (const uint8_t*) a + 1;
1644 if (type == SD_BUS_TYPE_UNIX_FD)
1647 if (c->enclosing != SD_BUS_TYPE_ARRAY)
1654 _public_ int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p) {
1655 return message_append_basic(m, type, p, NULL);
1658 _public_ int sd_bus_message_append_string_space(
1663 struct bus_container *c;
1666 assert_return(m, -EINVAL);
1667 assert_return(s, -EINVAL);
1668 assert_return(!m->sealed, -EPERM);
1669 assert_return(!m->poisoned, -ESTALE);
1671 c = message_get_container(m);
1673 if (c->signature && c->signature[c->index]) {
1674 /* Container signature is already set */
1676 if (c->signature[c->index] != SD_BUS_TYPE_STRING)
1681 /* Maybe we can append to the signature? But only if this is the top-level container */
1682 if (c->enclosing != 0)
1685 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRING), NULL);
1692 if (BUS_MESSAGE_IS_GVARIANT(m)) {
1693 a = message_extend_body(m, 1, size + 1, true, false);
1699 a = message_extend_body(m, 4, 4 + size + 1, false, false);
1703 *(uint32_t*) a = size;
1709 if (c->enclosing != SD_BUS_TYPE_ARRAY)
1715 _public_ int sd_bus_message_append_string_iovec(
1717 const struct iovec *iov,
1725 assert_return(m, -EINVAL);
1726 assert_return(!m->sealed, -EPERM);
1727 assert_return(iov || n == 0, -EINVAL);
1728 assert_return(!m->poisoned, -ESTALE);
1730 size = IOVEC_TOTAL_SIZE(iov, n);
1732 r = sd_bus_message_append_string_space(m, size, &p);
1736 for (i = 0; i < n; i++) {
1738 if (iov[i].iov_base)
1739 memcpy(p, iov[i].iov_base, iov[i].iov_len);
1741 memset(p, ' ', iov[i].iov_len);
1743 p += iov[i].iov_len;
1749 static int bus_message_open_array(
1751 struct bus_container *c,
1752 const char *contents,
1753 uint32_t **array_size,
1755 bool *need_offsets) {
1765 assert(need_offsets);
1767 if (!signature_is_single(contents, true))
1770 if (c->signature && c->signature[c->index]) {
1772 /* Verify the existing signature */
1774 if (c->signature[c->index] != SD_BUS_TYPE_ARRAY)
1777 if (!startswith(c->signature + c->index + 1, contents))
1780 nindex = c->index + 1 + strlen(contents);
1784 if (c->enclosing != 0)
1787 /* Extend the existing signature */
1789 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_ARRAY), contents, NULL);
1795 nindex = e - c->signature;
1798 if (BUS_MESSAGE_IS_GVARIANT(m)) {
1799 alignment = bus_gvariant_get_alignment(contents);
1803 /* Add alignment padding and add to offset list */
1804 if (!message_extend_body(m, alignment, 0, false, false))
1807 r = bus_gvariant_is_fixed_size(contents);
1811 *begin = m->body_size;
1812 *need_offsets = r == 0;
1816 struct bus_body_part *o;
1818 alignment = bus_type_get_alignment(contents[0]);
1822 a = message_extend_body(m, 4, 4, false, false);
1827 op = m->body_end->data;
1828 os = m->body_end->size;
1830 /* Add alignment between size and first element */
1831 if (!message_extend_body(m, alignment, 0, false, false))
1834 /* location of array size might have changed so let's readjust a */
1835 if (o == m->body_end)
1836 a = adjust_pointer(a, op, os, m->body_end->data);
1842 if (c->enclosing != SD_BUS_TYPE_ARRAY)
1848 static int bus_message_open_variant(
1850 struct bus_container *c,
1851 const char *contents) {
1857 if (!signature_is_single(contents, false))
1860 if (*contents == SD_BUS_TYPE_DICT_ENTRY_BEGIN)
1863 if (c->signature && c->signature[c->index]) {
1865 if (c->signature[c->index] != SD_BUS_TYPE_VARIANT)
1871 if (c->enclosing != 0)
1874 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_VARIANT), NULL);
1881 if (BUS_MESSAGE_IS_GVARIANT(m)) {
1882 /* Variants are always aligned to 8 */
1884 if (!message_extend_body(m, 8, 0, false, false))
1891 l = strlen(contents);
1892 a = message_extend_body(m, 1, 1 + l + 1, false, false);
1897 memcpy((uint8_t*) a + 1, contents, l + 1);
1900 if (c->enclosing != SD_BUS_TYPE_ARRAY)
1906 static int bus_message_open_struct(
1908 struct bus_container *c,
1909 const char *contents,
1911 bool *need_offsets) {
1920 assert(need_offsets);
1922 if (!signature_is_valid(contents, false))
1925 if (c->signature && c->signature[c->index]) {
1928 l = strlen(contents);
1930 if (c->signature[c->index] != SD_BUS_TYPE_STRUCT_BEGIN ||
1931 !startswith(c->signature + c->index + 1, contents) ||
1932 c->signature[c->index + 1 + l] != SD_BUS_TYPE_STRUCT_END)
1935 nindex = c->index + 1 + l + 1;
1939 if (c->enclosing != 0)
1942 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_BEGIN), contents, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_END), NULL);
1948 nindex = e - c->signature;
1951 if (BUS_MESSAGE_IS_GVARIANT(m)) {
1954 alignment = bus_gvariant_get_alignment(contents);
1958 if (!message_extend_body(m, alignment, 0, false, false))
1961 r = bus_gvariant_is_fixed_size(contents);
1965 *begin = m->body_size;
1966 *need_offsets = r == 0;
1968 /* Align contents to 8 byte boundary */
1969 if (!message_extend_body(m, 8, 0, false, false))
1973 if (c->enclosing != SD_BUS_TYPE_ARRAY)
1979 static int bus_message_open_dict_entry(
1981 struct bus_container *c,
1982 const char *contents,
1984 bool *need_offsets) {
1992 assert(need_offsets);
1994 if (!signature_is_pair(contents))
1997 if (c->enclosing != SD_BUS_TYPE_ARRAY)
2000 if (c->signature && c->signature[c->index]) {
2003 l = strlen(contents);
2005 if (c->signature[c->index] != SD_BUS_TYPE_DICT_ENTRY_BEGIN ||
2006 !startswith(c->signature + c->index + 1, contents) ||
2007 c->signature[c->index + 1 + l] != SD_BUS_TYPE_DICT_ENTRY_END)
2012 if (BUS_MESSAGE_IS_GVARIANT(m)) {
2015 alignment = bus_gvariant_get_alignment(contents);
2019 if (!message_extend_body(m, alignment, 0, false, false))
2022 r = bus_gvariant_is_fixed_size(contents);
2026 *begin = m->body_size;
2027 *need_offsets = r == 0;
2029 /* Align contents to 8 byte boundary */
2030 if (!message_extend_body(m, 8, 0, false, false))
2037 _public_ int sd_bus_message_open_container(
2040 const char *contents) {
2042 struct bus_container *c, *w;
2043 uint32_t *array_size = NULL;
2045 size_t before, begin = 0;
2046 bool need_offsets = false;
2049 assert_return(m, -EINVAL);
2050 assert_return(!m->sealed, -EPERM);
2051 assert_return(contents, -EINVAL);
2052 assert_return(!m->poisoned, -ESTALE);
2054 /* Make sure we have space for one more container */
2055 if (!GREEDY_REALLOC(m->containers, m->containers_allocated, m->n_containers + 1)) {
2060 c = message_get_container(m);
2062 signature = strdup(contents);
2068 /* Save old index in the parent container, in case we have to
2069 * abort this container */
2070 c->saved_index = c->index;
2071 before = m->body_size;
2073 if (type == SD_BUS_TYPE_ARRAY)
2074 r = bus_message_open_array(m, c, contents, &array_size, &begin, &need_offsets);
2075 else if (type == SD_BUS_TYPE_VARIANT)
2076 r = bus_message_open_variant(m, c, contents);
2077 else if (type == SD_BUS_TYPE_STRUCT)
2078 r = bus_message_open_struct(m, c, contents, &begin, &need_offsets);
2079 else if (type == SD_BUS_TYPE_DICT_ENTRY)
2080 r = bus_message_open_dict_entry(m, c, contents, &begin, &need_offsets);
2089 /* OK, let's fill it in */
2090 w = m->containers + m->n_containers++;
2091 w->enclosing = type;
2092 w->signature = signature;
2094 w->array_size = array_size;
2097 w->n_offsets = w->offsets_allocated = 0;
2099 w->need_offsets = need_offsets;
2104 static int bus_message_close_array(sd_bus_message *m, struct bus_container *c) {
2109 if (!BUS_MESSAGE_IS_GVARIANT(m))
2112 if (c->need_offsets) {
2113 size_t payload, sz, i;
2116 /* Variable-width arrays */
2118 payload = c->n_offsets > 0 ? c->offsets[c->n_offsets-1] - c->begin : 0;
2119 sz = bus_gvariant_determine_word_size(payload, c->n_offsets);
2121 a = message_extend_body(m, 1, sz * c->n_offsets, true, false);
2125 for (i = 0; i < c->n_offsets; i++)
2126 bus_gvariant_write_word_le(a + sz*i, sz, c->offsets[i] - c->begin);
2130 /* Fixed-width or empty arrays */
2132 a = message_extend_body(m, 1, 0, true, false); /* let's add offset to parent */
2140 static int bus_message_close_variant(sd_bus_message *m, struct bus_container *c) {
2146 assert(c->signature);
2148 if (!BUS_MESSAGE_IS_GVARIANT(m))
2151 l = strlen(c->signature);
2153 a = message_extend_body(m, 1, 1 + l, true, false);
2158 memcpy(a+1, c->signature, l);
2163 static int bus_message_close_struct(sd_bus_message *m, struct bus_container *c, bool add_offset) {
2164 bool fixed_size = true;
2165 size_t n_variable = 0;
2174 if (!BUS_MESSAGE_IS_GVARIANT(m))
2177 p = strempty(c->signature);
2181 r = signature_element_length(p, &n);
2190 r = bus_gvariant_is_fixed_size(t);
2195 assert(!c->need_offsets || i <= c->n_offsets);
2197 /* We need to add an offset for each item that has a
2198 * variable size and that is not the last one in the
2202 if (r == 0 && p[n] != 0)
2209 assert(!c->need_offsets || i == c->n_offsets);
2210 assert(c->need_offsets || n_variable == 0);
2212 if (n_variable <= 0) {
2215 /* Structures with fixed-size members only have to be
2216 * fixed-size themselves. But gvariant requires all fixed-size
2217 * elements to be sized a multiple of their alignment. Hence,
2218 * we must *always* add final padding after the last member so
2219 * the overall size of the structure is properly aligned. */
2221 alignment = bus_gvariant_get_alignment(strempty(c->signature));
2223 assert(alignment > 0);
2225 a = message_extend_body(m, alignment, 0, add_offset, false);
2232 assert(c->offsets[c->n_offsets-1] == m->body_size);
2234 sz = bus_gvariant_determine_word_size(m->body_size - c->begin, n_variable);
2236 a = message_extend_body(m, 1, sz * n_variable, add_offset, false);
2240 p = strempty(c->signature);
2241 for (i = 0, j = 0; i < c->n_offsets; i++) {
2245 r = signature_element_length(p, &n);
2256 r = bus_gvariant_is_fixed_size(t);
2259 if (r > 0 || p[0] == 0)
2263 k = n_variable - 1 - j;
2265 bus_gvariant_write_word_le(a + k * sz, sz, c->offsets[i] - c->begin);
2274 _public_ int sd_bus_message_close_container(sd_bus_message *m) {
2275 struct bus_container *c;
2278 assert_return(m, -EINVAL);
2279 assert_return(!m->sealed, -EPERM);
2280 assert_return(m->n_containers > 0, -EINVAL);
2281 assert_return(!m->poisoned, -ESTALE);
2283 c = message_get_container(m);
2285 if (c->enclosing != SD_BUS_TYPE_ARRAY)
2286 if (c->signature && c->signature[c->index] != 0)
2291 if (c->enclosing == SD_BUS_TYPE_ARRAY)
2292 r = bus_message_close_array(m, c);
2293 else if (c->enclosing == SD_BUS_TYPE_VARIANT)
2294 r = bus_message_close_variant(m, c);
2295 else if (c->enclosing == SD_BUS_TYPE_STRUCT || c->enclosing == SD_BUS_TYPE_DICT_ENTRY)
2296 r = bus_message_close_struct(m, c, true);
2298 assert_not_reached("Unknown container type");
2312 static int type_stack_push(TypeStack *stack, unsigned max, unsigned *i, const char *types, unsigned n_struct, unsigned n_array) {
2319 stack[*i].types = types;
2320 stack[*i].n_struct = n_struct;
2321 stack[*i].n_array = n_array;
2327 static int type_stack_pop(TypeStack *stack, unsigned max, unsigned *i, const char **types, unsigned *n_struct, unsigned *n_array) {
2338 *types = stack[*i].types;
2339 *n_struct = stack[*i].n_struct;
2340 *n_array = stack[*i].n_array;
2345 int bus_message_append_ap(
2350 unsigned n_array, n_struct;
2351 TypeStack stack[BUS_CONTAINER_DEPTH];
2352 unsigned stack_ptr = 0;
2360 n_array = (unsigned) -1;
2361 n_struct = strlen(types);
2366 if (n_array == 0 || (n_array == (unsigned) -1 && n_struct == 0)) {
2367 r = type_stack_pop(stack, ELEMENTSOF(stack), &stack_ptr, &types, &n_struct, &n_array);
2373 r = sd_bus_message_close_container(m);
2381 if (n_array != (unsigned) -1)
2390 case SD_BUS_TYPE_BYTE: {
2393 x = (uint8_t) va_arg(ap, int);
2394 r = sd_bus_message_append_basic(m, *t, &x);
2398 case SD_BUS_TYPE_BOOLEAN:
2399 case SD_BUS_TYPE_INT32:
2400 case SD_BUS_TYPE_UINT32:
2401 case SD_BUS_TYPE_UNIX_FD: {
2404 /* We assume a boolean is the same as int32_t */
2405 assert_cc(sizeof(int32_t) == sizeof(int));
2407 x = va_arg(ap, uint32_t);
2408 r = sd_bus_message_append_basic(m, *t, &x);
2412 case SD_BUS_TYPE_INT16:
2413 case SD_BUS_TYPE_UINT16: {
2416 x = (uint16_t) va_arg(ap, int);
2417 r = sd_bus_message_append_basic(m, *t, &x);
2421 case SD_BUS_TYPE_INT64:
2422 case SD_BUS_TYPE_UINT64: {
2425 x = va_arg(ap, uint64_t);
2426 r = sd_bus_message_append_basic(m, *t, &x);
2430 case SD_BUS_TYPE_DOUBLE: {
2433 x = va_arg(ap, double);
2434 r = sd_bus_message_append_basic(m, *t, &x);
2438 case SD_BUS_TYPE_STRING:
2439 case SD_BUS_TYPE_OBJECT_PATH:
2440 case SD_BUS_TYPE_SIGNATURE: {
2443 x = va_arg(ap, const char*);
2444 r = sd_bus_message_append_basic(m, *t, x);
2448 case SD_BUS_TYPE_ARRAY: {
2451 r = signature_element_length(t + 1, &k);
2457 memcpy(s, t + 1, k);
2460 r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, s);
2465 if (n_array == (unsigned) -1) {
2470 r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
2476 n_array = va_arg(ap, unsigned);
2481 case SD_BUS_TYPE_VARIANT: {
2484 s = va_arg(ap, const char*);
2488 r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, s);
2492 r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
2497 n_struct = strlen(s);
2498 n_array = (unsigned) -1;
2503 case SD_BUS_TYPE_STRUCT_BEGIN:
2504 case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
2507 r = signature_element_length(t, &k);
2514 memcpy(s, t + 1, k - 2);
2517 r = sd_bus_message_open_container(m, *t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
2522 if (n_array == (unsigned) -1) {
2527 r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
2533 n_array = (unsigned) -1;
2549 _public_ int sd_bus_message_append(sd_bus_message *m, const char *types, ...) {
2553 assert_return(m, -EINVAL);
2554 assert_return(types, -EINVAL);
2555 assert_return(!m->sealed, -EPERM);
2556 assert_return(!m->poisoned, -ESTALE);
2558 va_start(ap, types);
2559 r = bus_message_append_ap(m, types, ap);
2565 _public_ int sd_bus_message_append_array_space(
2575 assert_return(m, -EINVAL);
2576 assert_return(!m->sealed, -EPERM);
2577 assert_return(bus_type_is_trivial(type) && type != SD_BUS_TYPE_BOOLEAN, -EINVAL);
2578 assert_return(ptr || size == 0, -EINVAL);
2579 assert_return(!m->poisoned, -ESTALE);
2581 /* alignment and size of the trivial types (except bool) is
2582 * identical for gvariant and dbus1 marshalling */
2583 align = bus_type_get_alignment(type);
2584 sz = bus_type_get_size(type);
2586 assert_se(align > 0);
2592 r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
2596 a = message_extend_body(m, align, size, false, false);
2600 r = sd_bus_message_close_container(m);
2608 _public_ int sd_bus_message_append_array(
2616 assert_return(m, -EINVAL);
2617 assert_return(!m->sealed, -EPERM);
2618 assert_return(bus_type_is_trivial(type), -EINVAL);
2619 assert_return(ptr || size == 0, -EINVAL);
2620 assert_return(!m->poisoned, -ESTALE);
2622 r = sd_bus_message_append_array_space(m, type, size, &p);
2627 memcpy(p, ptr, size);
2632 _public_ int sd_bus_message_append_array_iovec(
2635 const struct iovec *iov,
2643 assert_return(m, -EINVAL);
2644 assert_return(!m->sealed, -EPERM);
2645 assert_return(bus_type_is_trivial(type), -EINVAL);
2646 assert_return(iov || n == 0, -EINVAL);
2647 assert_return(!m->poisoned, -ESTALE);
2649 size = IOVEC_TOTAL_SIZE(iov, n);
2651 r = sd_bus_message_append_array_space(m, type, size, &p);
2655 for (i = 0; i < n; i++) {
2657 if (iov[i].iov_base)
2658 memcpy(p, iov[i].iov_base, iov[i].iov_len);
2660 memzero(p, iov[i].iov_len);
2662 p = (uint8_t*) p + iov[i].iov_len;
2668 _public_ int sd_bus_message_append_array_memfd(
2675 _cleanup_close_ int copy_fd = -1;
2676 struct bus_body_part *part;
2682 assert_return(m, -EINVAL);
2683 assert_return(memfd >= 0, -EINVAL);
2684 assert_return(bus_type_is_trivial(type), -EINVAL);
2685 assert_return(size > 0, -EINVAL);
2686 assert_return(!m->sealed, -EPERM);
2687 assert_return(!m->poisoned, -ESTALE);
2689 r = memfd_set_sealed(memfd);
2693 copy_fd = dup(memfd);
2697 r = memfd_get_size(memfd, &real_size);
2701 if (offset == 0 && size == (uint64_t) -1)
2703 else if (offset + size > real_size)
2706 align = bus_type_get_alignment(type);
2707 sz = bus_type_get_size(type);
2709 assert_se(align > 0);
2712 if (offset % align != 0)
2718 if (size > (uint64_t) (uint32_t) -1)
2721 r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
2725 a = message_extend_body(m, align, 0, false, false);
2729 part = message_append_part(m);
2733 part->memfd = copy_fd;
2734 part->memfd_offset = offset;
2735 part->sealed = true;
2739 m->body_size += size;
2740 message_extend_containers(m, size);
2742 return sd_bus_message_close_container(m);
2745 _public_ int sd_bus_message_append_string_memfd(
2751 _cleanup_close_ int copy_fd = -1;
2752 struct bus_body_part *part;
2753 struct bus_container *c;
2758 assert_return(m, -EINVAL);
2759 assert_return(memfd >= 0, -EINVAL);
2760 assert_return(size > 0, -EINVAL);
2761 assert_return(!m->sealed, -EPERM);
2762 assert_return(!m->poisoned, -ESTALE);
2764 r = memfd_set_sealed(memfd);
2768 copy_fd = dup(memfd);
2772 r = memfd_get_size(memfd, &real_size);
2776 if (offset == 0 && size == (uint64_t) -1)
2778 else if (offset + size > real_size)
2781 /* We require this to be NUL terminated */
2785 if (size > (uint64_t) (uint32_t) -1)
2788 c = message_get_container(m);
2789 if (c->signature && c->signature[c->index]) {
2790 /* Container signature is already set */
2792 if (c->signature[c->index] != SD_BUS_TYPE_STRING)
2797 /* Maybe we can append to the signature? But only if this is the top-level container */
2798 if (c->enclosing != 0)
2801 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRING), NULL);
2808 if (!BUS_MESSAGE_IS_GVARIANT(m)) {
2809 a = message_extend_body(m, 4, 4, false, false);
2813 *(uint32_t*) a = size - 1;
2816 part = message_append_part(m);
2820 part->memfd = copy_fd;
2821 part->memfd_offset = offset;
2822 part->sealed = true;
2826 m->body_size += size;
2827 message_extend_containers(m, size);
2829 if (BUS_MESSAGE_IS_GVARIANT(m)) {
2830 r = message_add_offset(m, m->body_size);
2837 if (c->enclosing != SD_BUS_TYPE_ARRAY)
2843 _public_ int sd_bus_message_append_strv(sd_bus_message *m, char **l) {
2847 assert_return(m, -EINVAL);
2848 assert_return(!m->sealed, -EPERM);
2849 assert_return(!m->poisoned, -ESTALE);
2851 r = sd_bus_message_open_container(m, 'a', "s");
2855 STRV_FOREACH(i, l) {
2856 r = sd_bus_message_append_basic(m, 's', *i);
2861 return sd_bus_message_close_container(m);
2864 static int bus_message_close_header(sd_bus_message *m) {
2868 /* The actual user data is finished now, we just complete the
2869 variant and struct now (at least on gvariant). Remember
2870 this position, so that during parsing we know where to to
2871 put the outer container end. */
2872 m->user_body_size = m->body_size;
2874 if (BUS_MESSAGE_IS_GVARIANT(m)) {
2875 const char *signature;
2879 /* Add offset table to end of fields array */
2880 if (m->n_header_offsets >= 1) {
2884 assert(m->fields_size == m->header_offsets[m->n_header_offsets-1]);
2886 sz = bus_gvariant_determine_word_size(m->fields_size, m->n_header_offsets);
2887 a = message_extend_fields(m, 1, sz * m->n_header_offsets, false);
2891 for (i = 0; i < m->n_header_offsets; i++)
2892 bus_gvariant_write_word_le(a + sz*i, sz, m->header_offsets[i]);
2895 /* Add gvariant NUL byte plus signature to the end of
2896 * the body, followed by the final offset pointing to
2897 * the end of the fields array */
2899 signature = strempty(m->root_container.signature);
2900 l = strlen(signature);
2902 sz = bus_gvariant_determine_word_size(sizeof(struct bus_header) + ALIGN8(m->fields_size) + m->body_size + 1 + l, 1);
2903 d = message_extend_body(m, 1, 1 + l + sz, false, true);
2908 memcpy((uint8_t*) d + 1, signature, l);
2910 bus_gvariant_write_word_le((uint8_t*) d + 1 + l, sz, sizeof(struct bus_header) + m->fields_size);
2913 m->footer_accessible = 1 + l + sz;
2915 m->header->dbus1.fields_size = m->fields_size;
2916 m->header->dbus1.body_size = m->body_size;
2922 int bus_message_seal(sd_bus_message *m, uint64_t cookie, usec_t timeout) {
2923 struct bus_body_part *part;
2933 if (m->n_containers > 0)
2939 if (cookie > 0xffffffffULL &&
2940 !BUS_MESSAGE_IS_GVARIANT(m))
2943 /* In vtables the return signature of method calls is listed,
2944 * let's check if they match if this is a response */
2945 if (m->header->type == SD_BUS_MESSAGE_METHOD_RETURN &&
2946 m->enforced_reply_signature &&
2947 !streq(strempty(m->root_container.signature), m->enforced_reply_signature))
2950 /* If gvariant marshalling is used we need to close the body structure */
2951 r = bus_message_close_struct(m, &m->root_container, false);
2955 /* If there's a non-trivial signature set, then add it in
2956 * here, but only on dbus1 */
2957 if (!isempty(m->root_container.signature) && !BUS_MESSAGE_IS_GVARIANT(m)) {
2958 r = message_append_field_signature(m, BUS_MESSAGE_HEADER_SIGNATURE, m->root_container.signature, NULL);
2964 r = message_append_field_uint32(m, BUS_MESSAGE_HEADER_UNIX_FDS, m->n_fds);
2969 r = bus_message_close_header(m);
2973 if (BUS_MESSAGE_IS_GVARIANT(m))
2974 m->header->dbus2.cookie = cookie;
2976 m->header->dbus1.serial = (uint32_t) cookie;
2978 m->timeout = m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED ? 0 : timeout;
2980 /* Add padding at the end of the fields part, since we know
2981 * the body needs to start at an 8 byte alignment. We made
2982 * sure we allocated enough space for this, so all we need to
2983 * do here is to zero it out. */
2984 a = ALIGN8(m->fields_size) - m->fields_size;
2986 memzero((uint8_t*) BUS_MESSAGE_FIELDS(m) + m->fields_size, a);
2988 /* If this is something we can send as memfd, then let's seal
2989 the memfd now. Note that we can send memfds as payload only
2990 for directed messages, and not for broadcasts. */
2991 if (m->destination && m->bus->use_memfd) {
2992 MESSAGE_FOREACH_PART(part, i, m)
2993 if (part->memfd >= 0 &&
2995 (part->size > MEMFD_MIN_SIZE || m->bus->use_memfd < 0) &&
2996 part != m->body_end) { /* The last part may never be sent as memfd */
2999 /* Try to seal it if that makes
3000 * sense. First, unmap our own map to
3001 * make sure we don't keep it busy. */
3002 bus_body_part_unmap(part);
3004 /* Then, sync up real memfd size */
3006 r = memfd_set_size(part->memfd, sz);
3010 /* Finally, try to seal */
3011 if (memfd_set_sealed(part->memfd) >= 0)
3012 part->sealed = true;
3016 m->root_container.end = m->user_body_size;
3017 m->root_container.index = 0;
3018 m->root_container.offset_index = 0;
3019 m->root_container.item_size = m->root_container.n_offsets > 0 ? m->root_container.offsets[0] : 0;
3026 int bus_body_part_map(struct bus_body_part *part) {
3035 if (part->size <= 0)
3038 /* For smaller zero parts (as used for padding) we don't need to map anything... */
3039 if (part->memfd < 0 && part->is_zero && part->size < 8) {
3040 static const uint8_t zeroes[7] = { };
3041 part->data = (void*) zeroes;
3045 shift = part->memfd_offset - ((part->memfd_offset / page_size()) * page_size());
3046 psz = PAGE_ALIGN(part->size + shift);
3048 if (part->memfd >= 0)
3049 p = mmap(NULL, psz, PROT_READ, MAP_PRIVATE, part->memfd, part->memfd_offset - shift);
3050 else if (part->is_zero)
3051 p = mmap(NULL, psz, PROT_READ, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
3055 if (p == MAP_FAILED)
3059 part->mmap_begin = p;
3060 part->data = (uint8_t*) p + shift;
3061 part->munmap_this = true;
3066 void bus_body_part_unmap(struct bus_body_part *part) {
3070 if (part->memfd < 0)
3073 if (!part->mmap_begin)
3076 if (!part->munmap_this)
3079 assert_se(munmap(part->mmap_begin, part->mapped) == 0);
3081 part->mmap_begin = NULL;
3084 part->munmap_this = false;
3089 static int buffer_peek(const void *p, uint32_t sz, size_t *rindex, size_t align, size_t nbytes, void **r) {
3090 size_t k, start, end;
3095 start = ALIGN_TO((size_t) *rindex, align);
3096 end = start + nbytes;
3101 /* Verify that padding is 0 */
3102 for (k = *rindex; k < start; k++)
3103 if (((const uint8_t*) p)[k] != 0)
3107 *r = (uint8_t*) p + start;
3114 static bool message_end_of_signature(sd_bus_message *m) {
3115 struct bus_container *c;
3119 c = message_get_container(m);
3120 return !c->signature || c->signature[c->index] == 0;
3123 static bool message_end_of_array(sd_bus_message *m, size_t index) {
3124 struct bus_container *c;
3128 c = message_get_container(m);
3129 if (c->enclosing != SD_BUS_TYPE_ARRAY)
3132 if (BUS_MESSAGE_IS_GVARIANT(m))
3133 return index >= c->end;
3135 assert(c->array_size);
3136 return index >= c->begin + BUS_MESSAGE_BSWAP32(m, *c->array_size);
3140 _public_ int sd_bus_message_at_end(sd_bus_message *m, int complete) {
3141 assert_return(m, -EINVAL);
3142 assert_return(m->sealed, -EPERM);
3144 if (complete && m->n_containers > 0)
3147 if (message_end_of_signature(m))
3150 if (message_end_of_array(m, m->rindex))
3156 static struct bus_body_part* find_part(sd_bus_message *m, size_t index, size_t sz, void **p) {
3157 struct bus_body_part *part;
3163 if (m->cached_rindex_part && index >= m->cached_rindex_part_begin) {
3164 part = m->cached_rindex_part;
3165 begin = m->cached_rindex_part_begin;
3175 if (index + sz <= begin + part->size) {
3177 r = bus_body_part_map(part);
3182 *p = (uint8_t*) part->data + index - begin;
3184 m->cached_rindex_part = part;
3185 m->cached_rindex_part_begin = begin;
3190 begin += part->size;
3197 static int container_next_item(sd_bus_message *m, struct bus_container *c, size_t *rindex) {
3204 if (!BUS_MESSAGE_IS_GVARIANT(m))
3207 if (c->enclosing == SD_BUS_TYPE_ARRAY) {
3210 sz = bus_gvariant_get_size(c->signature);
3214 if (c->offset_index+1 >= c->n_offsets)
3217 /* Variable-size array */
3219 alignment = bus_gvariant_get_alignment(c->signature);
3220 assert(alignment > 0);
3222 *rindex = ALIGN_TO(c->offsets[c->offset_index], alignment);
3223 c->item_size = c->offsets[c->offset_index+1] - *rindex;
3226 if (c->offset_index+1 >= (c->end-c->begin)/sz)
3229 /* Fixed-size array */
3230 *rindex = c->begin + (c->offset_index+1) * sz;
3236 } else if (c->enclosing == 0 ||
3237 c->enclosing == SD_BUS_TYPE_STRUCT ||
3238 c->enclosing == SD_BUS_TYPE_DICT_ENTRY) {
3243 if (c->offset_index+1 >= c->n_offsets)
3246 r = signature_element_length(c->signature + c->index, &n);
3250 r = signature_element_length(c->signature + c->index + n, &j);
3255 memcpy(t, c->signature + c->index + n, j);
3258 alignment = bus_gvariant_get_alignment(t);
3261 assert(alignment > 0);
3263 *rindex = ALIGN_TO(c->offsets[c->offset_index], alignment);
3264 c->item_size = c->offsets[c->offset_index+1] - *rindex;
3268 } else if (c->enclosing == SD_BUS_TYPE_VARIANT)
3271 assert_not_reached("Unknown container type");
3276 /* Reached the end */
3283 static int message_peek_body(
3290 size_t k, start, end, padding;
3291 struct bus_body_part *part;
3298 start = ALIGN_TO((size_t) *rindex, align);
3299 padding = start - *rindex;
3300 end = start + nbytes;
3302 if (end > m->user_body_size)
3305 part = find_part(m, *rindex, padding, (void**) &q);
3310 /* Verify padding */
3311 for (k = 0; k < padding; k++)
3316 part = find_part(m, start, nbytes, (void**) &q);
3317 if (!part || (nbytes > 0 && !q))
3328 static bool validate_nul(const char *s, size_t l) {
3330 /* Check for NUL chars in the string */
3331 if (memchr(s, 0, l))
3334 /* Check for NUL termination */
3341 static bool validate_string(const char *s, size_t l) {
3343 if (!validate_nul(s, l))
3346 /* Check if valid UTF8 */
3347 if (!utf8_is_valid(s))
3353 static bool validate_signature(const char *s, size_t l) {
3355 if (!validate_nul(s, l))
3358 /* Check if valid signature */
3359 if (!signature_is_valid(s, true))
3365 static bool validate_object_path(const char *s, size_t l) {
3367 if (!validate_nul(s, l))
3370 if (!object_path_is_valid(s))
3376 _public_ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) {
3377 struct bus_container *c;
3382 assert_return(m, -EINVAL);
3383 assert_return(m->sealed, -EPERM);
3384 assert_return(bus_type_is_basic(type), -EINVAL);
3386 if (message_end_of_signature(m))
3389 if (message_end_of_array(m, m->rindex))
3392 c = message_get_container(m);
3393 if (c->signature[c->index] != type)
3398 if (BUS_MESSAGE_IS_GVARIANT(m)) {
3400 if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE)) {
3403 r = message_peek_body(m, &rindex, 1, c->item_size, &q);
3407 if (type == SD_BUS_TYPE_STRING)
3408 ok = validate_string(q, c->item_size-1);
3409 else if (type == SD_BUS_TYPE_OBJECT_PATH)
3410 ok = validate_object_path(q, c->item_size-1);
3412 ok = validate_signature(q, c->item_size-1);
3418 *(const char**) p = q;
3422 sz = bus_gvariant_get_size(CHAR_TO_STR(type));
3424 if ((size_t) sz != c->item_size)
3427 align = bus_gvariant_get_alignment(CHAR_TO_STR(type));
3430 r = message_peek_body(m, &rindex, align, c->item_size, &q);
3436 case SD_BUS_TYPE_BYTE:
3438 *(uint8_t*) p = *(uint8_t*) q;
3441 case SD_BUS_TYPE_BOOLEAN:
3443 *(int*) p = !!*(uint8_t*) q;
3446 case SD_BUS_TYPE_INT16:
3447 case SD_BUS_TYPE_UINT16:
3449 *(uint16_t*) p = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q);
3452 case SD_BUS_TYPE_INT32:
3453 case SD_BUS_TYPE_UINT32:
3455 *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
3458 case SD_BUS_TYPE_INT64:
3459 case SD_BUS_TYPE_UINT64:
3460 case SD_BUS_TYPE_DOUBLE:
3462 *(uint64_t*) p = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q);
3465 case SD_BUS_TYPE_UNIX_FD: {
3468 j = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
3473 *(int*) p = m->fds[j];
3479 assert_not_reached("unexpected type");
3483 r = container_next_item(m, c, &rindex);
3488 if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH)) {
3492 r = message_peek_body(m, &rindex, 4, 4, &q);
3496 l = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
3497 r = message_peek_body(m, &rindex, 1, l+1, &q);
3501 if (type == SD_BUS_TYPE_OBJECT_PATH)
3502 ok = validate_object_path(q, l);
3504 ok = validate_string(q, l);
3509 *(const char**) p = q;
3511 } else if (type == SD_BUS_TYPE_SIGNATURE) {
3514 r = message_peek_body(m, &rindex, 1, 1, &q);
3519 r = message_peek_body(m, &rindex, 1, l+1, &q);
3523 if (!validate_signature(q, l))
3527 *(const char**) p = q;
3532 align = bus_type_get_alignment(type);
3535 sz = bus_type_get_size(type);
3538 r = message_peek_body(m, &rindex, align, sz, &q);
3544 case SD_BUS_TYPE_BYTE:
3546 *(uint8_t*) p = *(uint8_t*) q;
3549 case SD_BUS_TYPE_BOOLEAN:
3551 *(int*) p = !!*(uint32_t*) q;
3554 case SD_BUS_TYPE_INT16:
3555 case SD_BUS_TYPE_UINT16:
3557 *(uint16_t*) p = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q);
3560 case SD_BUS_TYPE_INT32:
3561 case SD_BUS_TYPE_UINT32:
3563 *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
3566 case SD_BUS_TYPE_INT64:
3567 case SD_BUS_TYPE_UINT64:
3568 case SD_BUS_TYPE_DOUBLE:
3570 *(uint64_t*) p = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q);
3573 case SD_BUS_TYPE_UNIX_FD: {
3576 j = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
3581 *(int*) p = m->fds[j];
3586 assert_not_reached("Unknown basic type...");
3593 if (c->enclosing != SD_BUS_TYPE_ARRAY)
3599 static int bus_message_enter_array(
3601 struct bus_container *c,
3602 const char *contents,
3603 uint32_t **array_size,
3606 size_t *n_offsets) {
3620 if (!signature_is_single(contents, true))
3623 if (!c->signature || c->signature[c->index] == 0)
3626 if (c->signature[c->index] != SD_BUS_TYPE_ARRAY)
3629 if (!startswith(c->signature + c->index + 1, contents))
3634 if (!BUS_MESSAGE_IS_GVARIANT(m)) {
3637 r = message_peek_body(m, &rindex, 4, 4, &q);
3641 if (BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q) > BUS_ARRAY_MAX_SIZE)
3644 alignment = bus_type_get_alignment(contents[0]);
3648 r = message_peek_body(m, &rindex, alignment, 0, NULL);
3652 *array_size = (uint32_t*) q;
3654 } else if (c->item_size <= 0) {
3656 /* gvariant: empty array */
3661 } else if (bus_gvariant_is_fixed_size(contents)) {
3663 /* gvariant: fixed length array */
3664 *item_size = bus_gvariant_get_size(contents);
3669 size_t where, p = 0, framing, sz;
3672 /* gvariant: variable length array */
3673 sz = bus_gvariant_determine_word_size(c->item_size, 0);
3675 where = rindex + c->item_size - sz;
3676 r = message_peek_body(m, &where, 1, sz, &q);
3680 framing = bus_gvariant_read_word_le(q, sz);
3681 if (framing > c->item_size - sz)
3683 if ((c->item_size - framing) % sz != 0)
3686 *n_offsets = (c->item_size - framing) / sz;
3688 where = rindex + framing;
3689 r = message_peek_body(m, &where, 1, *n_offsets * sz, &q);
3693 *offsets = new(size_t, *n_offsets);
3697 for (i = 0; i < *n_offsets; i++) {
3700 x = bus_gvariant_read_word_le((uint8_t*) q + i * sz, sz);
3701 if (x > c->item_size - sz)
3706 (*offsets)[i] = rindex + x;
3710 *item_size = (*offsets)[0] - rindex;
3715 if (c->enclosing != SD_BUS_TYPE_ARRAY)
3716 c->index += 1 + strlen(contents);
3721 static int bus_message_enter_variant(
3723 struct bus_container *c,
3724 const char *contents,
3725 size_t *item_size) {
3737 if (!signature_is_single(contents, false))
3740 if (*contents == SD_BUS_TYPE_DICT_ENTRY_BEGIN)
3743 if (!c->signature || c->signature[c->index] == 0)
3746 if (c->signature[c->index] != SD_BUS_TYPE_VARIANT)
3751 if (BUS_MESSAGE_IS_GVARIANT(m)) {
3754 k = strlen(contents);
3755 if (1+k > c->item_size)
3758 where = rindex + c->item_size - (1+k);
3759 r = message_peek_body(m, &where, 1, 1+k, &q);
3763 if (*(char*) q != 0)
3766 if (memcmp((uint8_t*) q+1, contents, k))
3769 *item_size = c->item_size - (1+k);
3772 r = message_peek_body(m, &rindex, 1, 1, &q);
3777 r = message_peek_body(m, &rindex, 1, l+1, &q);
3781 if (!validate_signature(q, l))
3784 if (!streq(q, contents))
3790 if (c->enclosing != SD_BUS_TYPE_ARRAY)
3796 static int build_struct_offsets(
3798 const char *signature,
3802 size_t *n_offsets) {
3804 unsigned n_variable = 0, n_total = 0, v;
3805 size_t previous = 0, where;
3816 if (isempty(signature)) {
3823 sz = bus_gvariant_determine_word_size(size, 0);
3827 /* First, loop over signature and count variable elements and
3828 * elements in general. We use this to know how large the
3829 * offset array is at the end of the structure. Note that
3830 * GVariant only stores offsets for all variable size elements
3831 * that are not the last item. */
3837 r = signature_element_length(p, &n);
3846 r = bus_gvariant_is_fixed_size(t);
3851 if (r == 0 && p[n] != 0) /* except the last item */
3858 if (size < n_variable * sz)
3861 where = m->rindex + size - (n_variable * sz);
3862 r = message_peek_body(m, &where, 1, n_variable * sz, &q);
3868 *offsets = new(size_t, n_total);
3874 /* Second, loop again and build an offset table */
3880 r = signature_element_length(p, &n);
3889 k = bus_gvariant_get_size(t);
3897 x = bus_gvariant_read_word_le((uint8_t*) q + v*sz, sz);
3900 if (m->rindex + x < previous)
3903 /* The last item's end
3904 * is determined from
3907 x = size - (n_variable * sz);
3909 offset = m->rindex + x;
3915 align = bus_gvariant_get_alignment(t);
3918 offset = (*n_offsets == 0 ? m->rindex : ALIGN_TO((*offsets)[*n_offsets-1], align)) + k;
3922 previous = (*offsets)[(*n_offsets)++] = offset;
3927 assert(*n_offsets == n_total);
3929 *item_size = (*offsets)[0] - m->rindex;
3933 static int enter_struct_or_dict_entry(
3935 struct bus_container *c,
3936 const char *contents,
3939 size_t *n_offsets) {
3950 if (!BUS_MESSAGE_IS_GVARIANT(m)) {
3953 r = message_peek_body(m, &m->rindex, 8, 0, NULL);
3958 /* gvariant with contents */
3959 return build_struct_offsets(m, contents, c->item_size, item_size, offsets, n_offsets);
3964 static int bus_message_enter_struct(
3966 struct bus_container *c,
3967 const char *contents,
3970 size_t *n_offsets) {
3982 if (!signature_is_valid(contents, false))
3985 if (!c->signature || c->signature[c->index] == 0)
3988 l = strlen(contents);
3990 if (c->signature[c->index] != SD_BUS_TYPE_STRUCT_BEGIN ||
3991 !startswith(c->signature + c->index + 1, contents) ||
3992 c->signature[c->index + 1 + l] != SD_BUS_TYPE_STRUCT_END)
3995 r = enter_struct_or_dict_entry(m, c, contents, item_size, offsets, n_offsets);
3999 if (c->enclosing != SD_BUS_TYPE_ARRAY)
4000 c->index += 1 + l + 1;
4005 static int bus_message_enter_dict_entry(
4007 struct bus_container *c,
4008 const char *contents,
4011 size_t *n_offsets) {
4020 if (!signature_is_pair(contents))
4023 if (c->enclosing != SD_BUS_TYPE_ARRAY)
4026 if (!c->signature || c->signature[c->index] == 0)
4029 l = strlen(contents);
4031 if (c->signature[c->index] != SD_BUS_TYPE_DICT_ENTRY_BEGIN ||
4032 !startswith(c->signature + c->index + 1, contents) ||
4033 c->signature[c->index + 1 + l] != SD_BUS_TYPE_DICT_ENTRY_END)
4036 r = enter_struct_or_dict_entry(m, c, contents, item_size, offsets, n_offsets);
4040 if (c->enclosing != SD_BUS_TYPE_ARRAY)
4041 c->index += 1 + l + 1;
4046 _public_ int sd_bus_message_enter_container(sd_bus_message *m,
4048 const char *contents) {
4049 struct bus_container *c, *w;
4050 uint32_t *array_size = NULL;
4053 size_t *offsets = NULL;
4054 size_t n_offsets = 0, item_size = 0;
4057 assert_return(m, -EINVAL);
4058 assert_return(m->sealed, -EPERM);
4059 assert_return(type != 0 || !contents, -EINVAL);
4061 if (type == 0 || !contents) {
4065 /* Allow entering into anonymous containers */
4066 r = sd_bus_message_peek_type(m, &tt, &cc);
4070 if (type != 0 && type != tt)
4073 if (contents && !streq(contents, cc))
4081 * We enforce a global limit on container depth, that is much
4082 * higher than the 32 structs and 32 arrays the specification
4083 * mandates. This is simpler to implement for us, and we need
4084 * this only to ensure our container array doesn't grow
4085 * without bounds. We are happy to return any data from a
4086 * message as long as the data itself is valid, even if the
4087 * overall message might be not.
4089 * Note that the message signature is validated when
4090 * parsing the headers, and that validation does check the
4093 * Note that the specification defines no limits on the depth
4094 * of stacked variants, but we do.
4096 if (m->n_containers >= BUS_CONTAINER_DEPTH)
4099 if (!GREEDY_REALLOC(m->containers, m->containers_allocated, m->n_containers + 1))
4102 if (message_end_of_signature(m))
4105 if (message_end_of_array(m, m->rindex))
4108 c = message_get_container(m);
4110 signature = strdup(contents);
4114 c->saved_index = c->index;
4117 if (type == SD_BUS_TYPE_ARRAY)
4118 r = bus_message_enter_array(m, c, contents, &array_size, &item_size, &offsets, &n_offsets);
4119 else if (type == SD_BUS_TYPE_VARIANT)
4120 r = bus_message_enter_variant(m, c, contents, &item_size);
4121 else if (type == SD_BUS_TYPE_STRUCT)
4122 r = bus_message_enter_struct(m, c, contents, &item_size, &offsets, &n_offsets);
4123 else if (type == SD_BUS_TYPE_DICT_ENTRY)
4124 r = bus_message_enter_dict_entry(m, c, contents, &item_size, &offsets, &n_offsets);
4134 /* OK, let's fill it in */
4135 w = m->containers + m->n_containers++;
4136 w->enclosing = type;
4137 w->signature = signature;
4138 w->peeked_signature = NULL;
4142 w->begin = m->rindex;
4143 w->end = m->rindex + c->item_size;
4145 w->array_size = array_size;
4146 w->item_size = item_size;
4147 w->offsets = offsets;
4148 w->n_offsets = n_offsets;
4149 w->offset_index = 0;
4154 _public_ int sd_bus_message_exit_container(sd_bus_message *m) {
4155 struct bus_container *c;
4159 assert_return(m, -EINVAL);
4160 assert_return(m->sealed, -EPERM);
4161 assert_return(m->n_containers > 0, -ENXIO);
4163 c = message_get_container(m);
4165 if (c->enclosing != SD_BUS_TYPE_ARRAY) {
4166 if (c->signature && c->signature[c->index] != 0)
4170 if (BUS_MESSAGE_IS_GVARIANT(m)) {
4171 if (m->rindex < c->end)
4174 } else if (c->enclosing == SD_BUS_TYPE_ARRAY) {
4177 l = BUS_MESSAGE_BSWAP32(m, *c->array_size);
4178 if (c->begin + l != m->rindex)
4183 free(c->peeked_signature);
4187 c = message_get_container(m);
4190 c->index = c->saved_index;
4191 r = container_next_item(m, c, &m->rindex);
4199 static void message_quit_container(sd_bus_message *m) {
4200 struct bus_container *c;
4204 assert(m->n_containers > 0);
4206 c = message_get_container(m);
4209 assert(m->rindex >= c->before);
4210 m->rindex = c->before;
4212 /* Free container */
4217 /* Correct index of new top-level container */
4218 c = message_get_container(m);
4219 c->index = c->saved_index;
4222 _public_ int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents) {
4223 struct bus_container *c;
4226 assert_return(m, -EINVAL);
4227 assert_return(m->sealed, -EPERM);
4229 if (message_end_of_signature(m))
4232 if (message_end_of_array(m, m->rindex))
4235 c = message_get_container(m);
4237 if (bus_type_is_basic(c->signature[c->index])) {
4241 *type = c->signature[c->index];
4245 if (c->signature[c->index] == SD_BUS_TYPE_ARRAY) {
4251 r = signature_element_length(c->signature+c->index+1, &l);
4257 sig = strndup(c->signature + c->index + 1, l);
4261 free(c->peeked_signature);
4262 *contents = c->peeked_signature = sig;
4266 *type = SD_BUS_TYPE_ARRAY;
4271 if (c->signature[c->index] == SD_BUS_TYPE_STRUCT_BEGIN ||
4272 c->signature[c->index] == SD_BUS_TYPE_DICT_ENTRY_BEGIN) {
4278 r = signature_element_length(c->signature+c->index, &l);
4283 sig = strndup(c->signature + c->index + 1, l - 2);
4287 free(c->peeked_signature);
4288 *contents = c->peeked_signature = sig;
4292 *type = c->signature[c->index] == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY;
4297 if (c->signature[c->index] == SD_BUS_TYPE_VARIANT) {
4301 if (BUS_MESSAGE_IS_GVARIANT(m)) {
4304 if (c->item_size < 2)
4307 /* Look for the NUL delimiter that
4308 separates the payload from the
4309 signature. Since the body might be
4310 in a different part that then the
4311 signature we map byte by byte. */
4313 for (k = 2; k <= c->item_size; k++) {
4316 where = m->rindex + c->item_size - k;
4317 r = message_peek_body(m, &where, 1, k, &q);
4321 if (*(char*) q == 0)
4325 if (k > c->item_size)
4328 free(c->peeked_signature);
4329 c->peeked_signature = strndup((char*) q + 1, k - 1);
4330 if (!c->peeked_signature)
4333 if (!signature_is_valid(c->peeked_signature, true))
4336 *contents = c->peeked_signature;
4341 r = message_peek_body(m, &rindex, 1, 1, &q);
4346 r = message_peek_body(m, &rindex, 1, l+1, &q);
4350 if (!validate_signature(q, l))
4358 *type = SD_BUS_TYPE_VARIANT;
4373 _public_ int sd_bus_message_rewind(sd_bus_message *m, int complete) {
4374 struct bus_container *c;
4376 assert_return(m, -EINVAL);
4377 assert_return(m->sealed, -EPERM);
4380 message_reset_containers(m);
4383 c = message_get_container(m);
4385 c = message_get_container(m);
4387 c->offset_index = 0;
4389 m->rindex = c->begin;
4392 c->offset_index = 0;
4393 c->item_size = (c->n_offsets > 0 ? c->offsets[0] : c->end) - c->begin;
4395 return !isempty(c->signature);
4398 static int message_read_ap(
4403 unsigned n_array, n_struct;
4404 TypeStack stack[BUS_CONTAINER_DEPTH];
4405 unsigned stack_ptr = 0;
4406 unsigned n_loop = 0;
4414 /* Ideally, we'd just call ourselves recursively on every
4415 * complex type. However, the state of a va_list that is
4416 * passed to a function is undefined after that function
4417 * returns. This means we need to docode the va_list linearly
4418 * in a single stackframe. We hence implement our own
4419 * home-grown stack in an array. */
4421 n_array = (unsigned) -1; /* length of current array entries */
4422 n_struct = strlen(types); /* length of current struct contents signature */
4429 if (n_array == 0 || (n_array == (unsigned) -1 && n_struct == 0)) {
4430 r = type_stack_pop(stack, ELEMENTSOF(stack), &stack_ptr, &types, &n_struct, &n_array);
4436 r = sd_bus_message_exit_container(m);
4444 if (n_array != (unsigned) -1)
4453 case SD_BUS_TYPE_BYTE:
4454 case SD_BUS_TYPE_BOOLEAN:
4455 case SD_BUS_TYPE_INT16:
4456 case SD_BUS_TYPE_UINT16:
4457 case SD_BUS_TYPE_INT32:
4458 case SD_BUS_TYPE_UINT32:
4459 case SD_BUS_TYPE_INT64:
4460 case SD_BUS_TYPE_UINT64:
4461 case SD_BUS_TYPE_DOUBLE:
4462 case SD_BUS_TYPE_STRING:
4463 case SD_BUS_TYPE_OBJECT_PATH:
4464 case SD_BUS_TYPE_SIGNATURE:
4465 case SD_BUS_TYPE_UNIX_FD: {
4468 p = va_arg(ap, void*);
4469 r = sd_bus_message_read_basic(m, *t, p);
4482 case SD_BUS_TYPE_ARRAY: {
4485 r = signature_element_length(t + 1, &k);
4491 memcpy(s, t + 1, k);
4494 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, s);
4505 if (n_array == (unsigned) -1) {
4510 r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
4516 n_array = va_arg(ap, unsigned);
4521 case SD_BUS_TYPE_VARIANT: {
4524 s = va_arg(ap, const char *);
4528 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, s);
4538 r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
4543 n_struct = strlen(s);
4544 n_array = (unsigned) -1;
4549 case SD_BUS_TYPE_STRUCT_BEGIN:
4550 case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
4553 r = signature_element_length(t, &k);
4559 memcpy(s, t + 1, k - 2);
4562 r = sd_bus_message_enter_container(m, *t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
4572 if (n_array == (unsigned) -1) {
4577 r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
4583 n_array = (unsigned) -1;
4596 _public_ int sd_bus_message_read(sd_bus_message *m, const char *types, ...) {
4600 assert_return(m, -EINVAL);
4601 assert_return(m->sealed, -EPERM);
4602 assert_return(types, -EINVAL);
4604 va_start(ap, types);
4605 r = message_read_ap(m, types, ap);
4611 _public_ int sd_bus_message_skip(sd_bus_message *m, const char *types) {
4614 assert_return(m, -EINVAL);
4615 assert_return(m->sealed, -EPERM);
4617 /* If types is NULL, read exactly one element */
4619 struct bus_container *c;
4622 if (message_end_of_signature(m))
4625 if (message_end_of_array(m, m->rindex))
4628 c = message_get_container(m);
4630 r = signature_element_length(c->signature + c->index, &l);
4634 types = strndupa(c->signature + c->index, l);
4639 case 0: /* Nothing to drop */
4642 case SD_BUS_TYPE_BYTE:
4643 case SD_BUS_TYPE_BOOLEAN:
4644 case SD_BUS_TYPE_INT16:
4645 case SD_BUS_TYPE_UINT16:
4646 case SD_BUS_TYPE_INT32:
4647 case SD_BUS_TYPE_UINT32:
4648 case SD_BUS_TYPE_INT64:
4649 case SD_BUS_TYPE_UINT64:
4650 case SD_BUS_TYPE_DOUBLE:
4651 case SD_BUS_TYPE_STRING:
4652 case SD_BUS_TYPE_OBJECT_PATH:
4653 case SD_BUS_TYPE_SIGNATURE:
4654 case SD_BUS_TYPE_UNIX_FD:
4656 r = sd_bus_message_read_basic(m, *types, NULL);
4660 r = sd_bus_message_skip(m, types + 1);
4666 case SD_BUS_TYPE_ARRAY: {
4669 r = signature_element_length(types + 1, &k);
4675 memcpy(s, types+1, k);
4678 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, s);
4683 r = sd_bus_message_skip(m, s);
4690 r = sd_bus_message_exit_container(m);
4695 r = sd_bus_message_skip(m, types + 1 + k);
4702 case SD_BUS_TYPE_VARIANT: {
4703 const char *contents;
4706 r = sd_bus_message_peek_type(m, &x, &contents);
4710 if (x != SD_BUS_TYPE_VARIANT)
4713 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, contents);
4717 r = sd_bus_message_skip(m, contents);
4722 r = sd_bus_message_exit_container(m);
4726 r = sd_bus_message_skip(m, types + 1);
4733 case SD_BUS_TYPE_STRUCT_BEGIN:
4734 case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
4737 r = signature_element_length(types, &k);
4743 memcpy(s, types+1, k-2);
4746 r = sd_bus_message_enter_container(m, *types == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
4750 r = sd_bus_message_skip(m, s);
4754 r = sd_bus_message_exit_container(m);
4759 r = sd_bus_message_skip(m, types + k);
4771 _public_ int sd_bus_message_read_array(
4777 struct bus_container *c;
4783 assert_return(m, -EINVAL);
4784 assert_return(m->sealed, -EPERM);
4785 assert_return(bus_type_is_trivial(type), -EINVAL);
4786 assert_return(ptr, -EINVAL);
4787 assert_return(size, -EINVAL);
4788 assert_return(!BUS_MESSAGE_NEED_BSWAP(m), -EOPNOTSUPP);
4790 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
4794 c = message_get_container(m);
4796 if (BUS_MESSAGE_IS_GVARIANT(m)) {
4797 align = bus_gvariant_get_alignment(CHAR_TO_STR(type));
4801 sz = c->end - c->begin;
4803 align = bus_type_get_alignment(type);
4807 sz = BUS_MESSAGE_BSWAP32(m, *c->array_size);
4811 /* Zero length array, let's return some aligned
4812 * pointer that is not NULL */
4813 p = (uint8_t*) NULL + align;
4815 r = message_peek_body(m, &m->rindex, align, sz, &p);
4820 r = sd_bus_message_exit_container(m);
4824 *ptr = (const void*) p;
4830 message_quit_container(m);
4834 static int message_peek_fields(
4845 return buffer_peek(BUS_MESSAGE_FIELDS(m), m->fields_size, rindex, align, nbytes, ret);
4848 static int message_peek_field_uint32(
4860 if (BUS_MESSAGE_IS_GVARIANT(m) && item_size != 4)
4863 /* identical for gvariant and dbus1 */
4865 r = message_peek_fields(m, ri, 4, 4, &q);
4870 *ret = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
4875 static int message_peek_field_uint64(
4887 if (BUS_MESSAGE_IS_GVARIANT(m) && item_size != 8)
4890 /* identical for gvariant and dbus1 */
4892 r = message_peek_fields(m, ri, 8, 8, &q);
4897 *ret = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q);
4902 static int message_peek_field_string(
4904 bool (*validate)(const char *p),
4916 if (BUS_MESSAGE_IS_GVARIANT(m)) {
4921 r = message_peek_fields(m, ri, 1, item_size, &q);
4927 r = message_peek_field_uint32(m, ri, 4, &l);
4931 r = message_peek_fields(m, ri, 1, l+1, &q);
4937 if (!validate_nul(q, l))
4943 if (!validate_string(q, l))
4953 static int message_peek_field_signature(
4966 if (BUS_MESSAGE_IS_GVARIANT(m)) {
4971 r = message_peek_fields(m, ri, 1, item_size, &q);
4977 r = message_peek_fields(m, ri, 1, 1, &q);
4982 r = message_peek_fields(m, ri, 1, l+1, &q);
4987 if (!validate_signature(q, l))
4996 static int message_skip_fields(
4999 uint32_t array_size,
5000 const char **signature) {
5002 size_t original_index;
5008 assert(!BUS_MESSAGE_IS_GVARIANT(m));
5010 original_index = *ri;
5016 if (array_size != (uint32_t) -1 &&
5017 array_size <= *ri - original_index)
5024 if (t == SD_BUS_TYPE_STRING) {
5026 r = message_peek_field_string(m, NULL, ri, 0, NULL);
5032 } else if (t == SD_BUS_TYPE_OBJECT_PATH) {
5034 r = message_peek_field_string(m, object_path_is_valid, ri, 0, NULL);
5040 } else if (t == SD_BUS_TYPE_SIGNATURE) {
5042 r = message_peek_field_signature(m, ri, 0, NULL);
5048 } else if (bus_type_is_basic(t)) {
5051 align = bus_type_get_alignment(t);
5052 k = bus_type_get_size(t);
5053 assert(align > 0 && k > 0);
5055 r = message_peek_fields(m, ri, align, k, NULL);
5061 } else if (t == SD_BUS_TYPE_ARRAY) {
5063 r = signature_element_length(*signature+1, &l);
5073 strncpy(sig, *signature + 1, l-1);
5076 alignment = bus_type_get_alignment(sig[0]);
5080 r = message_peek_field_uint32(m, ri, 0, &nas);
5083 if (nas > BUS_ARRAY_MAX_SIZE)
5086 r = message_peek_fields(m, ri, alignment, 0, NULL);
5090 r = message_skip_fields(m, ri, nas, (const char**) &s);
5095 (*signature) += 1 + l;
5097 } else if (t == SD_BUS_TYPE_VARIANT) {
5100 r = message_peek_field_signature(m, ri, 0, &s);
5104 r = message_skip_fields(m, ri, (uint32_t) -1, (const char**) &s);
5110 } else if (t == SD_BUS_TYPE_STRUCT ||
5111 t == SD_BUS_TYPE_DICT_ENTRY) {
5113 r = signature_element_length(*signature, &l);
5120 strncpy(sig, *signature + 1, l-1);
5123 r = message_skip_fields(m, ri, (uint32_t) -1, (const char**) &s);
5134 int bus_message_parse_fields(sd_bus_message *m) {
5137 uint32_t unix_fds = 0;
5138 bool unix_fds_set = false;
5139 void *offsets = NULL;
5140 unsigned n_offsets = 0;
5146 if (BUS_MESSAGE_IS_GVARIANT(m)) {
5149 /* Read the signature from the end of the body variant first */
5150 sz = bus_gvariant_determine_word_size(BUS_MESSAGE_SIZE(m), 0);
5151 if (m->footer_accessible < 1 + sz)
5154 p = (char*) m->footer + m->footer_accessible - (1 + sz);
5156 if (p < (char*) m->footer)
5162 /* We found the beginning of the signature string, yay! */
5164 c = strndup(p + 1, ((char*) m->footer + m->footer_accessible) - p - (1 + sz));
5168 free(m->root_container.signature);
5169 m->root_container.signature = c;
5176 /* Calculate the actual user body size, by removing
5177 * the trailing variant signature and struct offset
5179 m->user_body_size = m->body_size - ((char*) m->footer + m->footer_accessible - p);
5181 /* Pull out the offset table for the fields array */
5182 sz = bus_gvariant_determine_word_size(m->fields_size, 0);
5187 ri = m->fields_size - sz;
5188 r = message_peek_fields(m, &ri, 1, sz, &q);
5192 framing = bus_gvariant_read_word_le(q, sz);
5193 if (framing >= m->fields_size - sz)
5195 if ((m->fields_size - framing) % sz != 0)
5199 r = message_peek_fields(m, &ri, 1, m->fields_size - framing, &offsets);
5203 n_offsets = (m->fields_size - framing) / sz;
5206 m->user_body_size = m->body_size;
5209 while (ri < m->fields_size) {
5210 _cleanup_free_ char *sig = NULL;
5211 const char *signature;
5212 uint64_t field_type;
5213 size_t item_size = (size_t) -1;
5215 if (BUS_MESSAGE_IS_GVARIANT(m)) {
5224 ri = ALIGN_TO(bus_gvariant_read_word_le((uint8_t*) offsets + (i-1)*sz, sz), 8);
5226 r = message_peek_fields(m, &ri, 8, 8, (void**) &u64);
5230 field_type = BUS_MESSAGE_BSWAP64(m, *u64);
5234 r = message_peek_fields(m, &ri, 8, 1, (void**) &u8);
5241 if (BUS_MESSAGE_IS_GVARIANT(m)) {
5246 end = bus_gvariant_read_word_le((uint8_t*) offsets + i*sz, sz);
5251 where = ri = ALIGN_TO(ri, 8);
5252 item_size = end - ri;
5253 r = message_peek_fields(m, &where, 1, item_size, &q);
5257 b = memrchr(q, 0, item_size);
5261 sig = strndup(b+1, item_size - (b+1-(char*) q));
5266 item_size = b - (char*) q;
5268 r = message_peek_field_signature(m, &ri, 0, &signature);
5273 switch (field_type) {
5275 case _BUS_MESSAGE_HEADER_INVALID:
5278 case BUS_MESSAGE_HEADER_PATH:
5283 if (!streq(signature, "o"))
5286 r = message_peek_field_string(m, object_path_is_valid, &ri, item_size, &m->path);
5289 case BUS_MESSAGE_HEADER_INTERFACE:
5294 if (!streq(signature, "s"))
5297 r = message_peek_field_string(m, interface_name_is_valid, &ri, item_size, &m->interface);
5300 case BUS_MESSAGE_HEADER_MEMBER:
5305 if (!streq(signature, "s"))
5308 r = message_peek_field_string(m, member_name_is_valid, &ri, item_size, &m->member);
5311 case BUS_MESSAGE_HEADER_ERROR_NAME:
5316 if (!streq(signature, "s"))
5319 r = message_peek_field_string(m, error_name_is_valid, &ri, item_size, &m->error.name);
5321 m->error._need_free = -1;
5325 case BUS_MESSAGE_HEADER_DESTINATION:
5330 if (!streq(signature, "s"))
5333 r = message_peek_field_string(m, service_name_is_valid, &ri, item_size, &m->destination);
5336 case BUS_MESSAGE_HEADER_SENDER:
5341 if (!streq(signature, "s"))
5344 r = message_peek_field_string(m, service_name_is_valid, &ri, item_size, &m->sender);
5346 if (r >= 0 && m->sender[0] == ':' && m->bus->bus_client && !m->bus->is_kernel) {
5347 m->creds.unique_name = (char*) m->sender;
5348 m->creds.mask |= SD_BUS_CREDS_UNIQUE_NAME & m->bus->creds_mask;
5354 case BUS_MESSAGE_HEADER_SIGNATURE: {
5358 if (BUS_MESSAGE_IS_GVARIANT(m)) /* only applies to dbus1 */
5361 if (m->root_container.signature)
5364 if (!streq(signature, "g"))
5367 r = message_peek_field_signature(m, &ri, item_size, &s);
5375 free(m->root_container.signature);
5376 m->root_container.signature = c;
5380 case BUS_MESSAGE_HEADER_REPLY_SERIAL:
5382 if (m->reply_cookie != 0)
5385 if (BUS_MESSAGE_IS_GVARIANT(m)) {
5386 /* 64bit on dbus2 */
5388 if (!streq(signature, "t"))
5391 r = message_peek_field_uint64(m, &ri, item_size, &m->reply_cookie);
5395 /* 32bit on dbus1 */
5398 if (!streq(signature, "u"))
5401 r = message_peek_field_uint32(m, &ri, item_size, &serial);
5405 m->reply_cookie = serial;
5408 if (m->reply_cookie == 0)
5413 case BUS_MESSAGE_HEADER_UNIX_FDS:
5417 if (!streq(signature, "u"))
5420 r = message_peek_field_uint32(m, &ri, item_size, &unix_fds);
5424 unix_fds_set = true;
5428 if (!BUS_MESSAGE_IS_GVARIANT(m))
5429 r = message_skip_fields(m, &ri, (uint32_t) -1, (const char **) &signature);
5438 if (m->n_fds != unix_fds)
5441 switch (m->header->type) {
5443 case SD_BUS_MESSAGE_SIGNAL:
5444 if (!m->path || !m->interface || !m->member)
5447 if (m->reply_cookie != 0)
5452 case SD_BUS_MESSAGE_METHOD_CALL:
5454 if (!m->path || !m->member)
5457 if (m->reply_cookie != 0)
5462 case SD_BUS_MESSAGE_METHOD_RETURN:
5464 if (m->reply_cookie == 0)
5468 case SD_BUS_MESSAGE_METHOD_ERROR:
5470 if (m->reply_cookie == 0 || !m->error.name)
5475 /* Refuse non-local messages that claim they are local */
5476 if (streq_ptr(m->path, "/org/freedesktop/DBus/Local"))
5478 if (streq_ptr(m->interface, "org.freedesktop.DBus.Local"))
5480 if (streq_ptr(m->sender, "org.freedesktop.DBus.Local"))
5483 m->root_container.end = m->user_body_size;
5485 if (BUS_MESSAGE_IS_GVARIANT(m)) {
5486 r = build_struct_offsets(
5488 m->root_container.signature,
5490 &m->root_container.item_size,
5491 &m->root_container.offsets,
5492 &m->root_container.n_offsets);
5497 /* Try to read the error message, but if we can't it's a non-issue */
5498 if (m->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
5499 (void) sd_bus_message_read(m, "s", &m->error.message);
5504 _public_ int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) {
5505 assert_return(m, -EINVAL);
5506 assert_return(destination, -EINVAL);
5507 assert_return(!m->sealed, -EPERM);
5508 assert_return(!m->destination, -EEXIST);
5510 return message_append_field_string(m, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &m->destination);
5513 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz) {
5517 struct bus_body_part *part;
5523 total = BUS_MESSAGE_SIZE(m);
5529 e = mempcpy(p, m->header, BUS_MESSAGE_BODY_BEGIN(m));
5530 MESSAGE_FOREACH_PART(part, i, m)
5531 e = mempcpy(e, part->data, part->size);
5533 assert(total == (size_t) ((uint8_t*) e - (uint8_t*) p));
5541 int bus_message_read_strv_extend(sd_bus_message *m, char ***l) {
5548 r = sd_bus_message_enter_container(m, 'a', "s");
5552 while ((r = sd_bus_message_read_basic(m, 's', &s)) > 0) {
5553 r = strv_extend(l, s);
5560 r = sd_bus_message_exit_container(m);
5567 _public_ int sd_bus_message_read_strv(sd_bus_message *m, char ***l) {
5571 assert_return(m, -EINVAL);
5572 assert_return(m->sealed, -EPERM);
5573 assert_return(l, -EINVAL);
5575 r = bus_message_read_strv_extend(m, &strv);
5585 int bus_message_get_arg(sd_bus_message *m, unsigned i, const char **str, char ***strv) {
5586 const char *contents;
5595 r = sd_bus_message_rewind(m, true);
5600 r = sd_bus_message_peek_type(m, &type, &contents);
5606 /* Don't match against arguments after the first one we don't understand */
5607 if (!IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE) &&
5608 !(type == SD_BUS_TYPE_ARRAY && STR_IN_SET(contents, "s", "o", "g")))
5614 r = sd_bus_message_skip(m, NULL);
5619 if (type == SD_BUS_TYPE_ARRAY) {
5621 r = sd_bus_message_read_strv(m, strv);
5628 r = sd_bus_message_read_basic(m, type, str);
5638 _public_ int sd_bus_message_get_errno(sd_bus_message *m) {
5639 assert_return(m, EINVAL);
5641 if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
5644 return sd_bus_error_get_errno(&m->error);
5647 _public_ const char* sd_bus_message_get_signature(sd_bus_message *m, int complete) {
5648 struct bus_container *c;
5650 assert_return(m, NULL);
5652 c = complete ? &m->root_container : message_get_container(m);
5653 return strempty(c->signature);
5656 _public_ int sd_bus_message_is_empty(sd_bus_message *m) {
5657 assert_return(m, -EINVAL);
5659 return isempty(m->root_container.signature);
5662 _public_ int sd_bus_message_has_signature(sd_bus_message *m, const char *signature) {
5663 assert_return(m, -EINVAL);
5665 return streq(strempty(m->root_container.signature), strempty(signature));
5668 _public_ int sd_bus_message_copy(sd_bus_message *m, sd_bus_message *source, int all) {
5669 bool done_something = false;
5672 assert_return(m, -EINVAL);
5673 assert_return(source, -EINVAL);
5674 assert_return(!m->sealed, -EPERM);
5675 assert_return(source->sealed, -EPERM);
5678 const char *contents;
5693 r = sd_bus_message_peek_type(source, &type, &contents);
5699 done_something = true;
5701 if (bus_type_is_container(type) > 0) {
5703 r = sd_bus_message_enter_container(source, type, contents);
5707 r = sd_bus_message_open_container(m, type, contents);
5711 r = sd_bus_message_copy(m, source, true);
5715 r = sd_bus_message_close_container(m);
5719 r = sd_bus_message_exit_container(source);
5726 r = sd_bus_message_read_basic(source, type, &basic);
5732 if (type == SD_BUS_TYPE_OBJECT_PATH ||
5733 type == SD_BUS_TYPE_SIGNATURE ||
5734 type == SD_BUS_TYPE_STRING)
5735 r = sd_bus_message_append_basic(m, type, basic.string);
5737 r = sd_bus_message_append_basic(m, type, &basic);
5744 return done_something;
5747 _public_ int sd_bus_message_verify_type(sd_bus_message *m, char type, const char *contents) {
5752 assert_return(m, -EINVAL);
5753 assert_return(m->sealed, -EPERM);
5754 assert_return(!type || bus_type_is_valid(type), -EINVAL);
5755 assert_return(!contents || signature_is_valid(contents, true), -EINVAL);
5756 assert_return(type || contents, -EINVAL);
5757 assert_return(!contents || !type || bus_type_is_container(type), -EINVAL);
5759 r = sd_bus_message_peek_type(m, &t, &c);
5763 if (type != 0 && type != t)
5766 if (contents && !streq_ptr(contents, c))
5772 _public_ sd_bus *sd_bus_message_get_bus(sd_bus_message *m) {
5773 assert_return(m, NULL);
5778 int bus_message_remarshal(sd_bus *bus, sd_bus_message **m) {
5779 _cleanup_bus_message_unref_ sd_bus_message *n = NULL;
5787 switch ((*m)->header->type) {
5789 case SD_BUS_MESSAGE_SIGNAL:
5790 r = sd_bus_message_new_signal(bus, &n, (*m)->path, (*m)->interface, (*m)->member);
5796 case SD_BUS_MESSAGE_METHOD_CALL:
5797 r = sd_bus_message_new_method_call(bus, &n, (*m)->destination, (*m)->path, (*m)->interface, (*m)->member);
5803 case SD_BUS_MESSAGE_METHOD_RETURN:
5804 case SD_BUS_MESSAGE_METHOD_ERROR:
5806 n = message_new(bus, (*m)->header->type);
5810 n->reply_cookie = (*m)->reply_cookie;
5812 r = message_append_reply_cookie(n, n->reply_cookie);
5816 if ((*m)->header->type == SD_BUS_MESSAGE_METHOD_ERROR && (*m)->error.name) {
5817 r = message_append_field_string(n, BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, (*m)->error.name, &n->error.message);
5821 n->error._need_free = -1;
5830 if ((*m)->destination && !n->destination) {
5831 r = message_append_field_string(n, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, (*m)->destination, &n->destination);
5836 if ((*m)->sender && !n->sender) {
5837 r = message_append_field_string(n, BUS_MESSAGE_HEADER_SENDER, SD_BUS_TYPE_STRING, (*m)->sender, &n->sender);
5842 n->header->flags |= (*m)->header->flags & (BUS_MESSAGE_NO_REPLY_EXPECTED|BUS_MESSAGE_NO_AUTO_START);
5844 r = sd_bus_message_copy(n, *m, true);
5848 timeout = (*m)->timeout;
5849 if (timeout == 0 && !((*m)->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED))
5850 timeout = BUS_DEFAULT_TIMEOUT;
5852 r = bus_message_seal(n, BUS_MESSAGE_COOKIE(*m), timeout);
5856 sd_bus_message_unref(*m);
5863 int bus_message_append_sender(sd_bus_message *m, const char *sender) {
5867 assert_return(!m->sealed, -EPERM);
5868 assert_return(!m->sender, -EPERM);
5870 return message_append_field_string(m, BUS_MESSAGE_HEADER_SENDER, SD_BUS_TYPE_STRING, sender, &m->sender);
5873 _public_ int sd_bus_message_get_priority(sd_bus_message *m, int64_t *priority) {
5874 assert_return(m, -EINVAL);
5875 assert_return(priority, -EINVAL);
5877 *priority = m->priority;
5881 _public_ int sd_bus_message_set_priority(sd_bus_message *m, int64_t priority) {
5882 assert_return(m, -EINVAL);
5883 assert_return(!m->sealed, -EPERM);
5885 m->priority = priority;