HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/libsystemd/sd-bus/bus-message.c

140,617 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 81f78f8036f3d70b14af45edd5d008e1d7ca1d64

Lines 2001–3000 of 4,752

 
                        break;
                }
 
                case SD_BUS_TYPE_VARIANT: {
                        const char *s;
 
                        s = va_arg(ap, const char*);
                        if (!s)
                                return -EINVAL;
 
                        r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, s);
                        if (r < 0)
                                return r;
 
                        r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
                        if (r < 0)
                                return r;
 
                        types = s;
                        n_struct = strlen(s);
                        n_array = UINT_MAX;
 
                        break;
                }
 
                case SD_BUS_TYPE_STRUCT_BEGIN:
                case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
                        size_t k;
 
                        r = signature_element_length(t, &k);
                        if (r < 0)
                                return r;
                        if (k < 2)
                                return -ERANGE;
 
                        {
                                char s[k - 1];
 
                                memcpy(s, t + 1, k - 2);
                                s[k - 2] = 0;
 
                                r = sd_bus_message_open_container(m, *t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
                                if (r < 0)
                                        return r;
                        }
 
                        if (n_array == UINT_MAX) {
                                types += k - 1;
                                n_struct -= k - 1;
                        }
 
                        r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
                        if (r < 0)
                                return r;
 
                        types = t + 1;
                        n_struct = k - 2;
                        n_array = UINT_MAX;
 
                        break;
                }
 
                default:
                        r = -EINVAL;
                }
 
                if (r < 0)
                        return r;
        }
 
        return 1;
}
 
_public_ int sd_bus_message_append(sd_bus_message *m, const char *types, ...) {
        va_list ap;
        int r;
 
        va_start(ap, types);
        r = sd_bus_message_appendv(m, types, ap);
        va_end(ap);
 
        return r;
}
 
_public_ int sd_bus_message_append_array_space(
                sd_bus_message *m,
                char type,
                size_t size,
                void **ret) {
 
        ssize_t align, sz;
        void *a;
        int r;
 
        assert_return(m, -EINVAL);
        assert_return(!m->sealed, -EPERM);
        assert_return(bus_type_is_trivial(type) && type != SD_BUS_TYPE_BOOLEAN, -EINVAL);
        assert_return(ret || size == 0, -EINVAL);
        assert_return(!m->poisoned, -ESTALE);
 
        align = bus_type_get_alignment(type);
        sz = bus_type_get_size(type);
 
        assert_se(align > 0);
        assert_se(sz > 0);
 
        if (size % sz != 0)
                return -EINVAL;
 
        r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
        if (r < 0)
                return r;
 
        a = message_extend_body(m, align, size);
        if (!a)
                return -ENOMEM;
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return r;
 
        *ret = a;
        return 0;
}
 
_public_ int sd_bus_message_append_array(
                sd_bus_message *m,
                char type,
                const void *ptr,
                size_t size) {
        int r;
        void *p;
 
        assert_return(m, -EINVAL);
        assert_return(!m->sealed, -EPERM);
        assert_return(bus_type_is_trivial(type), -EINVAL);
        assert_return(ptr || size == 0, -EINVAL);
        assert_return(!m->poisoned, -ESTALE);
 
        r = sd_bus_message_append_array_space(m, type, size, &p);
        if (r < 0)
                return r;
 
        memcpy_safe(p, ptr, size);
 
        return 0;
}
 
_public_ int sd_bus_message_append_array_iovec(
                sd_bus_message *m,
                char type,
                const struct iovec *iov,
                unsigned n /* should be size_t, but is API now… 😞 */) {
 
        int r;
 
        assert_return(m, -EINVAL);
        assert_return(!m->sealed, -EPERM);
        assert_return(bus_type_is_trivial(type), -EINVAL);
        assert_return(iov || n == 0, -EINVAL);
        assert_return(!m->poisoned, -ESTALE);
 
        size_t size = iovec_total_size(iov, n);
        if (size == SIZE_MAX)
                return -ENOBUFS;
 
        void *p;
        r = sd_bus_message_append_array_space(m, type, size, &p);
        if (r < 0)
                return r;
 
        for (unsigned i = 0; i < n; i++) {
 
                if (iov[i].iov_base)
                        memcpy(p, iov[i].iov_base, iov[i].iov_len);
                else
                        memzero(p, iov[i].iov_len);
 
                p = (uint8_t*) p + iov[i].iov_len;
        }
 
        return 0;
}
 
_public_ int sd_bus_message_append_array_memfd(
                sd_bus_message *m,
                char type,
                int memfd,
                uint64_t offset,
                uint64_t size) {
 
        _cleanup_close_ int copy_fd = -EBADF;
        BusMessageBodyPart *part;
        ssize_t align, sz;
        uint64_t real_size;
        void *a;
        int r;
 
        assert_return(m, -EINVAL);
        assert_return(memfd >= 0, -EBADF);
        assert_return(bus_type_is_trivial(type), -EINVAL);
        assert_return(size > 0, -EINVAL);
        assert_return(!m->sealed, -EPERM);
        assert_return(!m->poisoned, -ESTALE);
 
        r = memfd_set_sealed_gracefully(memfd);
        if (r < 0)
                return r;
 
        copy_fd = fcntl(memfd, F_DUPFD_CLOEXEC, 3);
        if (copy_fd < 0)
                return -errno;
 
        r = memfd_get_size(memfd, &real_size);
        if (r < 0)
                return r;
 
        if (offset == 0 && size == UINT64_MAX)
                size = real_size;
        else if (size > real_size || offset > real_size - size)
                return -EMSGSIZE;
 
        align = bus_type_get_alignment(type);
        sz = bus_type_get_size(type);
 
        assert_se(align > 0);
        assert_se(sz > 0);
 
        if (offset % align != 0)
                return -EINVAL;
 
        if (size % sz != 0)
                return -EINVAL;
 
        if (size == 0)
                return -EINVAL;
 
        if (size > (uint64_t) UINT32_MAX)
                return -EINVAL;
 
        r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
        if (r < 0)
                return r;
 
        a = message_extend_body(m, align, 0);
        if (!a)
                return -ENOMEM;
 
        part = message_append_part(m);
        if (!part)
                return -ENOMEM;
 
        if (m->body_size > UINT32_MAX - size)
                return -EMSGSIZE;
 
        part->memfd = TAKE_FD(copy_fd);
        part->memfd_offset = offset;
        part->sealed = true;
        part->size = size;
 
        m->body_size += size;
        message_extend_containers(m, size);
 
        return sd_bus_message_close_container(m);
}
 
_public_ int sd_bus_message_append_string_memfd(
                sd_bus_message *m,
                int memfd,
                uint64_t offset,
                uint64_t size) {
 
        _cleanup_close_ int copy_fd = -EBADF;
        BusMessageBodyPart *part;
        BusMessageContainer *c;
        uint64_t real_size;
        void *a;
        int r;
 
        assert_return(m, -EINVAL);
        assert_return(memfd >= 0, -EBADF);
        assert_return(size > 0, -EINVAL);
        assert_return(!m->sealed, -EPERM);
        assert_return(!m->poisoned, -ESTALE);
 
        r = memfd_set_sealed_gracefully(memfd);
        if (r < 0)
                return r;
 
        copy_fd = fcntl(memfd, F_DUPFD_CLOEXEC, 3);
        if (copy_fd < 0)
                return -errno;
 
        r = memfd_get_size(memfd, &real_size);
        if (r < 0)
                return r;
 
        if (offset == 0 && size == UINT64_MAX)
                size = real_size;
        else if (size > real_size || offset > real_size - size)
                return -EMSGSIZE;
 
        /* We require this to be NUL terminated */
        if (size == 0)
                return -EINVAL;
 
        if (size > (uint64_t) UINT32_MAX)
                return -EINVAL;
 
        c = message_get_last_container(m);
        if (c->signature && c->signature[c->index]) {
                /* Container signature is already set */
 
                if (c->signature[c->index] != SD_BUS_TYPE_STRING)
                        return -ENXIO;
        } else {
                char *e;
 
                /* Maybe we can append to the signature? But only if this is the top-level container */
                if (c->enclosing != 0)
                        return -ENXIO;
 
                e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRING));
                if (!e) {
                        m->poisoned = true;
                        return -ENOMEM;
                }
        }
 
        a = message_extend_body(m, 4, 4);
        if (!a)
                return -ENOMEM;
 
        *(uint32_t*) a = size - 1;
 
        part = message_append_part(m);
        if (!part)
                return -ENOMEM;
 
        if (m->body_size > UINT32_MAX - size)
                return -EMSGSIZE;
 
        part->memfd = TAKE_FD(copy_fd);
        part->memfd_offset = offset;
        part->sealed = true;
        part->size = size;
 
        m->body_size += size;
        message_extend_containers(m, size);
 
        if (c->enclosing != SD_BUS_TYPE_ARRAY)
                c->index++;
 
        return 0;
}
 
_public_ int sd_bus_message_append_strv(sd_bus_message *m, char **l) {
        int r;
 
        assert_return(m, -EINVAL);
        assert_return(!m->sealed, -EPERM);
        assert_return(!m->poisoned, -ESTALE);
 
        r = sd_bus_message_open_container(m, 'a', "s");
        if (r < 0)
                return r;
 
        STRV_FOREACH(i, l) {
                r = sd_bus_message_append_basic(m, 's', *i);
                if (r < 0)
                        return r;
        }
 
        return sd_bus_message_close_container(m);
}
 
static int bus_message_close_header(sd_bus_message *m) {
        assert(m);
 
        /* The actual user data is finished now, we just complete the variant and struct now. Remember
         * this position, so that during parsing we know where to put the outer container end. */
        m->user_body_size = m->body_size;
 
        m->header->fields_size = m->fields_size;
        m->header->body_size = m->body_size;
 
        return 0;
}
 
_public_ int sd_bus_message_seal(sd_bus_message *m, uint64_t cookie, uint64_t timeout_usec) {
        BusMessageBodyPart *part;
        size_t a;
        unsigned i;
        int r;
 
        assert_return(m, -EINVAL);
 
        if (m->sealed)
                return -EPERM;
 
        if (m->n_containers > 0)
                return -EBADMSG;
 
        if (m->poisoned)
                return -ESTALE;
 
        if (cookie > UINT32_MAX)
                return -EOPNOTSUPP;
 
        /* In vtables the return signature of method calls is listed,
         * let's check if they match if this is a response */
        if (m->header->type == SD_BUS_MESSAGE_METHOD_RETURN &&
            m->enforced_reply_signature &&
            !streq(strempty(m->root_container.signature), m->enforced_reply_signature))
                return -ENOMSG;
 
        /* If there's a non-trivial signature set, then add it in here */
        if (!isempty(m->root_container.signature)) {
                r = message_append_field_signature(m, BUS_MESSAGE_HEADER_SIGNATURE, m->root_container.signature, NULL);
                if (r < 0)
                        return r;
        }
 
        if (m->n_fds > 0) {
                r = message_append_field_uint32(m, BUS_MESSAGE_HEADER_UNIX_FDS, m->n_fds);
                if (r < 0)
                        return r;
        }
 
        r = bus_message_close_header(m);
        if (r < 0)
                return r;
 
        m->header->serial = (uint32_t) cookie;
 
        m->timeout = m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED ? 0 : timeout_usec;
 
        /* Add padding at the end of the fields part, since we know
         * the body needs to start at an 8 byte alignment. We made
         * sure we allocated enough space for this, so all we need to
         * do here is to zero it out. */
        a = ALIGN8(m->fields_size) - m->fields_size;
        if (a > 0)
                memzero((uint8_t*) BUS_MESSAGE_FIELDS(m) + m->fields_size, a);
 
        /* If this is something we can send as memfd, then let's seal
        the memfd now. Note that we can send memfds as payload only
        for directed messages, and not for broadcasts. */
        if (m->destination && m->bus->use_memfd) {
                MESSAGE_FOREACH_PART(part, i, m)
                        if (part->memfd >= 0 &&
                            !part->sealed &&
                            (part->size > MEMFD_MIN_SIZE || m->bus->use_memfd < 0) &&
                            part != m->body_end) { /* The last part may never be sent as memfd */
                                uint64_t sz;
 
                                /* Try to seal it if that makes
                                 * sense. First, unmap our own map to
                                 * make sure we don't keep it busy. */
                                bus_body_part_unmap(part);
 
                                /* Then, sync up real memfd size */
                                sz = part->size;
                                r = memfd_set_size(part->memfd, sz);
                                if (r < 0)
                                        return r;
 
                                /* Finally, try to seal */
                                if (memfd_set_sealed(part->memfd) >= 0)
                                        part->sealed = true;
                        }
        }
 
        m->root_container.end = m->user_body_size;
        m->root_container.index = 0;
 
        m->sealed = true;
 
        return 0;
}
 
int bus_body_part_map(BusMessageBodyPart *part) {
        void *p;
        size_t psz, shift;
 
        assert_se(part);
 
        if (part->data)
                return 0;
 
        if (part->size <= 0)
                return 0;
 
        /* For smaller zero parts (as used for padding) we don't need to map anything... */
        if (part->memfd < 0 && part->is_zero && part->size < 8) {
                static const uint8_t zeroes[7] = { };
                part->data = (void*) zeroes;
                return 0;
        }
 
        shift = PAGE_OFFSET(part->memfd_offset);
        psz = PAGE_ALIGN(part->size + shift);
        if (psz >= SIZE_MAX)
                return -EFBIG;
 
        if (part->memfd >= 0)
                p = mmap(NULL, psz, PROT_READ, MAP_PRIVATE, part->memfd, part->memfd_offset - shift);
        else if (part->is_zero)
                p = mmap(NULL, psz, PROT_READ, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
        else
                return -EINVAL;
 
        if (p == MAP_FAILED)
                return -errno;
 
        part->mapped = psz;
        part->mmap_begin = p;
        part->data = (uint8_t*) p + shift;
        part->munmap_this = true;
 
        return 0;
}
 
void bus_body_part_unmap(BusMessageBodyPart *part) {
 
        assert_se(part);
 
        if (part->memfd < 0)
                return;
 
        if (!part->mmap_begin)
                return;
 
        if (!part->munmap_this)
                return;
 
        assert_se(munmap(part->mmap_begin, part->mapped) == 0);
 
        part->mmap_begin = NULL;
        part->data = NULL;
        part->mapped = 0;
        part->munmap_this = false;
 
        return;
}
 
static bool message_end_of_signature(sd_bus_message *m) {
        BusMessageContainer *c;
 
        assert(m);
 
        c = message_get_last_container(m);
        return !c->signature || c->signature[c->index] == 0;
}
 
static bool message_end_of_array(sd_bus_message *m, size_t index) {
        BusMessageContainer *c;
 
        assert(m);
 
        c = message_get_last_container(m);
        if (c->enclosing != SD_BUS_TYPE_ARRAY)
                return false;
 
        assert(c->array_size);
        return index >= c->begin + BUS_MESSAGE_BSWAP32(m, *c->array_size);
}
 
_public_ int sd_bus_message_at_end(sd_bus_message *m, int complete) {
        assert_return(m, -EINVAL);
        assert_return(m->sealed, -EPERM);
 
        if (complete && m->n_containers > 0)
                return false;
 
        if (message_end_of_signature(m))
                return true;
 
        if (message_end_of_array(m, m->rindex))
                return true;
 
        return false;
}
 
static BusMessageBodyPart* find_part(sd_bus_message *m, size_t index, size_t sz, void **ret) {
        BusMessageBodyPart *part;
        size_t begin;
        int r;
 
        assert(m);
 
        if (m->cached_rindex_part && index >= m->cached_rindex_part_begin) {
                part = m->cached_rindex_part;
                begin = m->cached_rindex_part_begin;
        } else {
                part = &m->body;
                begin = 0;
        }
 
        while (part) {
                if (index < begin)
                        return NULL;
 
                if (index + sz <= begin + part->size) {
 
                        r = bus_body_part_map(part);
                        if (r < 0)
                                return NULL;
 
                        if (ret)
                                *ret = part->data ? (uint8_t*) part->data + index - begin
                                        : NULL; /* Avoid dereferencing a NULL pointer. */
 
                        m->cached_rindex_part = part;
                        m->cached_rindex_part_begin = begin;
 
                        return part;
                }
 
                begin += part->size;
                part = part->next;
        }
 
        return NULL;
}
 
static int message_peek_body(
                sd_bus_message *m,
                size_t *rindex,
                size_t align,
                size_t nbytes,
                void **ret) {
 
        size_t k, start, end, padding;
        BusMessageBodyPart *part;
        uint8_t *q;
 
        assert(m);
        assert(rindex);
        assert(align > 0);
 
        start = ALIGN_TO(*rindex, align);
        if (start > m->user_body_size)
                return -EBADMSG;
 
        padding = start - *rindex;
 
        /* Avoid overflow below */
        if (nbytes > SIZE_MAX - start)
                return -EBADMSG;
 
        end = start + nbytes;
        if (end > m->user_body_size)
                return -EBADMSG;
 
        part = find_part(m, *rindex, padding, (void**) &q);
        if (!part)
                return -EBADMSG;
 
        if (q) {
                /* Verify padding */
                for (k = 0; k < padding; k++)
                        if (q[k] != 0)
                                return -EBADMSG;
        }
 
        part = find_part(m, start, nbytes, (void**) &q);
        if (!part || (nbytes > 0 && !q))
                return -EBADMSG;
 
        *rindex = end;
 
        if (ret)
                *ret = q;
 
        return 0;
}
 
static bool validate_nul(const char *s, size_t l) {
 
        /* Check for NUL chars in the string */
        if (memchr(s, 0, l))
                return false;
 
        /* Check for NUL termination */
        if (s[l] != 0)
                return false;
 
        return true;
}
 
static bool validate_string(const char *s, size_t l) {
 
        if (!validate_nul(s, l))
                return false;
 
        /* Check if valid UTF8 */
        if (!utf8_is_valid(s))
                return false;
 
        return true;
}
 
static bool validate_signature(const char *s, size_t l) {
 
        if (!validate_nul(s, l))
                return false;
 
        /* Check if valid signature */
        if (!signature_is_valid(s, true))
                return false;
 
        return true;
}
 
static bool validate_object_path(const char *s, size_t l) {
 
        if (!validate_nul(s, l))
                return false;
 
        if (!object_path_is_valid(s))
                return false;
 
        return true;
}
 
_public_ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *ret) {
        BusMessageContainer *c;
        size_t rindex;
        void *q;
        int r;
 
        assert_return(m, -EINVAL);
        assert_return(m->sealed, -EPERM);
        assert_return(bus_type_is_basic(type), -EINVAL);
 
        if (message_end_of_signature(m))
                return -ENXIO;
 
        if (message_end_of_array(m, m->rindex))
                return 0;
 
        c = message_get_last_container(m);
        if (c->signature[c->index] != type)
                return -ENXIO;
 
        rindex = m->rindex;
 
        if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH)) {
                uint32_t l;
                bool ok;
 
                r = message_peek_body(m, &rindex, 4, 4, &q);
                if (r < 0)
                        return r;
 
                l = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
                if (l == UINT32_MAX)
                        /* avoid overflow right below */
                        return -EBADMSG;
 
                r = message_peek_body(m, &rindex, 1, l+1, &q);
                if (r < 0)
                        return r;
 
                if (type == SD_BUS_TYPE_OBJECT_PATH)
                        ok = validate_object_path(q, l);
                else
                        ok = validate_string(q, l);
                if (!ok)
                        return -EBADMSG;
 
                if (ret)
                        *(const char**) ret = q;
 
        } else if (type == SD_BUS_TYPE_SIGNATURE) {
                uint8_t l;
 
                r = message_peek_body(m, &rindex, 1, 1, &q);
                if (r < 0)
                        return r;
 
                l = *(uint8_t*) q;
                if (l == UINT8_MAX)
                        /* avoid overflow right below */
                        return -EBADMSG;
 
                r = message_peek_body(m, &rindex, 1, l+1, &q);
                if (r < 0)
                        return r;
 
                if (!validate_signature(q, l))
                        return -EBADMSG;
 
                if (ret)
                        *(const char**) ret = q;
 
        } else {
                ssize_t sz, align;
 
                align = bus_type_get_alignment(type);
                assert(align > 0);
 
                sz = bus_type_get_size(type);
                assert(sz > 0);
 
                r = message_peek_body(m, &rindex, align, sz, &q);
                if (r < 0)
                        return r;
 
                switch (type) {
 
                case SD_BUS_TYPE_BYTE:
                        if (ret)
                                *(uint8_t*) ret = *(uint8_t*) q;
                        break;
 
                case SD_BUS_TYPE_BOOLEAN:
                        if (ret)
                                *(int*) ret = !!*(uint32_t*) q;
                        break;
 
                case SD_BUS_TYPE_INT16:
                case SD_BUS_TYPE_UINT16:
                        if (ret)
                                *(uint16_t*) ret = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q);
                        break;
 
                case SD_BUS_TYPE_INT32:
                case SD_BUS_TYPE_UINT32:
                        if (ret)
                                *(uint32_t*) ret = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
                        break;
 
                case SD_BUS_TYPE_INT64:
                case SD_BUS_TYPE_UINT64:
                case SD_BUS_TYPE_DOUBLE:
                        if (ret)
                                *(uint64_t*) ret = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q);
                        break;
 
                case SD_BUS_TYPE_UNIX_FD: {
                        uint32_t j;
 
                        j = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
                        if (j >= m->n_fds)
                                return -EBADMSG;
 
                        if (ret)
                                *(int*) ret = m->fds[j];
                        break;
                }
 
                default:
                        assert_not_reached();
                }
        }
 
        m->rindex = rindex;
 
        if (c->enclosing != SD_BUS_TYPE_ARRAY)
                c->index++;
 
        return 1;
}
 
static int bus_message_enter_array(
                sd_bus_message *m,
                BusMessageContainer *c,
                const char *contents,
                uint32_t **ret_array_size) {
 
        size_t rindex;
        void *q;
        int alignment, r;
 
        assert(m);
        assert(c);
        assert(contents);
        assert(ret_array_size);
 
        if (!signature_is_single(contents, true))
                return -EINVAL;
 
        if (!c->signature || c->signature[c->index] == 0)
                return -ENXIO;
 
        if (c->signature[c->index] != SD_BUS_TYPE_ARRAY)
                return -ENXIO;
 
        if (!startswith(c->signature + c->index + 1, contents))
                return -ENXIO;
 
        rindex = m->rindex;
 
        r = message_peek_body(m, &rindex, 4, 4, &q);
        if (r < 0)
                return r;
 
        if (BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q) > BUS_ARRAY_MAX_SIZE)
                return -EBADMSG;
 
        alignment = bus_type_get_alignment(contents[0]);
        if (alignment < 0)
                return alignment;
 
        r = message_peek_body(m, &rindex, alignment, 0, NULL);
        if (r < 0)
                return r;
 
        *ret_array_size = (uint32_t*) q;
 
        m->rindex = rindex;
 
        if (c->enclosing != SD_BUS_TYPE_ARRAY)
                c->index += 1 + strlen(contents);
 
        return 1;
}
 
static int bus_message_enter_variant(
                sd_bus_message *m,
                BusMessageContainer *c,
                const char *contents) {
 
        size_t rindex;
        uint8_t l;
        void *q;
        int r;
 
        assert(m);
        assert(c);
        assert(contents);
 
        if (!signature_is_single(contents, false))
                return -EINVAL;
 
        if (*contents == SD_BUS_TYPE_DICT_ENTRY_BEGIN)
                return -EINVAL;
 
        if (!c->signature || c->signature[c->index] == 0)
                return -ENXIO;
 
        if (c->signature[c->index] != SD_BUS_TYPE_VARIANT)
                return -ENXIO;
 
        rindex = m->rindex;
 
        r = message_peek_body(m, &rindex, 1, 1, &q);
        if (r < 0)
                return r;
 
        l = *(uint8_t*) q;
        if (l == UINT8_MAX)
                /* avoid overflow right below */
                return -EBADMSG;
 
        r = message_peek_body(m, &rindex, 1, l+1, &q);
        if (r < 0)
                return r;
 
        if (!validate_signature(q, l))
                return -EBADMSG;
 
        if (!streq(q, contents))
                return -ENXIO;
 
        m->rindex = rindex;
 
        if (c->enclosing != SD_BUS_TYPE_ARRAY)
                c->index++;
 
        return 1;
}
 
static int bus_message_enter_struct(
                sd_bus_message *m,
                BusMessageContainer *c,
                const char *contents) {
 
        size_t l;
        int r;
 
        assert(m);
        assert(c);
        assert(contents);
 
        if (!signature_is_valid(contents, false))
                return -EINVAL;
 
        if (!c->signature || c->signature[c->index] == 0)
                return -ENXIO;
 
        l = strlen(contents);
 
        if (c->signature[c->index] != SD_BUS_TYPE_STRUCT_BEGIN ||
            !startswith(c->signature + c->index + 1, contents) ||
            c->signature[c->index + 1 + l] != SD_BUS_TYPE_STRUCT_END)
                return -ENXIO;