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 3001–4000 of 4,752

 
        r = message_peek_body(m, &m->rindex, 8, 0, NULL);
        if (r < 0)
                return r;
 
        if (c->enclosing != SD_BUS_TYPE_ARRAY)
                c->index += 1 + l + 1;
 
        return 1;
}
 
static int bus_message_enter_dict_entry(
                sd_bus_message *m,
                BusMessageContainer *c,
                const char *contents) {
 
        size_t l;
        int r;
 
        assert(m);
        assert(c);
        assert(contents);
 
        if (!signature_is_pair(contents))
                return -EINVAL;
 
        if (c->enclosing != SD_BUS_TYPE_ARRAY)
                return -ENXIO;
 
        if (!c->signature || c->signature[c->index] == 0)
                return 0;
 
        l = strlen(contents);
 
        if (c->signature[c->index] != SD_BUS_TYPE_DICT_ENTRY_BEGIN ||
            !startswith(c->signature + c->index + 1, contents) ||
            c->signature[c->index + 1 + l] != SD_BUS_TYPE_DICT_ENTRY_END)
                return -ENXIO;
 
        r = message_peek_body(m, &m->rindex, 8, 0, NULL);
        if (r < 0)
                return r;
 
        if (c->enclosing != SD_BUS_TYPE_ARRAY)
                c->index += 1 + l + 1;
 
        return 1;
}
 
_public_ int sd_bus_message_enter_container(
                sd_bus_message *m,
                char type,
                const char *contents) {
 
        BusMessageContainer *c;
        uint32_t *array_size = NULL;
        _cleanup_free_ char *signature = NULL;
        size_t before;
        int r;
 
        assert_return(m, -EINVAL);
        assert_return(m->sealed, -EPERM);
        assert_return(type != 0 || !contents, -EINVAL);
 
        if (type == 0 || !contents) {
                const char *cc;
                char tt;
 
                /* Allow entering into anonymous containers */
                r = sd_bus_message_peek_type(m, &tt, &cc);
                if (r < 0)
                        return r;
 
                if (type != 0 && type != tt)
                        return -ENXIO;
 
                if (contents && !streq(contents, cc))
                        return -ENXIO;
 
                type = tt;
                contents = cc;
        }
 
        /*
         * We enforce a global limit on container depth, that is much
         * higher than the 32 structs and 32 arrays the specification
         * mandates. This is simpler to implement for us, and we need
         * this only to ensure our container array doesn't grow
         * without bounds. We are happy to return any data from a
         * message as long as the data itself is valid, even if the
         * overall message might be not.
         *
         * Note that the message signature is validated when
         * parsing the headers, and that validation does check the
         * 32/32 limit.
         *
         * Note that the specification defines no limits on the depth
         * of stacked variants, but we do.
         */
        if (m->n_containers >= BUS_CONTAINER_DEPTH)
                return -EBADMSG;
 
        if (!GREEDY_REALLOC(m->containers, m->n_containers + 1))
                return -ENOMEM;
 
        if (message_end_of_signature(m))
                return -ENXIO;
 
        if (message_end_of_array(m, m->rindex))
                return 0;
 
        c = message_get_last_container(m);
 
        signature = strdup(contents);
        if (!signature)
                return -ENOMEM;
 
        c->saved_index = c->index;
        before = m->rindex;
 
        if (type == SD_BUS_TYPE_ARRAY)
                r = bus_message_enter_array(m, c, contents, &array_size);
        else if (type == SD_BUS_TYPE_VARIANT)
                r = bus_message_enter_variant(m, c, contents);
        else if (type == SD_BUS_TYPE_STRUCT)
                r = bus_message_enter_struct(m, c, contents);
        else if (type == SD_BUS_TYPE_DICT_ENTRY)
                r = bus_message_enter_dict_entry(m, c, contents);
        else
                r = -EINVAL;
        if (r <= 0)
                return r;
 
        /* OK, let's fill it in */
        m->containers[m->n_containers++] = (BusMessageContainer) {
                 .enclosing = type,
                 .signature = TAKE_PTR(signature),
 
                 .before = before,
                 .begin = m->rindex,
                 /* Unary type has fixed size of 1, but virtual size of 0 */
                 .end = m->rindex,
                 .array_size = array_size,
        };
 
        return 1;
}
 
_public_ int sd_bus_message_exit_container(sd_bus_message *m) {
        BusMessageContainer *c;
 
        assert_return(m, -EINVAL);
        assert_return(m->sealed, -EPERM);
        assert_return(m->n_containers > 0, -ENXIO);
 
        c = message_get_last_container(m);
 
        if (c->enclosing != SD_BUS_TYPE_ARRAY) {
                if (c->signature && c->signature[c->index] != 0)
                        return -EBUSY;
        }
 
        if (c->enclosing == SD_BUS_TYPE_ARRAY) {
                uint32_t l;
 
                l = BUS_MESSAGE_BSWAP32(m, *c->array_size);
                if (c->begin + l != m->rindex)
                        return -EBUSY;
        }
 
        message_free_last_container(m);
 
        return 1;
}
 
static void message_quit_container(sd_bus_message *m) {
        BusMessageContainer *c;
 
        assert(m);
        assert(m->sealed);
        assert(m->n_containers > 0);
 
        /* Undo seeks */
        c = message_get_last_container(m);
        assert(m->rindex >= c->before);
        m->rindex = c->before;
 
        /* Free container */
        message_free_last_container(m);
 
        /* Correct index of new top-level container */
        c = message_get_last_container(m);
        c->index = c->saved_index;
}
 
_public_ int sd_bus_message_peek_type(sd_bus_message *m, char *ret_type, const char **ret_contents) {
        BusMessageContainer *c;
        int r;
 
        assert_return(m, -EINVAL);
        assert_return(m->sealed, -EPERM);
 
        if (message_end_of_signature(m))
                goto eof;
 
        if (message_end_of_array(m, m->rindex))
                goto eof;
 
        c = message_get_last_container(m);
 
        if (bus_type_is_basic(c->signature[c->index])) {
                if (ret_contents)
                        *ret_contents = NULL;
                if (ret_type)
                        *ret_type = c->signature[c->index];
                return 1;
        }
 
        if (c->signature[c->index] == SD_BUS_TYPE_ARRAY) {
 
                if (ret_contents) {
                        size_t l;
 
                        r = signature_element_length(c->signature+c->index+1, &l);
                        if (r < 0)
                                return r;
 
                        /* signature_element_length does verification internally */
 
                        /* The array element must not be empty */
                        assert(l >= 1);
                        if (free_and_strndup(&c->peeked_signature,
                                             c->signature + c->index + 1, l) < 0)
                                return -ENOMEM;
 
                        *ret_contents = c->peeked_signature;
                }
 
                if (ret_type)
                        *ret_type = SD_BUS_TYPE_ARRAY;
 
                return 1;
        }
 
        if (IN_SET(c->signature[c->index], SD_BUS_TYPE_STRUCT_BEGIN, SD_BUS_TYPE_DICT_ENTRY_BEGIN)) {
 
                if (ret_contents) {
                        size_t l;
 
                        r = signature_element_length(c->signature+c->index, &l);
                        if (r < 0)
                                return r;
 
                        assert(l >= 3);
                        if (free_and_strndup(&c->peeked_signature,
                                             c->signature + c->index + 1, l - 2) < 0)
                                return -ENOMEM;
 
                        *ret_contents = c->peeked_signature;
                }
 
                if (ret_type)
                        *ret_type = c->signature[c->index] == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY;
 
                return 1;
        }
 
        if (c->signature[c->index] == SD_BUS_TYPE_VARIANT) {
                if (ret_contents) {
                        size_t rindex, l;
                        void *q;
 
                        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;
 
                        *ret_contents = q;
                }
 
                if (ret_type)
                        *ret_type = SD_BUS_TYPE_VARIANT;
 
                return 1;
        }
 
        return -EINVAL;
 
eof:
        if (ret_type)
                *ret_type = 0;
        if (ret_contents)
                *ret_contents = NULL;
        return 0;
}
 
_public_ int sd_bus_message_rewind(sd_bus_message *m, int complete) {
        BusMessageContainer *c;
 
        assert_return(m, -EINVAL);
        assert_return(m->sealed, -EPERM);
 
        if (complete) {
                message_reset_containers(m);
                m->rindex = 0;
 
                c = message_get_last_container(m);
        } else {
                c = message_get_last_container(m);
 
                c->index = 0;
                m->rindex = c->begin;
        }
 
        return !isempty(c->signature);
}
 
_public_ int sd_bus_message_readv(
                sd_bus_message *m,
                const char *types,
                va_list ap) {
 
        unsigned n_array, n_struct;
        BusTypeStack stack[BUS_CONTAINER_DEPTH];
        unsigned stack_ptr = 0;
        unsigned n_loop = 0;
        int r;
 
        assert_return(m, -EINVAL);
        assert_return(m->sealed, -EPERM);
        assert_return(types, -EINVAL);
 
        if (isempty(types))
                return 0;
 
        /* Ideally, we'd just call ourselves recursively on every
         * complex type. However, the state of a va_list that is
         * passed to a function is undefined after that function
         * returns. This means we need to decode the va_list linearly
         * in a single stackframe. We hence implement our own
         * home-grown stack in an array. */
 
        n_array = UINT_MAX; /* length of current array entries */
        n_struct = strlen(types); /* length of current struct contents signature */
 
        for (;;) {
                const char *t;
 
                n_loop++;
 
                if (n_array == 0 || (n_array == UINT_MAX && n_struct == 0)) {
                        r = type_stack_pop(stack, ELEMENTSOF(stack), &stack_ptr, &types, &n_struct, &n_array);
                        if (r < 0)
                                return r;
                        if (r == 0)
                                break;
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return r;
 
                        continue;
                }
 
                t = types;
                if (n_array != UINT_MAX)
                        n_array--;
                else {
                        types++;
                        n_struct--;
                }
 
                switch (*t) {
 
                case SD_BUS_TYPE_BYTE:
                case SD_BUS_TYPE_BOOLEAN:
                case SD_BUS_TYPE_INT16:
                case SD_BUS_TYPE_UINT16:
                case SD_BUS_TYPE_INT32:
                case SD_BUS_TYPE_UINT32:
                case SD_BUS_TYPE_INT64:
                case SD_BUS_TYPE_UINT64:
                case SD_BUS_TYPE_DOUBLE:
                case SD_BUS_TYPE_STRING:
                case SD_BUS_TYPE_OBJECT_PATH:
                case SD_BUS_TYPE_SIGNATURE:
                case SD_BUS_TYPE_UNIX_FD: {
                        void *p;
 
                        p = va_arg(ap, void*);
                        r = sd_bus_message_read_basic(m, *t, p);
                        if (r < 0)
                                return r;
                        if (r == 0) {
                                if (n_loop <= 1)
                                        return 0;
 
                                return -ENXIO;
                        }
 
                        break;
                }
 
                case SD_BUS_TYPE_ARRAY: {
                        size_t k;
 
                        r = signature_element_length(t + 1, &k);
                        if (r < 0)
                                return r;
 
                        {
                                char s[k + 1];
                                memcpy(s, t + 1, k);
                                s[k] = 0;
 
                                r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, s);
                                if (r < 0)
                                        return r;
                                if (r == 0) {
                                        if (n_loop <= 1)
                                                return 0;
 
                                        return -ENXIO;
                                }
                        }
 
                        if (n_array == UINT_MAX) {
                                types += k;
                                n_struct -= k;
                        }
 
                        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;
                        n_array = va_arg(ap, unsigned);
 
                        break;
                }
 
                case SD_BUS_TYPE_VARIANT: {
                        const char *s;
 
                        s = va_arg(ap, const char *);
                        if (!s)
                                return -EINVAL;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, s);
                        if (r < 0)
                                return r;
                        if (r == 0) {
                                if (n_loop <= 1)
                                        return 0;
 
                                return -ENXIO;
                        }
 
                        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_enter_container(m, *t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
                                if (r < 0)
                                        return r;
                                if (r == 0) {
                                        if (n_loop <= 1)
                                                return 0;
                                        return -ENXIO;
                                }
                        }
 
                        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:
                        return -EINVAL;
                }
        }
 
        return 1;
}
 
_public_ int sd_bus_message_read(sd_bus_message *m, const char *types, ...) {
        va_list ap;
        int r;
 
        va_start(ap, types);
        r = sd_bus_message_readv(m, types, ap);
        va_end(ap);
 
        return r;
}
 
_public_ int sd_bus_message_skip(sd_bus_message *m, const char *types) {
        int r;
 
        assert_return(m, -EINVAL);
        assert_return(m->sealed, -EPERM);
 
        /* If types is NULL, read exactly one element */
        if (!types) {
                BusMessageContainer *c;
                size_t l;
 
                if (message_end_of_signature(m))
                        return -ENXIO;
 
                if (message_end_of_array(m, m->rindex))
                        return 0;
 
                c = message_get_last_container(m);
 
                r = signature_element_length(c->signature + c->index, &l);
                if (r < 0)
                        return r;
 
                types = strndupa_safe(c->signature + c->index, l);
        }
 
        switch (*types) {
 
        case 0: /* Nothing to drop */
                return 0;
 
        case SD_BUS_TYPE_BYTE:
        case SD_BUS_TYPE_BOOLEAN:
        case SD_BUS_TYPE_INT16:
        case SD_BUS_TYPE_UINT16:
        case SD_BUS_TYPE_INT32:
        case SD_BUS_TYPE_UINT32:
        case SD_BUS_TYPE_INT64:
        case SD_BUS_TYPE_UINT64:
        case SD_BUS_TYPE_DOUBLE:
        case SD_BUS_TYPE_STRING:
        case SD_BUS_TYPE_OBJECT_PATH:
        case SD_BUS_TYPE_SIGNATURE:
        case SD_BUS_TYPE_UNIX_FD:
 
                r = sd_bus_message_read_basic(m, *types, NULL);
                if (r <= 0)
                        return r;
 
                r = sd_bus_message_skip(m, types + 1);
                if (r < 0)
                        return r;
 
                return 1;
 
        case SD_BUS_TYPE_ARRAY: {
                size_t k;
 
                r = signature_element_length(types + 1, &k);
                if (r < 0)
                        return r;
 
                {
                        char s[k+1];
                        memcpy(s, types+1, k);
                        s[k] = 0;
 
                        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, s);
                        if (r <= 0)
                                return r;
 
                        for (;;) {
                                r = sd_bus_message_skip(m, s);
                                if (r < 0)
                                        return r;
                                if (r == 0)
                                        break;
                        }
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return r;
                }
 
                r = sd_bus_message_skip(m, types + 1 + k);
                if (r < 0)
                        return r;
 
                return 1;
        }
 
        case SD_BUS_TYPE_VARIANT: {
                const char *contents;
                char x;
 
                r = sd_bus_message_peek_type(m, &x, &contents);
                if (r <= 0)
                        return r;
 
                if (x != SD_BUS_TYPE_VARIANT)
                        return -ENXIO;
 
                r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, contents);
                if (r <= 0)
                        return r;
 
                r = sd_bus_message_skip(m, contents);
                if (r < 0)
                        return r;
                assert(r != 0);
 
                r = sd_bus_message_exit_container(m);
                if (r < 0)
                        return r;
 
                r = sd_bus_message_skip(m, types + 1);
                if (r < 0)
                        return r;
 
                return 1;
        }
 
        case SD_BUS_TYPE_STRUCT_BEGIN:
        case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
                size_t k;
 
                r = signature_element_length(types, &k);
                if (r < 0)
                        return r;
                if (k < 2)
                        return -ERANGE;
 
                {
                        char s[k-1];
                        memcpy(s, types+1, k-2);
                        s[k-2] = 0;
 
                        r = sd_bus_message_enter_container(m, *types == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
                        if (r <= 0)
                                return r;
 
                        r = sd_bus_message_skip(m, s);
                        if (r < 0)
                                return r;
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return r;
                }
 
                r = sd_bus_message_skip(m, types + k);
                if (r < 0)
                        return r;
 
                return 1;
        }
 
        default:
                return -EINVAL;
        }
}
 
_public_ int sd_bus_message_read_array(
                sd_bus_message *m,
                char type,
                const void **ret_ptr,
                size_t *ret_size) {
 
        BusMessageContainer *c;
        void *p;
        size_t sz;
        ssize_t align;
        int r;
 
        assert_return(m, -EINVAL);
        assert_return(m->sealed, -EPERM);
        assert_return(bus_type_is_trivial(type), -EINVAL);
        assert_return(ret_ptr, -EINVAL);
        assert_return(ret_size, -EINVAL);
        assert_return(!BUS_MESSAGE_NEED_BSWAP(m), -EOPNOTSUPP);
 
        r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
        if (r < 0)
                return r;
        if (r == 0) {
                *ret_ptr = NULL;
                *ret_size = 0;
                return 0;
        }
 
        c = message_get_last_container(m);
 
        align = bus_type_get_alignment(type);
        if (align < 0)
                return align;
 
        sz = BUS_MESSAGE_BSWAP32(m, *c->array_size);
 
        if (sz == 0)
                /* Zero length array, let's return some aligned
                 * pointer that is not NULL */
                p = (uint8_t*) align;
        else {
                r = message_peek_body(m, &m->rindex, align, sz, &p);
                if (r < 0)
                        goto fail;
        }
 
        r = sd_bus_message_exit_container(m);
        if (r < 0)
                goto fail;
 
        *ret_ptr = (const void*) p;
        *ret_size = sz;
 
        return 1;
 
fail:
        message_quit_container(m);
        return r;
}
 
static int message_peek_fields(
                sd_bus_message *m,
                size_t *rindex,
                size_t align,
                size_t nbytes,
                void **ret) {
 
        size_t start, end;
 
        assert(m);
        assert(rindex);
        assert(align > 0);
 
        start = ALIGN_TO(*rindex, align);
        if (start > m->fields_size)
                return -EBADMSG;
 
        /* Avoid overflow below */
        if (nbytes > SIZE_MAX - start)
                return -EBADMSG;
 
        end = start + nbytes;
        if (end > m->fields_size)
                return -EBADMSG;
 
        /* Verify that padding is 0 */
        uint8_t *p = BUS_MESSAGE_FIELDS(m);
        for (size_t k = *rindex; k < start; k++)
                if (p[k] != 0)
                        return -EBADMSG;
 
        if (ret)
                *ret = p + start;
 
        *rindex = end;
        return 1;
}
 
static int message_peek_field_uint32(
                sd_bus_message *m,
                size_t *ri,
                size_t item_size,
                uint32_t *ret) {
 
        int r;
        void *q;
 
        assert(m);
        assert(ri);
 
        r = message_peek_fields(m, ri, 4, 4, &q);
        if (r < 0)
                return r;
 
        if (ret)
                *ret = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
 
        return 0;
}
 
static int message_peek_field_string(
                sd_bus_message *m,
                bool (*validate)(const char *p),
                size_t *ri,
                size_t item_size,
                const char **ret) {
 
        uint32_t l;
        int r;
        void *q;
 
        assert(m);
        assert(ri);
 
        r = message_peek_field_uint32(m, ri, 4, &l);
        if (r < 0)
                return r;
 
        if (l == UINT32_MAX)
                /* avoid overflow right below */
                return -EBADMSG;
 
        r = message_peek_fields(m, ri, 1, l+1, &q);
        if (r < 0)
                return r;
 
        if (validate) {
                if (!validate_nul(q, l))
                        return -EBADMSG;
 
                if (!validate(q))
                        return -EBADMSG;
        } else {
                if (!validate_string(q, l))
                        return -EBADMSG;
        }
 
        if (ret)
                *ret = q;
 
        return 0;
}
 
static int message_peek_field_signature(
                sd_bus_message *m,
                size_t *ri,
                size_t item_size,
                const char **ret) {
 
        size_t l;
        int r;
        void *q;
 
        assert(m);
        assert(ri);
 
        r = message_peek_fields(m, ri, 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_fields(m, ri, 1, l+1, &q);
        if (r < 0)
                return r;
 
        if (!validate_signature(q, l))
                return -EBADMSG;
 
        if (ret)
                *ret = q;
 
        return 0;
}
 
static int message_skip_fields(
                sd_bus_message *m,
                size_t *ri,
                uint32_t array_size,
                const char **signature,
                unsigned depth) {
 
        size_t original_index;
        int r;
 
        assert(m);
        assert(ri);
        assert(signature);
 
        if (depth >= BUS_CONTAINER_DEPTH)
                return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "Maximum container nesting depth reached, refusing.");
 
        original_index = *ri;
 
        for (;;) {
                char t;
                size_t l;
 
                if (array_size != UINT32_MAX &&
                    array_size <= *ri - original_index)
                        return 0;
 
                t = **signature;
                if (!t)
                        return 0;
 
                if (t == SD_BUS_TYPE_STRING) {
 
                        r = message_peek_field_string(m, NULL, ri, 0, NULL);
                        if (r < 0)
                                return r;
 
                        (*signature)++;
 
                } else if (t == SD_BUS_TYPE_OBJECT_PATH) {
 
                        r = message_peek_field_string(m, object_path_is_valid, ri, 0, NULL);
                        if (r < 0)
                                return r;
 
                        (*signature)++;
 
                } else if (t == SD_BUS_TYPE_SIGNATURE) {
 
                        r = message_peek_field_signature(m, ri, 0, NULL);
                        if (r < 0)
                                return r;
 
                        (*signature)++;
 
                } else if (bus_type_is_basic(t)) {
                        ssize_t align, k;
 
                        align = bus_type_get_alignment(t);
                        k = bus_type_get_size(t);
                        assert(align > 0 && k > 0);
 
                        r = message_peek_fields(m, ri, align, k, NULL);
                        if (r < 0)
                                return r;
 
                        (*signature)++;
 
                } else if (t == SD_BUS_TYPE_ARRAY) {
 
                        r = signature_element_length(*signature + 1, &l);
                        if (r < 0)
                                return r;
 
                        assert(l >= 1);
                        {
                                char sig[l + 1], *s = sig;
                                uint32_t nas;
                                int alignment;
 
                                strncpy(sig, *signature + 1, l);
                                sig[l] = '\0';
 
                                alignment = bus_type_get_alignment(sig[0]);
                                if (alignment < 0)
                                        return alignment;
 
                                r = message_peek_field_uint32(m, ri, 0, &nas);
                                if (r < 0)
                                        return r;
                                if (nas > BUS_ARRAY_MAX_SIZE)
                                        return -EBADMSG;
 
                                r = message_peek_fields(m, ri, alignment, 0, NULL);
                                if (r < 0)
                                        return r;
 
                                r = message_skip_fields(m, ri, nas, (const char**) &s, depth + 1);