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 1001–2000 of 4,752

 
        if (m->creds.mask == 0)
                return NULL;
 
        return &m->creds;
}
 
_public_ int sd_bus_message_is_signal(
                sd_bus_message *m,
                const char *interface,
                const char *member) {
 
        assert_return(m, -EINVAL);
 
        if (m->header->type != SD_BUS_MESSAGE_SIGNAL)
                return 0;
 
        if (interface && !streq_ptr(m->interface, interface))
                return 0;
 
        if (member && !streq_ptr(m->member, member))
                return 0;
 
        return 1;
}
 
_public_ int sd_bus_message_is_method_call(
                sd_bus_message *m,
                const char *interface,
                const char *member) {
 
        assert_return(m, -EINVAL);
 
        if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
                return 0;
 
        if (interface && !streq_ptr(m->interface, interface))
                return 0;
 
        if (member && !streq_ptr(m->member, member))
                return 0;
 
        return 1;
}
 
_public_ int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) {
        assert_return(m, -EINVAL);
 
        if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
                return 0;
 
        if (name && !streq_ptr(m->error.name, name))
                return 0;
 
        return 1;
}
 
_public_ int sd_bus_message_set_expect_reply(sd_bus_message *m, int b) {
        assert_return(m, -EINVAL);
        assert_return(!m->sealed, -EPERM);
        assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EPERM);
 
        SET_FLAG(m->header->flags, BUS_MESSAGE_NO_REPLY_EXPECTED, !b);
 
        return 0;
}
 
_public_ int sd_bus_message_set_auto_start(sd_bus_message *m, int b) {
        assert_return(m, -EINVAL);
        assert_return(!m->sealed, -EPERM);
 
        SET_FLAG(m->header->flags, BUS_MESSAGE_NO_AUTO_START, !b);
 
        return 0;
}
 
_public_ int sd_bus_message_set_allow_interactive_authorization(sd_bus_message *m, int b) {
        assert_return(m, -EINVAL);
        assert_return(!m->sealed, -EPERM);
 
        SET_FLAG(m->header->flags, BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION, b);
 
        return 0;
}
 
static BusMessageBodyPart* message_append_part(sd_bus_message *m) {
        BusMessageBodyPart *part;
 
        assert(m);
 
        if (m->poisoned)
                return NULL;
 
        if (m->n_body_parts <= 0) {
                part = &m->body;
                zero(*part);
        } else {
                assert(m->body_end);
 
                part = new0(BusMessageBodyPart, 1);
                if (!part) {
                        m->poisoned = true;
                        return NULL;
                }
 
                m->body_end->next = part;
        }
 
        part->memfd = -EBADF;
        m->body_end = part;
        m->n_body_parts++;
 
        return part;
}
 
static void part_zero(BusMessageBodyPart *part, size_t sz) {
        assert(part);
        assert(sz > 0);
        assert(sz < 8);
 
        /* All other fields can be left in their defaults */
        assert(!part->data);
        assert(part->memfd < 0);
 
        part->size = sz;
        part->is_zero = true;
        part->sealed = true;
}
 
static int part_make_space(
                struct sd_bus_message *m,
                BusMessageBodyPart *part,
                size_t sz,
                void **q) {
 
        void *n;
 
        assert(m);
        assert(part);
        assert(!part->sealed);
 
        if (m->poisoned)
                return -ENOMEM;
 
        if (part->allocated == 0 || sz > part->allocated) {
                size_t new_allocated;
 
                new_allocated = sz > 0 ? 2 * sz : 64;
                n = realloc(part->data, new_allocated);
                if (!n) {
                        m->poisoned = true;
                        return -ENOMEM;
                }
 
                part->data = n;
                part->allocated = new_allocated;
                part->free_this = true;
        }
 
        if (q)
                *q = part->data ? (uint8_t*) part->data + part->size : NULL;
 
        part->size = sz;
        return 0;
}
 
static void message_extend_containers(sd_bus_message *m, size_t expand) {
        assert(m);
 
        if (expand <= 0)
                return;
 
        if (m->n_containers <= 0)
                return;
 
        /* Update counters */
        for (BusMessageContainer *c = m->containers; c < m->containers + m->n_containers; c++)
                if (c->array_size)
                        *c->array_size += expand;
}
 
static void* message_extend_body(
                sd_bus_message *m,
                size_t align,
                size_t sz) {
 
        size_t start_body, end_body, padding, added;
        void *p;
        int r;
 
        assert(m);
        assert(align > 0);
        assert(!m->sealed);
 
        if (m->poisoned)
                return NULL;
 
        start_body = ALIGN_TO(m->body_size, align);
        end_body = start_body + sz;
 
        padding = start_body - m->body_size;
        added = padding + sz;
 
        /* Check for 32-bit overflows */
        if (end_body < start_body || end_body > UINT32_MAX) {
                m->poisoned = true;
                return NULL;
        }
 
        if (added > 0) {
                BusMessageBodyPart *part = NULL;
                bool add_new_part;
 
                add_new_part =
                        m->n_body_parts <= 0 ||
                        m->body_end->sealed ||
                        (padding != ALIGN_TO(m->body_end->size, align) - m->body_end->size);
                        /* If this must be an inlined extension, let's create a new part if
                         * the previous part is large enough to be inlined. */
 
                if (add_new_part) {
                        if (padding > 0) {
                                part = message_append_part(m);
                                if (!part)
                                        return NULL;
 
                                part_zero(part, padding);
                        }
 
                        part = message_append_part(m);
                        if (!part)
                                return NULL;
 
                        r = part_make_space(m, part, sz, &p);
                        if (r < 0)
                                return NULL;
                } else {
                        void *op;
                        size_t os, start_part, end_part;
 
                        part = m->body_end;
                        op = part->data;
                        os = part->size;
 
                        start_part = ALIGN_TO(part->size, align);
                        end_part = start_part + sz;
 
                        r = part_make_space(m, part, end_part, &p);
                        if (r < 0)
                                return NULL;
 
                        if (padding > 0) {
                                memzero(p, padding);
                                p = (uint8_t*) p + padding;
                        }
 
                        /* Readjust pointers */
                        if (m->n_containers > 0)
                                for (BusMessageContainer *c = m->containers; c < m->containers + m->n_containers; c++)
                                        c->array_size = adjust_pointer(c->array_size, op, os, part->data);
 
                        m->error.message = (const char*) adjust_pointer(m->error.message, op, os, part->data);
                }
        } else
                /* Return something that is not NULL and is aligned */
                p = (uint8_t*) align;
 
        m->body_size = end_body;
        message_extend_containers(m, added);
 
        return p;
}
 
static int message_push_fd(sd_bus_message *m, int fd) {
        int copy;
 
        assert(m);
 
        if (fd < 0)
                return -EINVAL;
 
        if (!m->allow_fds)
                return -EOPNOTSUPP;
 
        copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
        if (copy < 0)
                return -errno;
 
        if (!GREEDY_REALLOC(m->fds, m->n_fds + 1)) {
                m->poisoned = true;
                safe_close(copy);
                return -ENOMEM;
        }
 
        m->fds[m->n_fds] = copy; /* m->n_fds will be incremented by the caller later */
        m->free_fds = true;
 
        return copy;
}
 
int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored) {
        _cleanup_close_ int fd = -EBADF;
        BusMessageContainer *c;
        ssize_t align, sz;
        uint32_t u32;
        void *a;
 
        assert_return(m, -EINVAL);
        assert_return(!m->sealed, -EPERM);
        assert_return(bus_type_is_basic(type), -EINVAL);
        assert_return(!m->poisoned, -ESTALE);
 
        c = message_get_last_container(m);
 
        if (c->signature && c->signature[c->index]) {
                /* Container signature is already set */
 
                if (c->signature[c->index] != type)
                        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(type));
                if (!e) {
                        m->poisoned = true;
                        return -ENOMEM;
                }
        }
 
        switch (type) {
 
        case SD_BUS_TYPE_STRING:
                /* To make things easy we'll serialize a NULL string
                 * into the empty string */
                p = strempty(p);
 
                if (!utf8_is_valid(p))
                        return -EINVAL;
 
                align = 4;
                sz = 4 + strlen(p) + 1;
                break;
 
        case SD_BUS_TYPE_OBJECT_PATH:
 
                if (!p)
                        return -EINVAL;
 
                if (!object_path_is_valid(p))
                        return -EINVAL;
 
                align = 4;
                sz = 4 + strlen(p) + 1;
                break;
 
        case SD_BUS_TYPE_SIGNATURE:
 
                p = strempty(p);
 
                if (!signature_is_valid(p, /* allow_dict_entry= */ true))
                        return -EINVAL;
 
                align = 1;
                sz = 1 + strlen(p) + 1;
                break;
 
        case SD_BUS_TYPE_BOOLEAN:
 
                u32 = p && *(int*) p;
                p = &u32;
 
                align = sz = 4;
                break;
 
        case SD_BUS_TYPE_UNIX_FD:
 
                if (!p)
                        return -EINVAL;
 
                fd = message_push_fd(m, *(int*) p);
                if (fd < 0)
                        return fd;
 
                u32 = m->n_fds;
                p = &u32;
 
                align = sz = 4;
                break;
 
        default:
                align = bus_type_get_alignment(type);
                sz = bus_type_get_size(type);
        }
 
        assert(align > 0);
        assert(sz > 0);
 
        a = message_extend_body(m, align, sz);
        if (!a)
                return -ENOMEM;
 
        if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH)) {
                *(uint32_t*) a = sz - 5;
                memcpy((uint8_t*) a + 4, p, sz - 4);
 
                if (stored)
                        *stored = (const uint8_t*) a + 4;
 
        } else if (type == SD_BUS_TYPE_SIGNATURE) {
                *(uint8_t*) a = sz - 2;
                memcpy((uint8_t*) a + 1, p, sz - 1);
 
                if (stored)
                        *stored = (const uint8_t*) a + 1;
        } else {
                memcpy(a, p, sz);
 
                if (stored)
                        *stored = a;
        }
 
        if (type == SD_BUS_TYPE_UNIX_FD)
                m->n_fds++;
 
        if (c->enclosing != SD_BUS_TYPE_ARRAY)
                c->index++;
 
        fd = -EBADF;
        return 0;
}
 
_public_ int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p) {
        return message_append_basic(m, type, p, NULL);
}
 
_public_ int sd_bus_message_append_string_space(
                sd_bus_message *m,
                size_t size,
                char **ret) {
 
        BusMessageContainer *c;
        void *a;
 
        assert_return(m, -EINVAL);
        assert_return(!m->sealed, -EPERM);
        assert_return(!m->poisoned, -ESTALE);
        assert_return(ret, -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 + size + 1);
        if (!a)
                return -ENOMEM;
 
        *(uint32_t*) a = size;
        *ret = (char*) a + 4;
 
        (*ret)[size] = 0;
 
        if (c->enclosing != SD_BUS_TYPE_ARRAY)
                c->index++;
 
        return 0;
}
 
_public_ int sd_bus_message_append_string_iovec(
                sd_bus_message *m,
                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(iov || n == 0, -EINVAL);
        assert_return(!m->poisoned, -ESTALE);
 
        size_t size = iovec_total_size(iov, n);
        if (size == SIZE_MAX)
                return -ENOBUFS;
 
        char *p;
        r = sd_bus_message_append_string_space(m, 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
                        memset(p, ' ', iov[i].iov_len);
 
                p += iov[i].iov_len;
        }
 
        return 0;
}
 
static int bus_message_open_array(
                sd_bus_message *m,
                BusMessageContainer *c,
                const char *contents,
                uint32_t **ret_array_size) {
 
        unsigned nindex;
        int alignment;
        void *a, *op;
        size_t os;
        BusMessageBodyPart *o;
 
        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]) {
 
                /* Verify the existing signature */
 
                if (c->signature[c->index] != SD_BUS_TYPE_ARRAY)
                        return -ENXIO;
 
                if (!startswith(c->signature + c->index + 1, contents))
                        return -ENXIO;
 
                nindex = c->index + 1 + strlen(contents);
        } else {
                char *e;
 
                if (c->enclosing != 0)
                        return -ENXIO;
 
                /* Extend the existing signature */
 
                e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_ARRAY), contents);
                if (!e) {
                        m->poisoned = true;
                        return -ENOMEM;
                }
 
                nindex = e - c->signature;
        }
 
        alignment = bus_type_get_alignment(contents[0]);
        if (alignment < 0)
                return alignment;
 
        a = message_extend_body(m, 4, 4);
        if (!a)
                return -ENOMEM;
 
        o = m->body_end;
        op = m->body_end->data;
        os = m->body_end->size;
 
        /* Add alignment between size and first element */
        if (!message_extend_body(m, alignment, 0))
                return -ENOMEM;
 
        /* location of array size might have changed so let's readjust a */
        if (o == m->body_end)
                a = adjust_pointer(a, op, os, m->body_end->data);
 
        *(uint32_t*) a = 0;
        *ret_array_size = a;
 
        if (c->enclosing != SD_BUS_TYPE_ARRAY)
                c->index = nindex;
 
        return 0;
}
 
static int bus_message_open_variant(
                sd_bus_message *m,
                BusMessageContainer *c,
                const char *contents) {
 
        size_t l;
        void *a;
 
        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]) {
 
                if (c->signature[c->index] != SD_BUS_TYPE_VARIANT)
                        return -ENXIO;
 
        } else {
                char *e;
 
                if (c->enclosing != 0)
                        return -ENXIO;
 
                e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_VARIANT));
                if (!e) {
                        m->poisoned = true;
                        return -ENOMEM;
                }
        }
 
        l = strlen(contents);
        a = message_extend_body(m, 1, 1 + l + 1);
        if (!a)
                return -ENOMEM;
 
        *(uint8_t*) a = l;
        memcpy((uint8_t*) a + 1, contents, l + 1);
 
        if (c->enclosing != SD_BUS_TYPE_ARRAY)
                c->index++;
 
        return 0;
}
 
static int bus_message_open_struct(
                sd_bus_message *m,
                BusMessageContainer *c,
                const char *contents) {
 
        size_t nindex;
 
        assert(m);
        assert(c);
        assert(contents);
 
        if (!signature_is_valid(contents, false))
                return -EINVAL;
 
        if (c->signature && c->signature[c->index]) {
                size_t l;
 
                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;
 
                nindex = c->index + 1 + l + 1;
        } else {
                char *e;
 
                if (c->enclosing != 0)
                        return -ENXIO;
 
                e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_BEGIN), contents, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_END));
                if (!e) {
                        m->poisoned = true;
                        return -ENOMEM;
                }
 
                nindex = e - c->signature;
        }
 
        /* Align contents to 8 byte boundary */
        if (!message_extend_body(m, 8, 0))
                return -ENOMEM;
 
        if (c->enclosing != SD_BUS_TYPE_ARRAY)
                c->index = nindex;
 
        return 0;
}
 
static int bus_message_open_dict_entry(
                sd_bus_message *m,
                BusMessageContainer *c,
                const char *contents) {
 
        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]) {
                size_t l;
 
                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;
        } else
                return -ENXIO;
 
        /* Align contents to 8 byte boundary */
        if (!message_extend_body(m, 8, 0))
                return -ENOMEM;
 
        return 0;
}
 
_public_ int sd_bus_message_open_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(contents, -EINVAL);
        assert_return(!m->poisoned, -ESTALE);
 
        /* Make sure we have space for one more container */
        if (!GREEDY_REALLOC(m->containers, m->n_containers + 1)) {
                m->poisoned = true;
                return -ENOMEM;
        }
 
        c = message_get_last_container(m);
 
        signature = strdup(contents);
        if (!signature) {
                m->poisoned = true;
                return -ENOMEM;
        }
 
        /* Save old index in the parent container, in case we have to
         * abort this container */
        c->saved_index = c->index;
        before = m->body_size;
 
        if (type == SD_BUS_TYPE_ARRAY)
                r = bus_message_open_array(m, c, contents, &array_size);
        else if (type == SD_BUS_TYPE_VARIANT)
                r = bus_message_open_variant(m, c, contents);
        else if (type == SD_BUS_TYPE_STRUCT)
                r = bus_message_open_struct(m, c, contents);
        else if (type == SD_BUS_TYPE_DICT_ENTRY)
                r = bus_message_open_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),
                .array_size = array_size,
                .before = before,
        };
 
        return 0;
}
 
_public_ int sd_bus_message_close_container(sd_bus_message *m) {
        BusMessageContainer *c;
 
        assert_return(m, -EINVAL);
        assert_return(!m->sealed, -EPERM);
        assert_return(m->n_containers > 0, -EINVAL);
        assert_return(!m->poisoned, -ESTALE);
 
        c = message_get_last_container(m);
 
        if (c->enclosing != SD_BUS_TYPE_ARRAY)
                if (c->signature && c->signature[c->index] != 0)
                        return -EINVAL;
 
        m->n_containers--;
 
        free(c->signature);
 
        return 0;
}
 
typedef struct BusTypeStack {
        const char *types;
        unsigned n_struct;
        unsigned n_array;
} BusTypeStack;
 
static int type_stack_push(
                BusTypeStack *stack,
                unsigned max,
                unsigned *i,
                const char *types,
                unsigned n_struct,
                unsigned n_array) {
 
        assert(stack);
        assert(max > 0);
        assert(i);
 
        if (*i >= max)
                return -EINVAL;
 
        stack[*i].types = types;
        stack[*i].n_struct = n_struct;
        stack[*i].n_array = n_array;
        (*i)++;
 
        return 0;
}
 
static int type_stack_pop(
                BusTypeStack *stack,
                unsigned max,
                unsigned *i,
                const char **ret_types,
                unsigned *ret_n_struct,
                unsigned *ret_n_array) {
 
        assert(stack);
        assert(max > 0);
        assert(i);
        assert(ret_types);
        assert(ret_n_struct);
        assert(ret_n_array);
 
        if (*i <= 0)
                return 0;
 
        (*i)--;
        *ret_types = stack[*i].types;
        *ret_n_struct = stack[*i].n_struct;
        *ret_n_array = stack[*i].n_array;
 
        return 1;
}
 
_public_ int sd_bus_message_appendv(
                sd_bus_message *m,
                const char *types,
                va_list ap) {
 
        unsigned n_array, n_struct;
        BusTypeStack stack[BUS_CONTAINER_DEPTH];
        unsigned stack_ptr = 0;
        int r;
 
        assert_return(m, -EINVAL);
        assert_return(types, -EINVAL);
        assert_return(!m->sealed, -EPERM);
        assert_return(!m->poisoned, -ESTALE);
 
        n_array = UINT_MAX;
        n_struct = strlen(types);
 
        for (;;) {
                const char *t;
 
                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_close_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: {
                        uint8_t x;
 
                        x = (uint8_t) va_arg(ap, int);
                        r = sd_bus_message_append_basic(m, *t, &x);
                        break;
                }
 
                case SD_BUS_TYPE_BOOLEAN:
                case SD_BUS_TYPE_INT32:
                case SD_BUS_TYPE_UINT32:
                case SD_BUS_TYPE_UNIX_FD: {
                        uint32_t x;
 
                        /* We assume a boolean is the same as int32_t */
                        assert_cc(sizeof(int32_t) == sizeof(int));
 
                        x = va_arg(ap, uint32_t);
                        r = sd_bus_message_append_basic(m, *t, &x);
                        break;
                }
 
                case SD_BUS_TYPE_INT16:
                case SD_BUS_TYPE_UINT16: {
                        uint16_t x;
 
                        x = (uint16_t) va_arg(ap, int);
                        r = sd_bus_message_append_basic(m, *t, &x);
                        break;
                }
 
                case SD_BUS_TYPE_INT64:
                case SD_BUS_TYPE_UINT64: {
                        uint64_t x;
 
                        x = va_arg(ap, uint64_t);
                        r = sd_bus_message_append_basic(m, *t, &x);
                        break;
                }
 
                case SD_BUS_TYPE_DOUBLE: {
                        double x;
 
                        x = va_arg(ap, double);
                        r = sd_bus_message_append_basic(m, *t, &x);
                        break;
                }
 
                case SD_BUS_TYPE_STRING:
                case SD_BUS_TYPE_OBJECT_PATH:
                case SD_BUS_TYPE_SIGNATURE: {
                        const char *x;
 
                        x = va_arg(ap, const char*);
                        r = sd_bus_message_append_basic(m, *t, x);
                        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_open_container(m, SD_BUS_TYPE_ARRAY, s);
                                if (r < 0)
                                        return r;
                        }
 
                        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);