X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Flibsystemd-bus%2Fbus-message.c;h=c7cc32ec15db8cb10f6bb0f7d55ba23b28ac75ee;hp=4c5588cf8a6653f8d0f2167daad5ef747d07e3f2;hb=27f6e5c7823f0b763a92d2938d222b900c5d70e6;hpb=de1c301ed165eb4d04a0c9d4babe97912b5233bb diff --git a/src/libsystemd-bus/bus-message.c b/src/libsystemd-bus/bus-message.c index 4c5588cf8..c7cc32ec1 100644 --- a/src/libsystemd-bus/bus-message.c +++ b/src/libsystemd-bus/bus-message.c @@ -20,22 +20,39 @@ ***/ #include +#include #include "util.h" +#include "utf8.h" +#include "strv.h" -#include "bus-message.h" #include "sd-bus.h" +#include "bus-message.h" #include "bus-internal.h" #include "bus-type.h" #include "bus-signature.h" -int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored); +static int message_parse_fields(sd_bus_message *m); +static int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored); -static void message_free(sd_bus_message *m) { +static void reset_containers(sd_bus_message *m) { unsigned i; assert(m); + for (i = 0; i < m->n_containers; i++) + free(m->containers[i].signature); + + free(m->containers); + m->containers = NULL; + + m->n_containers = 0; + m->root_container.index = 0; +} + +static void message_free(sd_bus_message *m) { + assert(m); + if (m->free_header) free(m->header); @@ -45,13 +62,15 @@ static void message_free(sd_bus_message *m) { if (m->free_body) free(m->body); - for (i = 0; i < m->n_fds; i++) - close_nointr_nofail(m->fds[i]); + if (m->free_fds) { + close_many(m->fds, m->n_fds); + free(m->fds); + } - for (i = 0; i < m->n_containers; i++) - free(m->sub_containers[i].signature); + reset_containers(m); + free(m->root_container.signature); - free(m->sub_containers); + free(m->peeked_signature); free(m); } @@ -109,8 +128,6 @@ static void *message_extend_fields(sd_bus_message *m, size_t align, size_t sz) { m->destination = (const char*) m->fields + (m->destination - (const char*) o); if (m->sender) m->sender = (const char*) m->fields + (m->sender - (const char*) o); - if (m->signature) - m->signature = (const char*) m->fields + (m->signature - (const char*) o); if (m->error.name) m->error.name = (const char*) m->fields + (m->error.name - (const char*) o); } @@ -208,23 +225,113 @@ static int message_append_field_uint32(sd_bus_message *m, uint8_t h, uint32_t x) return 0; } +int bus_message_from_malloc( + void *buffer, + size_t length, + int *fds, + unsigned n_fds, + const struct ucred *ucred, + const char *label, + sd_bus_message **ret) { + + sd_bus_message *m; + struct bus_header *h; + size_t total, fs, bs, label_sz, a; + int r; + + assert(buffer || length <= 0); + assert(fds || n_fds <= 0); + assert(ret); + + if (length < sizeof(struct bus_header)) + return -EBADMSG; + + h = buffer; + if (h->version != 1) + return -EBADMSG; + + if (h->serial == 0) + return -EBADMSG; + + if (h->type == _SD_BUS_MESSAGE_TYPE_INVALID) + return -EBADMSG; + + if (h->endian == SD_BUS_NATIVE_ENDIAN) { + fs = h->fields_size; + bs = h->body_size; + } else if (h->endian == SD_BUS_REVERSE_ENDIAN) { + fs = bswap_32(h->fields_size); + bs = bswap_32(h->body_size); + } else + return -EBADMSG; + + total = sizeof(struct bus_header) + ALIGN_TO(fs, 8) + bs; + if (length != total) + return -EBADMSG; + + if (label) { + label_sz = strlen(label); + a = ALIGN(sizeof(sd_bus_message)) + label_sz + 1; + } else + a = sizeof(sd_bus_message); + + m = malloc0(a); + if (!m) + return -ENOMEM; + + m->n_ref = 1; + m->sealed = true; + m->header = h; + m->fields = (uint8_t*) buffer + sizeof(struct bus_header); + m->body = (uint8_t*) buffer + sizeof(struct bus_header) + ALIGN_TO(fs, 8); + m->fds = fds; + m->n_fds = n_fds; + + if (ucred) { + m->uid = ucred->uid; + m->pid = ucred->pid; + m->gid = ucred->gid; + m->uid_valid = m->gid_valid = true; + } + + if (label) { + m->label = (char*) m + ALIGN(sizeof(sd_bus_message)); + memcpy(m->label, label, label_sz + 1); + } + + m->n_iovec = 1; + m->iovec[0].iov_base = buffer; + m->iovec[0].iov_len = length; + + r = message_parse_fields(m); + if (r < 0) + goto fail; + + /* We take possession of the memory and fds now */ + m->free_header = true; + m->free_fds = true; + + *ret = m; + return 0; + +fail: + message_free(m); + return r; +} + static sd_bus_message *message_new(sd_bus *bus, uint8_t type) { sd_bus_message *m; - m = malloc0(ALIGN(sizeof(struct sd_bus_message)) + sizeof(struct bus_header)); + m = malloc0(ALIGN(sizeof(sd_bus_message)) + sizeof(struct bus_header)); if (!m) return NULL; m->n_ref = 1; m->header = (struct bus_header*) ((uint8_t*) m + ALIGN(sizeof(struct sd_bus_message))); - -#if __BYTE_ORDER == __BIG_ENDIAN - m->header->endian = SD_BUS_BIG_ENDIAN; -#else - m->header->endian = SD_BUS_LITTLE_ENDIAN; -#endif + m->header->endian = SD_BUS_NATIVE_ENDIAN; m->header->type = type; m->header->version = bus ? bus->message_version : 1; + m->allow_fds = !bus || bus->can_fds || (bus->state != BUS_HELLO && bus->state != BUS_RUNNING); return m; } @@ -245,11 +352,17 @@ int sd_bus_message_new_signal( return -EINVAL; if (!member) return -EINVAL; + if (!m) + return -EINVAL; + if (bus && bus->state == BUS_UNSET) + return -ENOTCONN; t = message_new(bus, SD_BUS_MESSAGE_TYPE_SIGNAL); if (!t) return -ENOMEM; + t->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED; + r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path); if (r < 0) goto fail; @@ -283,6 +396,10 @@ int sd_bus_message_new_method_call( return -EINVAL; if (!member) return -EINVAL; + if (!m) + return -EINVAL; + if (bus && bus->state == BUS_UNSET) + return -ENOTCONN; t = message_new(bus, SD_BUS_MESSAGE_TYPE_METHOD_CALL); if (!t) @@ -315,9 +432,10 @@ fail: return r; } -int sd_bus_message_new_method_return( +static int message_new_reply( sd_bus *bus, sd_bus_message *call, + uint8_t type, sd_bus_message **m) { sd_bus_message *t; @@ -325,14 +443,22 @@ int sd_bus_message_new_method_return( if (!call) return -EINVAL; + if (!call->sealed) + return -EPERM; if (call->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL) return -EINVAL; + if (!m) + return -EINVAL; + if (bus && bus->state == BUS_UNSET) + return -ENOTCONN; - t = message_new(bus, SD_BUS_MESSAGE_TYPE_METHOD_RETURN); + t = message_new(bus, type); if (!t) return -ENOMEM; + t->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED; t->reply_serial = BUS_MESSAGE_SERIAL(call); + r = message_append_field_uint32(t, SD_BUS_MESSAGE_HEADER_REPLY_SERIAL, t->reply_serial); if (r < 0) goto fail; @@ -343,6 +469,8 @@ int sd_bus_message_new_method_return( goto fail; } + t->dont_send = !!(call->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED); + *m = t; return 0; @@ -351,6 +479,14 @@ fail: return r; } +int sd_bus_message_new_method_return( + sd_bus *bus, + sd_bus_message *call, + sd_bus_message **m) { + + return message_new_reply(bus, call, SD_BUS_MESSAGE_TYPE_METHOD_RETURN, m); +} + int sd_bus_message_new_method_error( sd_bus *bus, sd_bus_message *call, @@ -360,29 +496,14 @@ int sd_bus_message_new_method_error( sd_bus_message *t; int r; - if (!call) - return -EINVAL; - if (call->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL) - return -EINVAL; - if (!e) + if (!sd_bus_error_is_set(e)) return -EINVAL; - if (!e->name) + if (!m) return -EINVAL; - t = message_new(bus, SD_BUS_MESSAGE_TYPE_METHOD_ERROR); - if (!t) - return -ENOMEM; - - t->reply_serial = BUS_MESSAGE_SERIAL(call); - r = message_append_field_uint32(t, SD_BUS_MESSAGE_HEADER_REPLY_SERIAL, t->reply_serial); + r = message_new_reply(bus, call, SD_BUS_MESSAGE_TYPE_METHOD_ERROR, &t); if (r < 0) - goto fail; - - if (call->sender) { - r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, call->sender, &t->sender); - if (r < 0) - goto fail; - } + return r; r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, e->name, &t->error.name); if (r < 0) @@ -550,6 +671,13 @@ int sd_bus_message_get_tid(sd_bus_message *m, pid_t *tid) { return 0; } +const char *sd_bus_message_get_label(sd_bus_message *m) { + if (!m) + return NULL; + + return m->label; +} + int sd_bus_message_is_signal(sd_bus_message *m, const char *interface, const char *member) { if (!m) return -EINVAL; @@ -617,8 +745,8 @@ static struct bus_container *message_get_container(sd_bus_message *m) { if (m->n_containers == 0) return &m->root_container; - assert(m->sub_containers); - return m->sub_containers + m->n_containers - 1; + assert(m->containers); + return m->containers + m->n_containers - 1; } static void *message_extend_body(sd_bus_message *m, size_t align, size_t sz) { @@ -627,6 +755,7 @@ static void *message_extend_body(sd_bus_message *m, size_t align, size_t sz) { struct bus_container *c; assert(m); + assert(align > 0); o = m->body; added = m->header->body_size; @@ -637,7 +766,7 @@ static void *message_extend_body(sd_bus_message *m, size_t align, size_t sz) { added = m->header->body_size - added; - for (c = m->sub_containers; c < m->sub_containers + m->n_containers; c++) + for (c = m->containers; c < m->containers + m->n_containers; c++) if (c->array_size) { c->array_size = (uint32_t*) ((uint8_t*) m->body + ((uint8_t*) c->array_size - (uint8_t*) o)); *c->array_size += added; @@ -655,13 +784,18 @@ static void *message_extend_body(sd_bus_message *m, size_t align, size_t sz) { int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored) { struct bus_container *c; - size_t sz, align, nindex; + ssize_t align, sz; uint32_t k; void *a; char *e = NULL; + int fd = -1; + uint32_t fdi = 0; + int r; if (!m) return -EINVAL; + if (!p) + return -EINVAL; if (m->sealed) return -EPERM; if (!bus_type_is_basic(type)) @@ -673,28 +807,28 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void /* Container signature is already set */ if (c->signature[c->index] != type) - return -EINVAL; + return -ENXIO; } else { /* Maybe we can append to the signature? But only if this is the top-level container*/ if (c->enclosing != 0) - return -EINVAL; + return -ENXIO; e = strextend(&c->signature, CHAR_TO_STR(type), NULL); if (!e) return -ENOMEM; } - nindex = c->index + 1; - switch (type) { case SD_BUS_TYPE_STRING: case SD_BUS_TYPE_OBJECT_PATH: + align = 4; sz = 4 + strlen(p) + 1; break; case SD_BUS_TYPE_SIGNATURE: + align = 1; sz = 1 + strlen(p) + 1; break; @@ -708,6 +842,41 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void p = &k; break; + case SD_BUS_TYPE_UNIX_FD: { + int z, *f; + + if (!m->allow_fds) { + r = -ENOTSUP; + goto fail; + } + + align = sz = 4; + + z = *(int*) p; + if (z < 0) { + r = -EINVAL; + goto fail; + } + + fd = fcntl(z, F_DUPFD_CLOEXEC, 3); + if (fd < 0) { + r = -errno; + goto fail; + } + + f = realloc(m->fds, sizeof(int) * (m->n_fds + 1)); + if (!f) { + r = -ENOMEM; + goto fail; + } + + fdi = m->n_fds; + f[fdi] = fd; + m->fds = f; + m->free_fds = true; + break; + } + default: align = bus_type_get_alignment(type); sz = bus_type_get_size(type); @@ -719,11 +888,8 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void a = message_extend_body(m, align, sz); if (!a) { - /* Truncate extended signature again */ - if (e) - c->signature[c->index] = 0; - - return -ENOMEM; + r = -ENOMEM; + goto fail; } if (type == SD_BUS_TYPE_STRING || type == SD_BUS_TYPE_OBJECT_PATH) { @@ -739,6 +905,13 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void if (stored) *stored = (const uint8_t*) a + 1; + } else if (type == SD_BUS_TYPE_UNIX_FD) { + *(uint32_t*) a = fdi; + + if (stored) + *stored = a; + + m->n_fds ++; } else { memcpy(a, p, sz); @@ -748,9 +921,19 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void } if (c->enclosing != SD_BUS_TYPE_ARRAY) - c->index = nindex; + c->index++; return 0; + +fail: + /* Truncate extended signature again */ + if (e) + c->signature[c->index] = 0; + + if (fd >= 0) + close_nointr_nofail(fd); + + return r; } int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p) { @@ -763,8 +946,8 @@ static int bus_message_open_array( const char *contents, uint32_t **array_size) { + unsigned nindex; char *e = NULL; - size_t nindex; void *a, *b; int alignment; size_t saved; @@ -786,15 +969,15 @@ static int bus_message_open_array( /* Verify the existing signature */ if (c->signature[c->index] != SD_BUS_TYPE_ARRAY) - return -EINVAL; + return -ENXIO; if (!startswith(c->signature + c->index + 1, contents)) - return -EINVAL; + return -ENXIO; nindex = c->index + 1 + strlen(contents); } else { if (c->enclosing != 0) - return -EINVAL; + return -ENXIO; /* Extend the existing signature */ @@ -842,7 +1025,7 @@ static int bus_message_open_variant( const char *contents) { char *e = NULL; - size_t l, nindex; + size_t l; void *a; assert(m); @@ -858,19 +1041,17 @@ static int bus_message_open_variant( if (c->signature && c->signature[c->index]) { if (c->signature[c->index] != SD_BUS_TYPE_VARIANT) - return -EINVAL; + return -ENXIO; } else { if (c->enclosing != 0) - return -EINVAL; + return -ENXIO; e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_VARIANT), NULL); if (!e) return -ENOMEM; } - nindex = c->index + 1; - l = strlen(contents); a = message_extend_body(m, 1, 1 + l + 1); if (!a) { @@ -885,7 +1066,7 @@ static int bus_message_open_variant( memcpy((uint8_t*) a + 1, contents, l + 1); if (c->enclosing != SD_BUS_TYPE_ARRAY) - c->index = nindex; + c->index++; return 0; } @@ -913,12 +1094,12 @@ static int bus_message_open_struct( 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 -EINVAL; + return -ENXIO; nindex = c->index + 1 + l + 1; } else { if (c->enclosing != 0) - return -EINVAL; + return -ENXIO; e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_BEGIN), contents, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_END), NULL); if (!e) @@ -956,7 +1137,7 @@ static int bus_message_open_dict_entry( return -EINVAL; if (c->enclosing != SD_BUS_TYPE_ARRAY) - return -EINVAL; + return -ENXIO; if (c->signature && c->signature[c->index]) { size_t l; @@ -966,11 +1147,11 @@ static int bus_message_open_dict_entry( 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 -EINVAL; + return -ENXIO; nindex = c->index + 1 + l + 1; } else - return -EINVAL; + return -ENXIO; /* Align contents to 8 byte boundary */ if (!message_extend_body(m, 8, 0)) @@ -987,9 +1168,9 @@ int sd_bus_message_open_container( char type, const char *contents) { - struct bus_container *c, *sub; - char *signature; + struct bus_container *c, *w; uint32_t *array_size = NULL; + char *signature; int r; if (!m) @@ -1000,11 +1181,10 @@ int sd_bus_message_open_container( return -EINVAL; /* Make sure we have space for one more container */ - sub = realloc(m->sub_containers, sizeof(struct bus_container) * (m->n_containers + 1)); - if (!sub) + w = realloc(m->containers, sizeof(struct bus_container) * (m->n_containers + 1)); + if (!w) return -ENOMEM; - - m->sub_containers = sub; + m->containers = w; c = message_get_container(m); @@ -1029,12 +1209,12 @@ int sd_bus_message_open_container( } /* OK, let's fill it in */ - sub += m->n_containers++; - - sub->enclosing = type; - sub->signature = signature; - sub->index = 0; - sub->array_size = array_size; + w += m->n_containers++; + w->enclosing = type; + w->signature = signature; + w->index = 0; + w->array_size = array_size; + w->begin = 0; return 0; } @@ -1050,12 +1230,8 @@ int sd_bus_message_close_container(sd_bus_message *m) { return -EINVAL; c = message_get_container(m); - - if (!c->signature) - return -EINVAL; - if (c->enclosing != SD_BUS_TYPE_ARRAY) - if (c->signature[c->index] != 0) + if (c->signature && c->signature[c->index] != 0) return -EINVAL; free(c->signature); @@ -1088,9 +1264,13 @@ static int message_append_ap( case SD_BUS_TYPE_BOOLEAN: case SD_BUS_TYPE_INT32: - case SD_BUS_TYPE_UINT32: { + 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; @@ -1125,16 +1305,7 @@ static int message_append_ap( break; } - case SD_BUS_TYPE_UNIX_FD: { - int x; - - x = va_arg(ap, int); - r = sd_bus_message_append_basic(m, *t, &x); - break; - } - case SD_BUS_TYPE_ARRAY: { - unsigned i, n; size_t k; r = signature_element_length(t + 1, &k); @@ -1142,6 +1313,7 @@ static int message_append_ap( return r; { + unsigned i, n; char s[k + 1]; memcpy(s, t + 1, k); @@ -1153,7 +1325,6 @@ static int message_append_ap( return r; n = va_arg(ap, unsigned); - for (i = 0; i < n; i++) { r = message_append_ap(m, s, ap); if (r < 0) @@ -1244,152 +1415,1544 @@ int sd_bus_message_append(sd_bus_message *m, const char *types, ...) { return r; } -int sd_bus_message_read_type(sd_bus_message *m, char *type, char *element, size_t *length) { - return -ENOTSUP; -} +static int buffer_peek(const void *p, uint32_t sz, size_t *rindex, size_t align, size_t nbytes, void **r) { + size_t k, start, n; -int sd_bus_message_read_basic(sd_bus_message *m, char type, char element, const void **p, size_t *length) { - return -ENOTSUP; -} + assert(rindex); + assert(align > 0); -int sd_bus_message_read(sd_bus_message *m, const char *types, ...) { - return -ENOTSUP; + start = ALIGN_TO((size_t) *rindex, align); + n = start + nbytes; + + if (n > sz) + return -EBADMSG; + + /* Verify that padding is 0 */ + for (k = *rindex; k < start; k++) + if (((const uint8_t*) p)[k] != 0) + return -EBADMSG; + + if (r) + *r = (uint8_t*) p + start; + + *rindex = n; + + return 1; } -int message_parse(sd_bus_message *m) { - assert(m); +static bool message_end_of_array(sd_bus_message *m, size_t index) { + struct bus_container *c; - if (m->header->version != 1) - return -EIO; + assert(m); - if (m->header->endian != SD_BUS_BIG_ENDIAN && - m->header->endian != SD_BUS_LITTLE_ENDIAN) - return -EIO; + c = message_get_container(m); + if (!c->array_size) + return false; - return 0; + return index >= c->begin + BUS_MESSAGE_BSWAP32(m, *c->array_size); } -static void setup_iovec(sd_bus_message *m) { +static int message_peek_body(sd_bus_message *m, size_t *rindex, size_t align, size_t nbytes, void **ret) { assert(m); - assert(m->sealed); + assert(rindex); + assert(align > 0); - m->n_iovec = 0; + if (message_end_of_array(m, *rindex)) + return 0; - m->iovec[m->n_iovec].iov_base = m->header; - m->iovec[m->n_iovec].iov_len = sizeof(*m->header); - m->n_iovec++; + return buffer_peek(m->body, BUS_MESSAGE_BODY_SIZE(m), rindex, align, nbytes, ret); +} - if (m->fields) { - m->iovec[m->n_iovec].iov_base = m->fields; - m->iovec[m->n_iovec].iov_len = m->header->fields_size; - m->n_iovec++; +static bool validate_nul(const char *s, size_t l) { - if (m->header->fields_size % 8 != 0) { - static const uint8_t padding[7] = { 0, 0, 0, 0, 0, 0, 0 }; + /* Check for NUL chars in the string */ + if (memchr(s, 0, l)) + return false; - m->iovec[m->n_iovec].iov_base = (void*) padding; - m->iovec[m->n_iovec].iov_len = 8 - m->header->fields_size % 8; - m->n_iovec++; - } - } + /* Check for NUL termination */ + if (s[l] != 0) + return false; - if (m->body) { - m->iovec[m->n_iovec].iov_base = m->body; - m->iovec[m->n_iovec].iov_len = m->header->body_size; - m->n_iovec++; - } + return true; } -int message_seal(sd_bus_message *m, uint64_t serial) { - int r; +static bool validate_string(const char *s, size_t l) { - assert(m); + if (!validate_nul(s, l)) + return false; - if (m->sealed) - return -EPERM; + /* Check if valid UTF8 */ + if (!utf8_is_valid(s)) + return false; - if (m->n_containers > 0) - return -EBADMSG; + return true; +} - /* 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, SD_BUS_MESSAGE_HEADER_SIGNATURE, m->root_container.signature, &m->signature); - if (r < 0) - return r; - } +static bool validate_signature(const char *s, size_t l) { - if (m->n_fds > 0) { - r = message_append_field_uint32(m, SD_BUS_MESSAGE_HEADER_UNIX_FDS, m->n_fds); - if (r < 0) - return r; - } + if (!validate_nul(s, l)) + return false; - m->header->serial = serial; - m->sealed = true; + /* Check if valid signature */ + if (!signature_is_valid(s, true)) + return false; - setup_iovec(m); + return true; +} - return 0; +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; } -int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) { +int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) { + struct bus_container *c; + int r; + void *q; + if (!m) return -EINVAL; - if (!destination) - return -EINVAL; - if (m->sealed) + if (!m->sealed) return -EPERM; - if (m->destination) - return -EEXIST; + if (!bus_type_is_basic(type)) + return -EINVAL; + if (!p) + return -EINVAL; - return message_append_field_string(m, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &m->destination); -} + c = message_get_container(m); -void message_dump(sd_bus_message *m) { - - log_info("Message %p\n" - "\tn_ref=%u\n" - "\tendian=%c\n" - "\ttype=%i\n" - "\tflags=%u\n" - "\tversion=%u\n" - "\tserial=%u\n" - "\tfields_size=%u\n" - "\tbody_size=%u\n" - "\tpath=%s\n" - "\tinterface=%s\n" - "\tmember=%s\n" - "\tdestination=%s\n" - "\tsender=%s\n" - "\tsignature=%s\n" - "\treply_serial=%u\n" - "\terror.name=%s\n" - "\terror.message=%s\n" - "\tsealed=%s\n", - m, - m->n_ref, - m->header->endian, - m->header->type, - m->header->flags, - m->header->version, - BUS_MESSAGE_SERIAL(m), - BUS_MESSAGE_FIELDS_SIZE(m), - BUS_MESSAGE_BODY_SIZE(m), - strna(m->path), - strna(m->interface), - strna(m->member), - strna(m->destination), - strna(m->sender), - strna(m->signature), - m->reply_serial, - strna(m->error.name), - strna(m->error.message), - yes_no(m->sealed)); -} + if (!c->signature || c->signature[c->index] == 0) + return 0; -int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz) { - size_t total; - unsigned i; + if (c->signature[c->index] != type) + return -ENXIO; + + switch (type) { + + case SD_BUS_TYPE_STRING: + case SD_BUS_TYPE_OBJECT_PATH: { + uint32_t l; + size_t rindex; + + rindex = m->rindex; + r = message_peek_body(m, &rindex, 4, 4, &q); + if (r <= 0) + return r; + + l = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q); + r = message_peek_body(m, &rindex, 1, l+1, &q); + if (r < 0) + return r; + if (r == 0) + return -EBADMSG; + + if (type == SD_BUS_TYPE_OBJECT_PATH) { + if (!validate_object_path(q, l)) + return -EBADMSG; + } else { + if (!validate_string(q, l)) + return -EBADMSG; + } + + m->rindex = rindex; + *(const char**) p = q; + break; + } + + case SD_BUS_TYPE_SIGNATURE: { + uint8_t l; + size_t rindex; + + rindex = m->rindex; + r = message_peek_body(m, &rindex, 1, 1, &q); + if (r <= 0) + return r; + + l = *(uint8_t*) q; + r = message_peek_body(m, &rindex, 1, l+1, &q); + if (r < 0) + return r; + if (r == 0) + return -EBADMSG; + + if (!validate_signature(q, l)) + return -EBADMSG; + + m->rindex = rindex; + *(const char**) p = q; + break; + } + + default: { + ssize_t sz, align; + size_t rindex; + + align = bus_type_get_alignment(type); + sz = bus_type_get_size(type); + assert(align > 0 && sz > 0); + + rindex = m->rindex; + r = message_peek_body(m, &rindex, align, sz, &q); + if (r <= 0) + return r; + + switch (type) { + + case SD_BUS_TYPE_BYTE: + *(uint8_t*) p = *(uint8_t*) q; + break; + + case SD_BUS_TYPE_BOOLEAN: + *(int*) p = !!*(uint32_t*) q; + break; + + case SD_BUS_TYPE_INT16: + case SD_BUS_TYPE_UINT16: + *(uint16_t*) p = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q); + break; + + case SD_BUS_TYPE_INT32: + case SD_BUS_TYPE_UINT32: + *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q); + break; + + case SD_BUS_TYPE_INT64: + case SD_BUS_TYPE_UINT64: + case SD_BUS_TYPE_DOUBLE: + *(uint64_t*) p = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q); + break; + + case SD_BUS_TYPE_UNIX_FD: { + int copy; + uint32_t j; + + j = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q); + if (j >= m->n_fds) + return -EBADMSG; + + copy = fcntl(m->fds[j], F_DUPFD_CLOEXEC, 3); + if (copy < 0) + return -errno; + + *(int*) p = copy; + break; + } + + default: + assert_not_reached("Unknown basic type..."); + } + + m->rindex = rindex; + + break; + } + } + + if (c->enclosing != SD_BUS_TYPE_ARRAY) + c->index++; + + return 1; +} + +static int bus_message_enter_array( + sd_bus_message *m, + struct bus_container *c, + const char *contents, + uint32_t **array_size) { + + size_t rindex; + void *q; + int r, alignment; + + assert(m); + assert(c); + assert(contents); + assert(array_size); + + if (!signature_is_single(contents)) + return -EINVAL; + + alignment = bus_type_get_alignment(contents[0]); + if (alignment < 0) + return alignment; + + if (!c->signature || c->signature[c->index] == 0) + return 0; + + 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; + + r = message_peek_body(m, &rindex, alignment, 0, NULL); + if (r < 0) + return r; + if (r == 0) + return -EBADMSG; + + if (c->enclosing != SD_BUS_TYPE_ARRAY) + c->index += 1 + strlen(contents); + + m->rindex = rindex; + + *array_size = (uint32_t*) q; + + return 1; +} + +static int bus_message_enter_variant( + sd_bus_message *m, + struct bus_container *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)) + return -EINVAL; + + if (*contents == SD_BUS_TYPE_DICT_ENTRY_BEGIN) + return -EINVAL; + + if (!c->signature || c->signature[c->index] == 0) + return 0; + + 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; + r = message_peek_body(m, &rindex, 1, l+1, &q); + if (r < 0) + return r; + if (r == 0) + return -EBADMSG; + + if (!validate_signature(q, l)) + return -EBADMSG; + + if (!streq(q, contents)) + return -ENXIO; + + if (c->enclosing != SD_BUS_TYPE_ARRAY) + c->index++; + + m->rindex = rindex; + + return 1; +} + +static int bus_message_enter_struct( + sd_bus_message *m, + struct bus_container *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 0; + + 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; + + 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, + struct bus_container *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; +} + +int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *contents) { + struct bus_container *c, *w; + uint32_t *array_size = NULL; + char *signature; + int r; + + if (!m) + return -EINVAL; + if (!m->sealed) + return -EPERM; + if (!contents) + return -EINVAL; + + /* + * 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; + + w = realloc(m->containers, sizeof(struct bus_container) * (m->n_containers + 1)); + if (!w) + return -ENOMEM; + m->containers = w; + + c = message_get_container(m); + + if (!c->signature || c->signature[c->index] == 0) + return 0; + + signature = strdup(contents); + if (!signature) + return -ENOMEM; + + 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) { + free(signature); + return r; + } + + /* OK, let's fill it in */ + w += m->n_containers++; + w->enclosing = type; + w->signature = signature; + w->index = 0; + w->array_size = array_size; + w->begin = m->rindex; + + return 1; +} + +int sd_bus_message_exit_container(sd_bus_message *m) { + struct bus_container *c; + + if (!m) + return -EINVAL; + if (!m->sealed) + return -EPERM; + if (m->n_containers <= 0) + return -EINVAL; + + c = message_get_container(m); + 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; + + } else { + if (c->signature && c->signature[c->index] != 0) + return -EINVAL; + } + + free(c->signature); + m->n_containers--; + + return 1; +} + +int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents) { + struct bus_container *c; + int r; + + if (!m) + return -EINVAL; + if (!m->sealed) + return -EPERM; + + c = message_get_container(m); + + if (!c->signature || c->signature[c->index] == 0) + goto eof; + + if (message_end_of_array(m, m->rindex)) + goto eof; + + if (bus_type_is_basic(c->signature[c->index])) { + if (contents) + *contents = NULL; + if (type) + *type = c->signature[c->index]; + return 1; + } + + if (c->signature[c->index] == SD_BUS_TYPE_ARRAY) { + + if (contents) { + size_t l; + char *sig; + + r = signature_element_length(c->signature+c->index+1, &l); + if (r < 0) + return r; + + assert(l >= 1); + + sig = strndup(c->signature + c->index + 1, l); + if (!sig) + return -ENOMEM; + + free(m->peeked_signature); + m->peeked_signature = sig; + + *contents = sig; + } + + if (type) + *type = SD_BUS_TYPE_ARRAY; + + return 1; + } + + if (c->signature[c->index] == SD_BUS_TYPE_STRUCT_BEGIN || + c->signature[c->index] == SD_BUS_TYPE_DICT_ENTRY_BEGIN) { + + if (contents) { + size_t l; + char *sig; + + r = signature_element_length(c->signature+c->index, &l); + if (r < 0) + return r; + + assert(l >= 2); + sig = strndup(c->signature + c->index + 1, l - 2); + if (!sig) + return -ENOMEM; + + free(m->peeked_signature); + m->peeked_signature = sig; + + *contents = sig; + } + + if (type) + *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 (contents) { + size_t rindex, l; + void *q; + + rindex = m->rindex; + r = message_peek_body(m, &rindex, 1, 1, &q); + if (r < 0) + return r; + if (r == 0) + goto eof; + + l = *(uint8_t*) q; + r = message_peek_body(m, &rindex, 1, l+1, &q); + if (r < 0) + return r; + if (r == 0) + return -EBADMSG; + + if (!validate_signature(q, l)) + return -EBADMSG; + + *contents = q; + } + + if (type) + *type = SD_BUS_TYPE_VARIANT; + + return 1; + } + + return -EINVAL; + +eof: + if (type) + *type = c->enclosing; + if (contents) + *contents = NULL; + return 0; +} + +int sd_bus_message_rewind(sd_bus_message *m, int complete) { + struct bus_container *c; + + if (!m) + return -EINVAL; + if (!m->sealed) + return -EPERM; + + if (complete) { + reset_containers(m); + m->rindex = 0; + m->root_container.index = 0; + + c = message_get_container(m); + } else { + c = message_get_container(m); + + c->index = 0; + m->rindex = c->begin; + } + + return !isempty(c->signature); +} + +static int message_read_ap(sd_bus_message *m, const char *types, va_list ap) { + const char *t; + int r; + + assert(m); + assert(types); + + for (t = types; *t; t++) { + 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); + break; + } + + case SD_BUS_TYPE_ARRAY: { + size_t k; + + r = signature_element_length(t + 1, &k); + if (r < 0) + return r; + + { + unsigned i, n; + char s[k + 1]; + + memcpy(s, t + 1, k); + s[k] = 0; + t += k; + + r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, s); + if (r < 0) + return r; + if (r == 0) + return -ENXIO; + + n = va_arg(ap, unsigned); + for (i = 0; i < n; i++) { + r = message_read_ap(m, s, ap); + if (r < 0) + return r; + } + + r = sd_bus_message_exit_container(m); + } + + 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) + return -ENXIO; + + r = message_read_ap(m, s, ap); + if (r < 0) + return r; + if (r == 0) + return -ENXIO; + + r = sd_bus_message_exit_container(m); + 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; + + { + 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) + return -ENXIO; + + t += k - 1; + + r = message_read_ap(m, s, ap); + if (r < 0) + return r; + if (r == 0) + return -ENXIO; + + r = sd_bus_message_exit_container(m); + } + + break; + } + + default: + r = -EINVAL; + } + + if (r < 0) + return r; + if (r == 0) + return -ENXIO; + } + + return 1; +} + +int sd_bus_message_read(sd_bus_message *m, const char *types, ...) { + va_list ap; + int r; + + if (!m) + return -EINVAL; + if (!m->sealed) + return -EPERM; + if (!types) + return -EINVAL; + + va_start(ap, types); + r = message_read_ap(m, types, ap); + va_end(ap); + + return r; +} + +static int message_peek_fields( + sd_bus_message *m, + size_t *rindex, + size_t align, + size_t nbytes, + void **ret) { + + assert(m); + assert(rindex); + assert(align > 0); + + return buffer_peek(m->fields, BUS_MESSAGE_FIELDS_SIZE(m), rindex, align, nbytes, ret); +} + +static int message_peek_field_uint32( + sd_bus_message *m, + size_t *ri, + 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, + const char **ret) { + + uint32_t l; + int r; + void *q; + + assert(m); + assert(ri); + + r = message_peek_field_uint32(m, ri, &l); + if (r < 0) + return r; + + 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, + 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; + 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) { + + size_t original_index; + int r; + + assert(m); + assert(ri); + assert(signature); + + original_index = *ri; + + for (;;) { + char t; + size_t l; + + if (array_size != (uint32_t) -1 && + 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, 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, NULL); + if (r < 0) + return r; + + (*signature)++; + + } else if (t == SD_BUS_TYPE_SIGNATURE) { + + r = message_peek_field_signature(m, ri, 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; + uint32_t nas; + int alignment; + + strncpy(sig, *signature + 1, l-1); + s = sig; + + alignment = bus_type_get_alignment(sig[0]); + if (alignment < 0) + return alignment; + + r = message_peek_field_uint32(m, ri, &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); + if (r < 0) + return r; + } + + (*signature) += 1 + l; + + } else if (t == SD_BUS_TYPE_VARIANT) { + const char *s; + + r = message_peek_field_signature(m, ri, &s); + if (r < 0) + return r; + + r = message_skip_fields(m, ri, (uint32_t) -1, (const char**) &s); + if (r < 0) + return r; + + (*signature)++; + + } else if (t == SD_BUS_TYPE_STRUCT || + t == SD_BUS_TYPE_DICT_ENTRY) { + + r = signature_element_length(*signature, &l); + if (r < 0) + return r; + + assert(l >= 2); + { + char sig[l-1], *s; + strncpy(sig, *signature + 1, l-1); + s = sig; + + r = message_skip_fields(m, ri, (uint32_t) -1, (const char**) &s); + if (r < 0) + return r; + } + + *signature += l; + } else + return -EINVAL; + } +} + +static int message_parse_fields(sd_bus_message *m) { + size_t ri; + int r; + uint32_t unix_fds = 0; + + assert(m); + + for (ri = 0; ri < BUS_MESSAGE_FIELDS_SIZE(m); ) { + const char *signature; + uint8_t *header; + + r = message_peek_fields(m, &ri, 8, 1, (void**) &header); + if (r < 0) + return r; + + r = message_peek_field_signature(m, &ri, &signature); + if (r < 0) + return r; + + switch (*header) { + case _SD_BUS_MESSAGE_HEADER_INVALID: + return -EBADMSG; + + case SD_BUS_MESSAGE_HEADER_PATH: + + if (m->path) + return -EBADMSG; + + if (!streq(signature, "o")) + return -EBADMSG; + + r = message_peek_field_string(m, object_path_is_valid, &ri, &m->path); + break; + + case SD_BUS_MESSAGE_HEADER_INTERFACE: + + if (m->interface) + return -EBADMSG; + + if (!streq(signature, "s")) + return -EBADMSG; + + r = message_peek_field_string(m, interface_name_is_valid, &ri, &m->interface); + break; + + case SD_BUS_MESSAGE_HEADER_MEMBER: + + if (m->member) + return -EBADMSG; + + if (!streq(signature, "s")) + return -EBADMSG; + + r = message_peek_field_string(m, member_name_is_valid, &ri, &m->member); + break; + + case SD_BUS_MESSAGE_HEADER_ERROR_NAME: + + if (m->error.name) + return -EBADMSG; + + if (!streq(signature, "s")) + return -EBADMSG; + + r = message_peek_field_string(m, error_name_is_valid, &ri, &m->error.name); + break; + + case SD_BUS_MESSAGE_HEADER_DESTINATION: + + if (m->destination) + return -EBADMSG; + + if (!streq(signature, "s")) + return -EBADMSG; + + r = message_peek_field_string(m, service_name_is_valid, &ri, &m->destination); + break; + + case SD_BUS_MESSAGE_HEADER_SENDER: + + if (m->sender) + return -EBADMSG; + + if (!streq(signature, "s")) + return -EBADMSG; + + r = message_peek_field_string(m, service_name_is_valid, &ri, &m->sender); + break; + + + case SD_BUS_MESSAGE_HEADER_SIGNATURE: { + const char *s; + char *c; + + if (m->root_container.signature) + return -EBADMSG; + + if (!streq(signature, "g")) + return -EBADMSG; + + r = message_peek_field_signature(m, &ri, &s); + if (r < 0) + return r; + + c = strdup(s); + if (!c) + return -ENOMEM; + + free(m->root_container.signature); + m->root_container.signature = c; + break; + } + + case SD_BUS_MESSAGE_HEADER_REPLY_SERIAL: + if (m->reply_serial != 0) + return -EBADMSG; + + if (!streq(signature, "u")) + return -EBADMSG; + + r = message_peek_field_uint32(m, &ri, &m->reply_serial); + if (r < 0) + return r; + + if (m->reply_serial == 0) + return -EBADMSG; + + break; + + case SD_BUS_MESSAGE_HEADER_UNIX_FDS: + if (unix_fds != 0) + return -EBADMSG; + + if (!streq(signature, "u")) + return -EBADMSG; + + r = message_peek_field_uint32(m, &ri, &unix_fds); + if (r < 0) + return -EBADMSG; + + if (unix_fds == 0) + return -EBADMSG; + + break; + + default: + r = message_skip_fields(m, &ri, (uint32_t) -1, (const char **) &signature); + } + + if (r < 0) + return r; + } + + if (m->n_fds != unix_fds) + return -EBADMSG; + + if (isempty(m->root_container.signature) != (BUS_MESSAGE_BODY_SIZE(m) == 0)) + return -EBADMSG; + + switch (m->header->type) { + + case SD_BUS_MESSAGE_TYPE_SIGNAL: + if (!m->path || !m->interface || !m->member) + return -EBADMSG; + break; + + case SD_BUS_MESSAGE_TYPE_METHOD_CALL: + + if (!m->path || !m->member) + return -EBADMSG; + + break; + + case SD_BUS_MESSAGE_TYPE_METHOD_RETURN: + + if (m->reply_serial == 0) + return -EBADMSG; + break; + + case SD_BUS_MESSAGE_TYPE_METHOD_ERROR: + + if (m->reply_serial == 0 || !m->error.name) + return -EBADMSG; + break; + } + + /* Try to read the error message, but if we can't it's a non-issue */ + if (m->header->type == SD_BUS_MESSAGE_TYPE_METHOD_ERROR) + sd_bus_message_read(m, "s", &m->error.message); + + return 0; +} + +static void setup_iovec(sd_bus_message *m) { + assert(m); + assert(m->sealed); + + m->n_iovec = 0; + m->size = 0; + + m->iovec[m->n_iovec].iov_base = m->header; + m->iovec[m->n_iovec].iov_len = sizeof(*m->header); + m->size += m->iovec[m->n_iovec].iov_len; + m->n_iovec++; + + if (m->fields) { + m->iovec[m->n_iovec].iov_base = m->fields; + m->iovec[m->n_iovec].iov_len = m->header->fields_size; + m->size += m->iovec[m->n_iovec].iov_len; + m->n_iovec++; + + if (m->header->fields_size % 8 != 0) { + static const uint8_t padding[7] = { 0, 0, 0, 0, 0, 0, 0 }; + + m->iovec[m->n_iovec].iov_base = (void*) padding; + m->iovec[m->n_iovec].iov_len = 8 - m->header->fields_size % 8; + m->size += m->iovec[m->n_iovec].iov_len; + m->n_iovec++; + } + } + + if (m->body) { + m->iovec[m->n_iovec].iov_base = m->body; + m->iovec[m->n_iovec].iov_len = m->header->body_size; + m->size += m->iovec[m->n_iovec].iov_len; + m->n_iovec++; + } +} + +int bus_message_seal(sd_bus_message *m, uint64_t serial) { + int r; + + assert(m); + + if (m->sealed) + return -EPERM; + + if (m->n_containers > 0) + return -EBADMSG; + + /* 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, SD_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, SD_BUS_MESSAGE_HEADER_UNIX_FDS, m->n_fds); + if (r < 0) + return r; + } + + m->header->serial = serial; + m->sealed = true; + + setup_iovec(m); + + return 0; +} + +int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) { + if (!m) + return -EINVAL; + if (!destination) + return -EINVAL; + if (m->sealed) + return -EPERM; + if (m->destination) + return -EEXIST; + + return message_append_field_string(m, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &m->destination); +} + +int bus_message_dump(sd_bus_message *m) { + unsigned level = 1; + int r; + + assert(m); + + printf("Message %p\n" + "\tn_ref=%u\n" + "\tendian=%c\n" + "\ttype=%i\n" + "\tflags=%u\n" + "\tversion=%u\n" + "\tserial=%u\n" + "\tfields_size=%u\n" + "\tbody_size=%u\n" + "\tpath=%s\n" + "\tinterface=%s\n" + "\tmember=%s\n" + "\tdestination=%s\n" + "\tsender=%s\n" + "\tsignature=%s\n" + "\treply_serial=%u\n" + "\terror.name=%s\n" + "\terror.message=%s\n" + "\tsealed=%s\n", + m, + m->n_ref, + m->header->endian, + m->header->type, + m->header->flags, + m->header->version, + BUS_MESSAGE_SERIAL(m), + BUS_MESSAGE_FIELDS_SIZE(m), + BUS_MESSAGE_BODY_SIZE(m), + strna(m->path), + strna(m->interface), + strna(m->member), + strna(m->destination), + strna(m->sender), + strna(m->root_container.signature), + m->reply_serial, + strna(m->error.name), + strna(m->error.message), + yes_no(m->sealed)); + + r = sd_bus_message_rewind(m, true); + if (r < 0) { + log_error("Failed to rewind: %s", strerror(-r)); + return r; + } + + printf("BEGIN_MESSAGE \"%s\" {\n", strempty(m->root_container.signature)); + + for(;;) { + _cleanup_free_ char *prefix = NULL; + const char *contents = NULL; + char type; + union { + uint8_t u8; + uint16_t u16; + int16_t s16; + uint32_t u32; + int32_t s32; + uint64_t u64; + int64_t s64; + double d64; + const char *string; + int i; + } basic; + + r = sd_bus_message_peek_type(m, &type, &contents); + if (r < 0) { + log_error("Failed to peek type: %s", strerror(-r)); + return r; + } + if (r == 0) { + if (level <= 1) + break; + + r = sd_bus_message_exit_container(m); + if (r < 0) { + log_error("Failed to exit container: %s", strerror(-r)); + return r; + } + + level--; + + prefix = strrep("\t", level); + if (!prefix) + return log_oom(); + + if (type == SD_BUS_TYPE_ARRAY) + printf("%s} END_ARRAY \n", prefix); + else if (type == SD_BUS_TYPE_VARIANT) + printf("%s} END_VARIANT\n", prefix); + else if (type == SD_BUS_TYPE_STRUCT) + printf("%s} END_STRUCT\n", prefix); + else if (type == SD_BUS_TYPE_DICT_ENTRY) + printf("%s} END_DICT_ENTRY\n", prefix); + + continue; + } + + prefix = strrep("\t", level); + if (!prefix) + return log_oom(); + + if (bus_type_is_container(type) > 0) { + r = sd_bus_message_enter_container(m, type, contents); + if (r < 0) { + log_error("Failed to enter container: %s", strerror(-r)); + return r; + } + + if (type == SD_BUS_TYPE_ARRAY) + printf("%sBEGIN_ARRAY \"%s\" {\n", prefix, contents); + else if (type == SD_BUS_TYPE_VARIANT) + printf("%sBEGIN_VARIANT \"%s\" {\n", prefix, contents); + else if (type == SD_BUS_TYPE_STRUCT) + printf("%sBEGIN_STRUCT \"%s\" {\n", prefix, contents); + else if (type == SD_BUS_TYPE_DICT_ENTRY) + printf("%sBEGIN_DICT_ENTRY \"%s\" {\n", prefix, contents); + + level ++; + + continue; + } + + r = sd_bus_message_read_basic(m, type, &basic); + if (r < 0) { + log_error("Failed to get basic: %s", strerror(-r)); + return r; + } + + switch (type) { + + case SD_BUS_TYPE_BYTE: + printf("%sBYTE: %u\n", prefix, basic.u8); + break; + + case SD_BUS_TYPE_BOOLEAN: + printf("%sBOOLEAN: %s\n", prefix, yes_no(basic.i)); + break; + + case SD_BUS_TYPE_INT16: + printf("%sINT16: %i\n", prefix, basic.s16); + break; + + case SD_BUS_TYPE_UINT16: + printf("%sUINT16: %u\n", prefix, basic.u16); + break; + + case SD_BUS_TYPE_INT32: + printf("%sINT32: %i\n", prefix, basic.s32); + break; + + case SD_BUS_TYPE_UINT32: + printf("%sUINT32: %u\n", prefix, basic.u32); + break; + + case SD_BUS_TYPE_INT64: + printf("%sINT64: %lli\n", prefix, (long long) basic.s64); + break; + + case SD_BUS_TYPE_UINT64: + printf("%sUINT64: %llu\n", prefix, (unsigned long long) basic.u64); + break; + + case SD_BUS_TYPE_DOUBLE: + printf("%sDOUBLE: %g\n", prefix, basic.d64); + break; + + case SD_BUS_TYPE_STRING: + printf("%sSTRING: \"%s\"\n", prefix, basic.string); + break; + + case SD_BUS_TYPE_OBJECT_PATH: + printf("%sOBJECT_PATH: \"%s\"\n", prefix, basic.string); + break; + + case SD_BUS_TYPE_SIGNATURE: + printf("%sSIGNATURE: \"%s\"\n", prefix, basic.string); + break; + + case SD_BUS_TYPE_UNIX_FD: + printf("%sUNIX_FD: %i\n", prefix, basic.i); + break; + + default: + assert_not_reached("Unknown basic type."); + } + } + + printf("} END_MESSAGE\n"); + return 0; +} + +int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz) { + size_t total; + unsigned i; void *p, *e; assert(m); @@ -1411,3 +2974,69 @@ int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz) { return 0; } + +int bus_message_read_strv_extend(sd_bus_message *m, char ***l) { + int r; + + assert(m); + assert(l); + + r = sd_bus_message_enter_container(m, 'a', "s"); + if (r < 0) + return r; + + for (;;) { + const char *s; + + r = sd_bus_message_read_basic(m, 's', &s); + if (r < 0) + return r; + if (r == 0) + break; + + r = strv_extend(l, s); + if (r < 0) + return r; + } + + r = sd_bus_message_exit_container(m); + if (r < 0) + return r; + + return 0; +} + +const char* bus_message_get_arg(sd_bus_message *m, unsigned i) { + int r; + const char *t; + char type; + + assert(m); + + r = sd_bus_message_rewind(m, true); + if (r < 0) + return NULL; + + while (i > 0) { + r = sd_bus_message_peek_type(m, &type, NULL); + if (r < 0) + return NULL; + + if (type != SD_BUS_TYPE_STRING && + type != SD_BUS_TYPE_OBJECT_PATH && + type != SD_BUS_TYPE_SIGNATURE) + return NULL; + + r = sd_bus_message_read_basic(m, type, &t); + if (r < 0) + return NULL; + + i--; + } + + r = sd_bus_message_rewind(m, true); + if (r < 0) + return NULL; + + return t; +}