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=5e355127b0cb119f460738c1c9c346a5a3114b97;hp=fb4718085bb6a73288ba5b3b928686a6669c6389;hb=f7e2bd5a8070ba86cba6bcbf7d1c9a8173d846d4;hpb=2100fa1099b086411270a2876dde0532ea2806fa diff --git a/src/libsystemd-bus/bus-message.c b/src/libsystemd-bus/bus-message.c index fb4718085..5e355127b 100644 --- a/src/libsystemd-bus/bus-message.c +++ b/src/libsystemd-bus/bus-message.c @@ -21,27 +21,94 @@ #include #include +#include #include "util.h" #include "utf8.h" #include "strv.h" +#include "time-util.h" +#include "cgroup-util.h" #include "sd-bus.h" #include "bus-message.h" #include "bus-internal.h" #include "bus-type.h" #include "bus-signature.h" +#include "bus-gvariant.h" -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 reset_containers(sd_bus_message *m) { +static void *adjust_pointer(const void *p, void *old_base, size_t sz, void *new_base) { + + if (p == NULL) + return NULL; + + if (old_base == new_base) + return (void*) p; + + if ((uint8_t*) p < (uint8_t*) old_base) + return (void*) p; + + if ((uint8_t*) p >= (uint8_t*) old_base + sz) + return (void*) p; + + return (uint8_t*) new_base + ((uint8_t*) p - (uint8_t*) old_base); +} + +static void message_free_part(sd_bus_message *m, struct bus_body_part *part) { + assert(m); + assert(part); + + if (part->memfd >= 0) { + /* If we can reuse the memfd, try that. For that it + * can't be sealed yet. */ + + if (!part->sealed) + bus_kernel_push_memfd(m->bus, part->memfd, part->data, part->mapped); + else { + if (part->mapped > 0) + assert_se(munmap(part->data, part->mapped) == 0); + + close_nointr_nofail(part->memfd); + } + + } else if (part->munmap_this) + munmap(part->data, part->mapped); + else if (part->free_this) + free(part->data); + + if (part != &m->body) + free(part); +} + +static void message_reset_parts(sd_bus_message *m) { + struct bus_body_part *part; + + assert(m); + + part = &m->body; + while (m->n_body_parts > 0) { + struct bus_body_part *next = part->next; + message_free_part(m, part); + part = next; + m->n_body_parts--; + } + + m->body_end = NULL; + + m->cached_rindex_part = NULL; + m->cached_rindex_part_begin = 0; +} + +static void message_reset_containers(sd_bus_message *m) { unsigned i; assert(m); - for (i = 0; i < m->n_containers; i++) + for (i = 0; i < m->n_containers; i++) { free(m->containers[i].signature); + free(m->containers[i].offsets); + } free(m->containers); m->containers = NULL; @@ -56,85 +123,102 @@ static void message_free(sd_bus_message *m) { if (m->free_header) free(m->header); - if (m->free_fields) - free(m->fields); + message_reset_parts(m); + + if (m->free_kdbus) + free(m->kdbus); - if (m->free_body) - free(m->body); + if (m->release_kdbus) { + uint64_t off; + + off = (uint8_t *)m->kdbus - (uint8_t *)m->bus->kdbus_buffer; + ioctl(m->bus->input_fd, KDBUS_CMD_FREE, &off); + } + + if (m->bus) + sd_bus_unref(m->bus); if (m->free_fds) { close_many(m->fds, m->n_fds); free(m->fds); } - reset_containers(m); + if (m->iovec != m->iovec_fixed) + free(m->iovec); + + message_reset_containers(m); free(m->root_container.signature); + free(m->root_container.offsets); free(m->peeked_signature); + + bus_creds_done(&m->creds); free(m); } -static void* buffer_extend(void **p, uint32_t *sz, size_t align, size_t extend) { - size_t start, n; - void *k; +static void *message_extend_fields(sd_bus_message *m, size_t align, size_t sz, bool add_offset) { + void *op, *np; + size_t old_size, new_size, start; - assert(p); - assert(sz); - assert(align > 0); + assert(m); + assert_return(!m->poisoned, NULL); - start = ALIGN_TO((size_t) *sz, align); - n = start + extend; + old_size = sizeof(struct bus_header) + m->header->fields_size; + start = ALIGN_TO(old_size, align); + new_size = start + sz; - if (n == *sz) - return (uint8_t*) *p + start; + if (old_size == new_size) + return (uint8_t*) m->header + old_size; - if (n > (size_t) ((uint32_t) -1)) - return NULL; + if (new_size > (size_t) ((uint32_t) -1)) + goto poison; - k = realloc(*p, n); - if (!k) - return NULL; + if (m->free_header) { + np = realloc(m->header, ALIGN8(new_size)); + if (!np) + goto poison; + } else { + /* Initially, the header is allocated as part of of + * the sd_bus_message itself, let's replace it by + * dynamic data */ - /* Zero out padding */ - if (start > *sz) - memset((uint8_t*) k + *sz, 0, start - *sz); + np = malloc(ALIGN8(new_size)); + if (!np) + goto poison; - *p = k; - *sz = n; + memcpy(np, m->header, sizeof(struct bus_header)); + } - return (uint8_t*) k + start; -} + /* Zero out padding */ + if (start > old_size) + memset((uint8_t*) np + old_size, 0, start - old_size); -static void *message_extend_fields(sd_bus_message *m, size_t align, size_t sz) { - void *p, *o; + op = m->header; + m->header = np; + m->header->fields_size = new_size - sizeof(struct bus_header); - assert(m); + /* Adjust quick access pointers */ + m->path = adjust_pointer(m->path, op, old_size, m->header); + m->interface = adjust_pointer(m->interface, op, old_size, m->header); + m->member = adjust_pointer(m->member, op, old_size, m->header); + m->destination = adjust_pointer(m->destination, op, old_size, m->header); + m->sender = adjust_pointer(m->sender, op, old_size, m->header); + m->error.name = adjust_pointer(m->error.name, op, old_size, m->header); - o = m->fields; - p = buffer_extend(&m->fields, &m->header->fields_size, align, sz); - if (!p) - return NULL; + m->free_header = true; - if (o != m->fields) { - /* Adjust quick access pointers */ + if (add_offset) { + if (m->n_header_offsets >= ELEMENTSOF(m->header_offsets)) + goto poison; - if (m->path) - m->path = (const char*) m->fields + (m->path - (const char*) o); - if (m->interface) - m->interface = (const char*) m->fields + (m->interface - (const char*) o); - if (m->member) - m->member = (const char*) m->fields + (m->member - (const char*) o); - if (m->destination) - 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->error.name) - m->error.name = (const char*) m->fields + (m->error.name - (const char*) o); + m->header_offsets[m->n_header_offsets++] = new_size - sizeof(struct bus_header); } - m->free_fields = true; + return (uint8_t*) np + start; - return p; +poison: + m->poisoned = true; + return NULL; } static int message_append_field_string( @@ -149,25 +233,48 @@ static int message_append_field_string( assert(m); + /* dbus1 doesn't allow strings over 32bit, let's enforce this + * globally, to not risk convertability */ l = strlen(s); if (l > (size_t) (uint32_t) -1) return -EINVAL; - /* field id byte + signature length + signature 's' + NUL + string length + string + NUL */ - p = message_extend_fields(m, 8, 4 + 4 + l + 1); - if (!p) - return -ENOMEM; + /* Signature "(yv)" where the variant contains "s" */ - p[0] = h; - p[1] = 1; - p[2] = type; - p[3] = 0; + if (BUS_MESSAGE_IS_GVARIANT(m)) { - ((uint32_t*) p)[1] = l; - memcpy(p + 8, s, l + 1); + /* (field id byte + 7x padding, ((string + NUL) + NUL + signature string 's') */ + p = message_extend_fields(m, 8, 1 + 7 + l + 1 + 1 + 1, true); + if (!p) + return -ENOMEM; - if (ret) - *ret = (const char*) p + 8; + p[0] = h; + memset(p+1, 0, 7); + memcpy(p+8, s, l); + p[8+l] = 0; + p[8+l+1] = 0; + p[8+l+2] = type; + + if (ret) + *ret = (char*) p + 8; + + } else { + /* (field id byte + (signature length + signature 's' + NUL) + (string length + string + NUL)) */ + p = message_extend_fields(m, 8, 4 + 4 + l + 1, false); + if (!p) + return -ENOMEM; + + p[0] = h; + p[1] = 1; + p[2] = type; + p[3] = 0; + + ((uint32_t*) p)[1] = l; + memcpy(p + 8, s, l + 1); + + if (ret) + *ret = (char*) p + 8; + } return 0; } @@ -183,24 +290,33 @@ static int message_append_field_signature( assert(m); + /* dbus1 doesn't allow signatures over 32bit, let's enforce + * this globally, to not risk convertability */ l = strlen(s); if (l > 255) return -EINVAL; - /* field id byte + signature length + signature 'g' + NUL + string length + string + NUL */ - p = message_extend_fields(m, 8, 4 + 1 + l + 1); - if (!p) - return -ENOMEM; + /* Signature "(yv)" where the variant contains "g" */ - p[0] = h; - p[1] = 1; - p[2] = SD_BUS_TYPE_SIGNATURE; - p[3] = 0; - p[4] = l; - memcpy(p + 5, s, l + 1); + if (BUS_MESSAGE_IS_GVARIANT(m)) + /* For gvariant the serialization is the same as for normal strings */ + return message_append_field_string(m, h, 'g', s, ret); + else { + /* (field id byte + (signature length + signature 'g' + NUL) + (string length + string + NUL)) */ + p = message_extend_fields(m, 8, 4 + 1 + l + 1, false); + if (!p) + return -ENOMEM; - if (ret) - *ret = (const char*) p + 5; + p[0] = h; + p[1] = 1; + p[2] = SD_BUS_TYPE_SIGNATURE; + p[3] = 0; + p[4] = l; + memcpy(p + 5, s, l + 1); + + if (ret) + *ret = (const char*) p + 5; + } return 0; } @@ -210,34 +326,49 @@ static int message_append_field_uint32(sd_bus_message *m, uint8_t h, uint32_t x) assert(m); - /* field id byte + signature length + signature 'u' + NUL + value */ - p = message_extend_fields(m, 8, 4 + 4); - if (!p) - return -ENOMEM; + if (BUS_MESSAGE_IS_GVARIANT(m)) { + /* (field id byte + 7x padding + ((value + NUL + signature string 'u') */ + + p = message_extend_fields(m, 8, 1 + 7 + 4 + 1 + 1, true); + if (!p) + return -ENOMEM; - p[0] = h; - p[1] = 1; - p[2] = SD_BUS_TYPE_UINT32; - p[3] = 0; + p[0] = h; + memset(p+1, 0, 7); + *((uint32_t*) (p + 8)) = x; + p[12] = 0; + p[13] = 'u'; + } else { + /* (field id byte + (signature length + signature 'u' + NUL) + value) */ + p = message_extend_fields(m, 8, 4 + 4, false); + if (!p) + return -ENOMEM; - ((uint32_t*) p)[1] = x; + p[0] = h; + p[1] = 1; + p[2] = SD_BUS_TYPE_UINT32; + p[3] = 0; + + ((uint32_t*) p)[1] = x; + } return 0; } -int bus_message_from_malloc( +int bus_message_from_header( + sd_bus *bus, void *buffer, size_t length, int *fds, unsigned n_fds, const struct ucred *ucred, const char *label, + size_t extra, sd_bus_message **ret) { sd_bus_message *m; struct bus_header *h; - size_t total, fs, bs, label_sz, a; - int r; + size_t a, label_sz; assert(buffer || length <= 0); assert(fds || n_fds <= 0); @@ -247,7 +378,8 @@ int bus_message_from_malloc( return -EBADMSG; h = buffer; - if (h->version != 1) + if (h->version != 1 && + h->version != 2) return -EBADMSG; if (h->serial == 0) @@ -256,24 +388,16 @@ int bus_message_from_malloc( 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 + if (h->endian != BUS_LITTLE_ENDIAN && + h->endian != BUS_BIG_ENDIAN) return -EBADMSG; - total = sizeof(struct bus_header) + ALIGN8(fs) + bs; - if (length != total) - return -EBADMSG; + a = ALIGN(sizeof(sd_bus_message)) + ALIGN(extra); if (label) { label_sz = strlen(label); - a = ALIGN(sizeof(sd_bus_message)) + label_sz + 1; - } else - a = sizeof(sd_bus_message); + a += label_sz + 1; + } m = malloc0(a); if (!m) @@ -282,28 +406,68 @@ int bus_message_from_malloc( 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) + ALIGN8(fs); 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; + m->creds.uid = ucred->uid; + m->creds.pid = ucred->pid; + m->creds.gid = ucred->gid; + m->creds.mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID; } if (label) { - m->label = (char*) m + ALIGN(sizeof(sd_bus_message)); - memcpy(m->label, label, label_sz + 1); + m->creds.label = (char*) m + ALIGN(sizeof(sd_bus_message)) + ALIGN(extra); + memcpy(m->creds.label, label, label_sz + 1); + + m->creds.mask |= SD_BUS_CREDS_SELINUX_CONTEXT; + } + + if (bus) + m->bus = sd_bus_ref(bus); + + *ret = m; + return 0; +} + +int bus_message_from_malloc( + sd_bus *bus, + 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; + size_t sz; + int r; + + r = bus_message_from_header(bus, buffer, length, fds, n_fds, ucred, label, 0, &m); + if (r < 0) + return r; + + if (length != BUS_MESSAGE_SIZE(m)) { + r = -EBADMSG; + goto fail; + } + + sz = length - sizeof(struct bus_header) - ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)); + if (sz > 0) { + m->n_body_parts = 1; + m->body.data = (uint8_t*) buffer + sizeof(struct bus_header) + ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)); + m->body.size = sz; + m->body.sealed = true; + m->body.memfd = -1; } m->n_iovec = 1; + m->iovec = m->iovec_fixed; m->iovec[0].iov_base = buffer; m->iovec[0].iov_len = length; - r = message_parse_fields(m); + r = bus_message_parse_fields(m); if (r < 0) goto fail; @@ -328,15 +492,19 @@ static sd_bus_message *message_new(sd_bus *bus, uint8_t type) { m->n_ref = 1; m->header = (struct bus_header*) ((uint8_t*) m + ALIGN(sizeof(struct sd_bus_message))); - m->header->endian = SD_BUS_NATIVE_ENDIAN; + m->header->endian = 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); + m->root_container.need_offsets = BUS_MESSAGE_IS_GVARIANT(m); + + if (bus) + m->bus = sd_bus_ref(bus); return m; } -int sd_bus_message_new_signal( +_public_ int sd_bus_message_new_signal( sd_bus *bus, const char *path, const char *interface, @@ -346,30 +514,25 @@ int sd_bus_message_new_signal( sd_bus_message *t; int r; - if (!path) - return -EINVAL; - if (!interface) - return -EINVAL; - if (!member) - return -EINVAL; - if (!m) - return -EINVAL; - if (bus && bus->state == BUS_UNSET) - return -ENOTCONN; + assert_return(!bus || bus->state != BUS_UNSET, -ENOTCONN); + assert_return(object_path_is_valid(path), -EINVAL); + assert_return(interface_name_is_valid(interface), -EINVAL); + assert_return(member_name_is_valid(member), -EINVAL); + assert_return(m, -EINVAL); - t = message_new(bus, SD_BUS_MESSAGE_TYPE_SIGNAL); + t = message_new(bus, SD_BUS_MESSAGE_SIGNAL); if (!t) return -ENOMEM; - t->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED; + t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED; - r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path); + r = message_append_field_string(t, BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path); if (r < 0) goto fail; - r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_INTERFACE, SD_BUS_TYPE_STRING, interface, &t->interface); + r = message_append_field_string(t, BUS_MESSAGE_HEADER_INTERFACE, SD_BUS_TYPE_STRING, interface, &t->interface); if (r < 0) goto fail; - r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_MEMBER, SD_BUS_TYPE_STRING, member, &t->member); + r = message_append_field_string(t, BUS_MESSAGE_HEADER_MEMBER, SD_BUS_TYPE_STRING, member, &t->member); if (r < 0) goto fail; @@ -381,7 +544,7 @@ fail: return r; } -int sd_bus_message_new_method_call( +_public_ int sd_bus_message_new_method_call( sd_bus *bus, const char *destination, const char *path, @@ -392,34 +555,32 @@ int sd_bus_message_new_method_call( sd_bus_message *t; int r; - if (!path) - return -EINVAL; - if (!member) - return -EINVAL; - if (!m) - return -EINVAL; - if (bus && bus->state == BUS_UNSET) - return -ENOTCONN; + assert_return(!bus || bus->state != BUS_UNSET, -ENOTCONN); + assert_return(!destination || service_name_is_valid(destination), -EINVAL); + assert_return(object_path_is_valid(path), -EINVAL); + assert_return(!interface || interface_name_is_valid(interface), -EINVAL); + assert_return(member_name_is_valid(member), -EINVAL); + assert_return(m, -EINVAL); - t = message_new(bus, SD_BUS_MESSAGE_TYPE_METHOD_CALL); + t = message_new(bus, SD_BUS_MESSAGE_METHOD_CALL); if (!t) return -ENOMEM; - r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path); + r = message_append_field_string(t, BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path); if (r < 0) goto fail; - r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_MEMBER, SD_BUS_TYPE_STRING, member, &t->member); + r = message_append_field_string(t, BUS_MESSAGE_HEADER_MEMBER, SD_BUS_TYPE_STRING, member, &t->member); if (r < 0) goto fail; if (interface) { - r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_INTERFACE, SD_BUS_TYPE_STRING, interface, &t->interface); + r = message_append_field_string(t, BUS_MESSAGE_HEADER_INTERFACE, SD_BUS_TYPE_STRING, interface, &t->interface); if (r < 0) goto fail; } if (destination) { - r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &t->destination); + r = message_append_field_string(t, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &t->destination); if (r < 0) goto fail; } @@ -433,7 +594,6 @@ fail: } static int message_new_reply( - sd_bus *bus, sd_bus_message *call, uint8_t type, sd_bus_message **m) { @@ -441,35 +601,31 @@ static int message_new_reply( sd_bus_message *t; int r; - 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; + assert_return(call, -EINVAL); + assert_return(call->sealed, -EPERM); + assert_return(call->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL); + assert_return(!call->bus || call->bus->state != BUS_UNSET, -ENOTCONN); + assert_return(m, -EINVAL); - t = message_new(bus, type); + t = message_new(call->bus, type); if (!t) return -ENOMEM; - t->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED; + t->header->flags |= 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); + r = message_append_field_uint32(t, BUS_MESSAGE_HEADER_REPLY_SERIAL, t->reply_serial); 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); + r = message_append_field_string(t, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, call->sender, &t->destination); if (r < 0) goto fail; } - t->dont_send = !!(call->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED); + t->dont_send = !!(call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED); + t->enforced_reply_signature = call->enforced_reply_signature; *m = t; return 0; @@ -479,16 +635,14 @@ fail: return r; } -int sd_bus_message_new_method_return( - sd_bus *bus, +_public_ int sd_bus_message_new_method_return( sd_bus_message *call, sd_bus_message **m) { - return message_new_reply(bus, call, SD_BUS_MESSAGE_TYPE_METHOD_RETURN, m); + return message_new_reply(call, SD_BUS_MESSAGE_METHOD_RETURN, m); } -int sd_bus_message_new_method_error( - sd_bus *bus, +_public_ int sd_bus_message_new_method_error( sd_bus_message *call, const sd_bus_error *e, sd_bus_message **m) { @@ -496,16 +650,14 @@ int sd_bus_message_new_method_error( sd_bus_message *t; int r; - if (!sd_bus_error_is_set(e)) - return -EINVAL; - if (!m) - return -EINVAL; + assert_return(sd_bus_error_is_set(e), -EINVAL); + assert_return(m, -EINVAL); - r = message_new_reply(bus, call, SD_BUS_MESSAGE_TYPE_METHOD_ERROR, &t); + r = message_new_reply(call, SD_BUS_MESSAGE_METHOD_ERROR, &t); if (r < 0) return r; - r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, e->name, &t->error.name); + r = message_append_field_string(t, BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, e->name, &t->error.name); if (r < 0) goto fail; @@ -515,6 +667,8 @@ int sd_bus_message_new_method_error( goto fail; } + t->error._need_free = -1; + *m = t; return 0; @@ -523,9 +677,110 @@ fail: return r; } -sd_bus_message* sd_bus_message_ref(sd_bus_message *m) { - if (!m) - return NULL; +_public_ int sd_bus_message_new_method_errorf( + sd_bus_message *call, + sd_bus_message **m, + const char *name, + const char *format, + ...) { + + _cleanup_free_ sd_bus_error error = SD_BUS_ERROR_NULL; + va_list ap; + + assert_return(name, -EINVAL); + assert_return(m, -EINVAL); + + va_start(ap, format); + bus_error_setfv(&error, name, format, ap); + va_end(ap); + + return sd_bus_message_new_method_error(call, &error, m); +} + +_public_ int sd_bus_message_new_method_errno( + sd_bus_message *call, + int error, + const sd_bus_error *p, + sd_bus_message **m) { + + _cleanup_free_ sd_bus_error berror = SD_BUS_ERROR_NULL; + + if (sd_bus_error_is_set(p)) + return sd_bus_message_new_method_error(call, p, m); + + sd_bus_error_set_errno(&berror, error); + + return sd_bus_message_new_method_error(call, &berror, m); +} + +_public_ int sd_bus_message_new_method_errnof( + sd_bus_message *call, + sd_bus_message **m, + int error, + const char *format, + ...) { + + _cleanup_free_ sd_bus_error berror = SD_BUS_ERROR_NULL; + va_list ap; + + va_start(ap, format); + bus_error_set_errnofv(&berror, error, format, ap); + va_end(ap); + + return sd_bus_message_new_method_error(call, &berror, m); +} + +int bus_message_new_synthetic_error( + sd_bus *bus, + uint64_t serial, + const sd_bus_error *e, + sd_bus_message **m) { + + sd_bus_message *t; + int r; + + assert(sd_bus_error_is_set(e)); + assert(m); + + t = message_new(bus, SD_BUS_MESSAGE_METHOD_ERROR); + if (!t) + return -ENOMEM; + + t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED; + t->reply_serial = serial; + + r = message_append_field_uint32(t, BUS_MESSAGE_HEADER_REPLY_SERIAL, t->reply_serial); + if (r < 0) + goto fail; + + if (bus && bus->unique_name) { + r = message_append_field_string(t, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, bus->unique_name, &t->destination); + if (r < 0) + goto fail; + } + + r = message_append_field_string(t, BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, e->name, &t->error.name); + if (r < 0) + goto fail; + + if (e->message) { + r = message_append_basic(t, SD_BUS_TYPE_STRING, e->message, (const void**) &t->error.message); + if (r < 0) + goto fail; + } + + t->error._need_free = -1; + + *m = t; + return 0; + +fail: + message_free(t); + return r; +} + +_public_ sd_bus_message* sd_bus_message_ref(sd_bus_message *m) { + assert_return(m, NULL); assert(m->n_ref > 0); m->n_ref++; @@ -533,9 +788,8 @@ sd_bus_message* sd_bus_message_ref(sd_bus_message *m) { return m; } -sd_bus_message* sd_bus_message_unref(sd_bus_message *m) { - if (!m) - return NULL; +_public_ sd_bus_message* sd_bus_message_unref(sd_bus_message *m) { + assert_return(m, NULL); assert(m->n_ref > 0); m->n_ref--; @@ -546,143 +800,114 @@ sd_bus_message* sd_bus_message_unref(sd_bus_message *m) { return NULL; } -int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type) { - if (!m) - return -EINVAL; - if (!type) - return -EINVAL; +_public_ int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type) { + assert_return(m, -EINVAL); + assert_return(type, -EINVAL); *type = m->header->type; return 0; } -int sd_bus_message_get_serial(sd_bus_message *m, uint64_t *serial) { - if (!m) - return -EINVAL; - if (!serial) - return -EINVAL; - if (m->header->serial == 0) - return -ENOENT; +_public_ int sd_bus_message_get_serial(sd_bus_message *m, uint64_t *serial) { + assert_return(m, -EINVAL); + assert_return(serial, -EINVAL); + assert_return(m->header->serial != 0, -ENOENT); *serial = BUS_MESSAGE_SERIAL(m); return 0; } -int sd_bus_message_get_reply_serial(sd_bus_message *m, uint64_t *serial) { - if (!m) - return -EINVAL; - if (!serial) - return -EINVAL; - if (m->reply_serial == 0) - return -ENOENT; +_public_ int sd_bus_message_get_reply_serial(sd_bus_message *m, uint64_t *serial) { + assert_return(m, -EINVAL); + assert_return(serial, -EINVAL); + assert_return(m->reply_serial != 0, -ENOENT); *serial = m->reply_serial; return 0; } -int sd_bus_message_get_no_reply(sd_bus_message *m) { - if (!m) - return -EINVAL; +_public_ int sd_bus_message_get_no_reply(sd_bus_message *m) { + assert_return(m, -EINVAL); - return m->header->type == SD_BUS_MESSAGE_TYPE_METHOD_CALL ? !!(m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED) : 0; + return m->header->type == SD_BUS_MESSAGE_METHOD_CALL ? !!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) : 0; } -const char *sd_bus_message_get_path(sd_bus_message *m) { - if (!m) - return NULL; +_public_ int sd_bus_message_get_no_auto_start(sd_bus_message *m) { + assert_return(m, -EINVAL); + + return !!(m->header->flags & BUS_MESSAGE_NO_AUTO_START); +} + +_public_ const char *sd_bus_message_get_path(sd_bus_message *m) { + assert_return(m, NULL); return m->path; } -const char *sd_bus_message_get_interface(sd_bus_message *m) { - if (!m) - return NULL; +_public_ const char *sd_bus_message_get_interface(sd_bus_message *m) { + assert_return(m, NULL); return m->interface; } -const char *sd_bus_message_get_member(sd_bus_message *m) { - if (!m) - return NULL; +_public_ const char *sd_bus_message_get_member(sd_bus_message *m) { + assert_return(m, NULL); return m->member; } -const char *sd_bus_message_get_destination(sd_bus_message *m) { - if (!m) - return NULL; + +_public_ const char *sd_bus_message_get_destination(sd_bus_message *m) { + assert_return(m, NULL); return m->destination; } -const char *sd_bus_message_get_sender(sd_bus_message *m) { - if (!m) - return NULL; +_public_ const char *sd_bus_message_get_sender(sd_bus_message *m) { + assert_return(m, NULL); return m->sender; } -const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) { - if (!m) - return NULL; - - if (!sd_bus_error_is_set(&m->error)) - return NULL; +_public_ const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) { + assert_return(m, NULL); + assert_return(sd_bus_error_is_set(&m->error), NULL); return &m->error; } -int sd_bus_message_get_uid(sd_bus_message *m, uid_t *uid) { - if (!m) - return -EINVAL; - if (!m->uid_valid) - return -ENOENT; - - *uid = m->uid; - return 0; -} - -int sd_bus_message_get_gid(sd_bus_message *m, gid_t *gid) { - if (!m) - return -EINVAL; - if (!m->gid_valid) - return -ENOENT; +_public_ int sd_bus_message_get_monotonic_timestamp(sd_bus_message *m, uint64_t *usec) { + assert_return(m, -EINVAL); + assert_return(usec, -EINVAL); + assert_return(m->monotonic > 0, -ENODATA); - *gid = m->gid; + *usec = m->monotonic; return 0; } -int sd_bus_message_get_pid(sd_bus_message *m, pid_t *pid) { - if (!m) - return -EINVAL; - if (m->pid <= 0) - return -ENOENT; +_public_ int sd_bus_message_get_realtime_timestamp(sd_bus_message *m, uint64_t *usec) { + assert_return(m, -EINVAL); + assert_return(usec, -EINVAL); + assert_return(m->realtime > 0, -ENODATA); - *pid = m->pid; + *usec = m->realtime; return 0; } -int sd_bus_message_get_tid(sd_bus_message *m, pid_t *tid) { - if (!m) - return -EINVAL; - if (m->tid <= 0) - return -ENOENT; - - *tid = m->tid; - return 0; -} +_public_ sd_bus_creds *sd_bus_message_get_creds(sd_bus_message *m) { + assert_return(m, NULL); -const char *sd_bus_message_get_label(sd_bus_message *m) { - if (!m) + if (m->creds.mask == 0) return NULL; - return m->label; + return &m->creds; } -int sd_bus_message_is_signal(sd_bus_message *m, const char *interface, const char *member) { - if (!m) - return -EINVAL; +_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_TYPE_SIGNAL) + if (m->header->type != SD_BUS_MESSAGE_SIGNAL) return 0; if (interface && (!m->interface || !streq(m->interface, interface))) @@ -694,11 +919,12 @@ int sd_bus_message_is_signal(sd_bus_message *m, const char *interface, const cha return 1; } -int sd_bus_message_is_method_call(sd_bus_message *m, const char *interface, const char *member) { - if (!m) - return -EINVAL; +_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_TYPE_METHOD_CALL) + if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL) return 0; if (interface && (!m->interface || !streq(m->interface, interface))) @@ -710,11 +936,10 @@ int sd_bus_message_is_method_call(sd_bus_message *m, const char *interface, cons return 1; } -int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) { - if (!m) - return -EINVAL; +_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_TYPE_METHOD_ERROR) + if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR) return 0; if (name && (!m->error.name || !streq(m->error.name, name))) @@ -723,18 +948,27 @@ int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) { return 1; } -int sd_bus_message_set_no_reply(sd_bus_message *m, int b) { - if (!m) - return -EINVAL; - if (m->sealed) - return -EPERM; - if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL) - return -EPERM; +_public_ int sd_bus_message_set_no_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); + + if (b) + m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED; + else + m->header->flags &= ~BUS_MESSAGE_NO_REPLY_EXPECTED; + + return 0; +} + +_public_ int sd_bus_message_set_no_auto_start(sd_bus_message *m, int b) { + assert_return(m, -EINVAL); + assert_return(!m->sealed, -EPERM); if (b) - m->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED; + m->header->flags |= BUS_MESSAGE_NO_AUTO_START; else - m->header->flags &= ~SD_BUS_MESSAGE_NO_REPLY_EXPECTED; + m->header->flags &= ~BUS_MESSAGE_NO_AUTO_START; return 0; } @@ -749,1103 +983,2740 @@ static struct bus_container *message_get_container(sd_bus_message *m) { return m->containers + m->n_containers - 1; } -static void *message_extend_body(sd_bus_message *m, size_t align, size_t sz) { - void *p, *o; - size_t added; - struct bus_container *c; +struct bus_body_part *message_append_part(sd_bus_message *m) { + struct bus_body_part *part; assert(m); - assert(align > 0); - - o = m->body; - added = m->header->body_size; - - p = buffer_extend(&m->body, &m->header->body_size, align, sz); - if (!p) - return NULL; + assert_return(!m->poisoned, NULL); - added = m->header->body_size - added; + if (m->n_body_parts <= 0) { + part = &m->body; + zero(*part); + } else { + assert(m->body_end); - 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; + part = new0(struct bus_body_part, 1); + if (!part) { + m->poisoned = true; + return NULL; } - if (o != m->body) { - if (m->error.message) - m->error.message = (const char*) m->body + (m->error.message - (const char*) o); + m->body_end->next = part; } - m->free_body = true; + part->memfd = -1; + m->body_end = part; + m->n_body_parts ++; - return p; + return part; } -int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored) { - struct bus_container *c; - 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)) - return -EINVAL; +static void part_zero(struct bus_body_part *part, size_t sz) { + assert(part); + assert(sz > 0); + assert(sz < 8); - c = message_get_container(m); + /* All other fields can be left in their defaults */ + assert(!part->data); + assert(part->memfd < 0); - if (c->signature && c->signature[c->index]) { - /* Container signature is already set */ + part->size = sz; + part->is_zero = true; + part->sealed = true; +} - if (c->signature[c->index] != type) - return -ENXIO; - } else { - /* Maybe we can append to the signature? But only if this is the top-level container*/ - if (c->enclosing != 0) - return -ENXIO; +static int part_make_space( + struct sd_bus_message *m, + struct bus_body_part *part, + size_t sz, + void **q) { - e = strextend(&c->signature, CHAR_TO_STR(type), NULL); - if (!e) - return -ENOMEM; - } + void *n; + int r; - switch (type) { + assert(m); + assert(part); + assert(!part->sealed); - case SD_BUS_TYPE_STRING: - case SD_BUS_TYPE_OBJECT_PATH: + if (m->poisoned) + return -ENOMEM; - align = 4; - sz = 4 + strlen(p) + 1; - break; + if (!part->data && part->memfd < 0) + part->memfd = bus_kernel_pop_memfd(m->bus, &part->data, &part->mapped); - case SD_BUS_TYPE_SIGNATURE: + if (part->memfd >= 0) { + uint64_t u = sz; - align = 1; - sz = 1 + strlen(p) + 1; - break; + r = ioctl(part->memfd, KDBUS_CMD_MEMFD_SIZE_SET, &u); + if (r < 0) { + m->poisoned = true; + return -errno; + } - case SD_BUS_TYPE_BOOLEAN: - align = sz = 4; + if (!part->data || sz > part->mapped) { + size_t psz = PAGE_ALIGN(sz > 0 ? sz : 1); - assert_cc(sizeof(int) == sizeof(uint32_t)); - memcpy(&k, p, 4); - k = !!k; - p = &k; - break; + if (part->mapped <= 0) + n = mmap(NULL, psz, PROT_READ|PROT_WRITE, MAP_SHARED, part->memfd, 0); + else + n = mremap(part->data, part->mapped, psz, MREMAP_MAYMOVE); - case SD_BUS_TYPE_UNIX_FD: { - int z, *f; + if (n == MAP_FAILED) { + m->poisoned = true; + return -errno; + } - if (!m->allow_fds) { - r = -ENOTSUP; - goto fail; + part->mapped = psz; + part->data = n; } - align = sz = 4; - - z = *(int*) p; - if (z < 0) { - r = -EINVAL; - goto fail; + part->munmap_this = true; + } else { + n = realloc(part->data, MAX(sz, 1u)); + if (!n) { + m->poisoned = true; + return -ENOMEM; } - fd = fcntl(z, F_DUPFD_CLOEXEC, 3); - if (fd < 0) { - r = -errno; - goto fail; - } + part->data = n; + part->free_this = true; + } - f = realloc(m->fds, sizeof(int) * (m->n_fds + 1)); - if (!f) { - r = -ENOMEM; - goto fail; - } + if (q) + *q = part->data ? (uint8_t*) part->data + part->size : NULL; - fdi = m->n_fds; - f[fdi] = fd; - m->fds = f; - m->free_fds = true; - break; - } + part->size = sz; + return 0; +} - default: - align = bus_type_get_alignment(type); - sz = bus_type_get_size(type); - break; - } +static int message_add_offset(sd_bus_message *m, size_t offset) { + struct bus_container *c; - assert(align > 0); - assert(sz > 0); + assert(m); + assert(BUS_MESSAGE_IS_GVARIANT(m)); - a = message_extend_body(m, align, sz); - if (!a) { - r = -ENOMEM; - goto fail; - } + /* Add offset to current container, unless this is the first + * item in it, which will have the 0 offset, which we can + * ignore. */ + c = message_get_container(m); - if (type == SD_BUS_TYPE_STRING || type == SD_BUS_TYPE_OBJECT_PATH) { - *(uint32_t*) a = sz - 5; - memcpy((uint8_t*) a + 4, p, sz - 4); + if (!c->need_offsets) + return 0; - if (stored) - *stored = (const uint8_t*) a + 4; + if (!GREEDY_REALLOC(c->offsets, c->n_offsets_allocated, c->n_offsets + 1)) + return -ENOMEM; - } else if (type == SD_BUS_TYPE_SIGNATURE) { - *(uint8_t*) a = sz - 1; - memcpy((uint8_t*) a + 1, p, sz - 1); + c->offsets[c->n_offsets++] = offset; + return 0; +} - if (stored) - *stored = (const uint8_t*) a + 1; - } else if (type == SD_BUS_TYPE_UNIX_FD) { - *(uint32_t*) a = fdi; +static void message_extend_containers(sd_bus_message *m, size_t expand) { + struct bus_container *c; - if (stored) - *stored = a; + assert(m); - m->n_fds ++; + if (expand <= 0) + return; - } else { - memcpy(a, p, sz); + /* Update counters */ + for (c = m->containers; c < m->containers + m->n_containers; c++) { - if (stored) - *stored = a; + if (c->array_size) + *c->array_size += expand; } +} - if (c->enclosing != SD_BUS_TYPE_ARRAY) - c->index++; +static void *message_extend_body(sd_bus_message *m, size_t align, size_t sz, bool add_offset) { + size_t start_body, end_body, padding, added; + void *p; + int r; - return 0; + assert(m); + assert(align > 0); + assert(!m->sealed); + assert_return(!m->poisoned, NULL); -fail: - /* Truncate extended signature again */ - if (e) - c->signature[c->index] = 0; + start_body = ALIGN_TO((size_t) m->header->body_size, align); + end_body = start_body + sz; - if (fd >= 0) - close_nointr_nofail(fd); + padding = start_body - m->header->body_size; + added = padding + sz; - return r; -} + /* Check for 32bit overflows */ + if (end_body > (size_t) ((uint32_t) -1)) { + m->poisoned = true; + return NULL; + } -int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p) { - return message_append_basic(m, type, p, NULL); -} + if (added > 0) { + struct bus_body_part *part = NULL; + bool add_new_part; -static int bus_message_open_array( - sd_bus_message *m, - struct bus_container *c, - const char *contents, - uint32_t **array_size) { + add_new_part = + m->n_body_parts <= 0 || + m->body_end->sealed || + padding != ALIGN_TO(m->body_end->size, align) - m->body_end->size; - unsigned nindex; - char *e = NULL; - void *a, *b; - int alignment; - size_t saved; + if (add_new_part) { + if (padding > 0) { + part = message_append_part(m); + if (!part) + return NULL; - assert(m); - assert(c); - assert(contents); - assert(array_size); + part_zero(part, padding); + } - if (!signature_is_single(contents)) - return -EINVAL; + part = message_append_part(m); + if (!part) + return NULL; - alignment = bus_type_get_alignment(contents[0]); - if (alignment < 0) - return alignment; + r = part_make_space(m, part, sz, &p); + if (r < 0) + return NULL; + } else { + struct bus_container *c; + void *op; + size_t os, start_part, end_part; - if (c->signature && c->signature[c->index]) { + part = m->body_end; + op = part->data; + os = part->size; - /* Verify the existing signature */ + start_part = ALIGN_TO(part->size, align); + end_part = start_part + sz; - if (c->signature[c->index] != SD_BUS_TYPE_ARRAY) - return -ENXIO; + r = part_make_space(m, part, end_part, &p); + if (r < 0) + return NULL; - if (!startswith(c->signature + c->index + 1, contents)) - return -ENXIO; + if (padding > 0) { + memset(p, 0, padding); + p = (uint8_t*) p + padding; + } - nindex = c->index + 1 + strlen(contents); - } else { - if (c->enclosing != 0) - return -ENXIO; + /* Readjust pointers */ + for (c = m->containers; c < m->containers + m->n_containers; c++) + c->array_size = adjust_pointer(c->array_size, op, os, part->data); - /* Extend the existing signature */ + 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 *) NULL + align; - e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_ARRAY), contents, NULL); - if (!e) - return -ENOMEM; + m->header->body_size = end_body; + message_extend_containers(m, added); - nindex = e - c->signature; + if (add_offset) { + r = message_add_offset(m, end_body); + if (r < 0) { + m->poisoned = true; + return NULL; + } } - saved = m->header->body_size; - a = message_extend_body(m, 4, 4); - if (!a) { - /* Truncate extended signature again */ - if (e) - c->signature[c->index] = 0; + return p; +} - return -ENOMEM; - } - b = m->body; +static int message_push_fd(sd_bus_message *m, int fd) { + int *f, copy; - if (!message_extend_body(m, alignment, 0)) { - /* Add alignment between size and first element */ - if (e) - c->signature[c->index] = 0; + assert(m); - m->header->body_size = saved; + if (fd < 0) + return -EINVAL; + + if (!m->allow_fds) + return -ENOTSUP; + + copy = fcntl(fd, F_DUPFD_CLOEXEC, 3); + if (copy < 0) + return -errno; + + f = realloc(m->fds, sizeof(int) * (m->n_fds + 1)); + if (!f) { + m->poisoned = true; + close_nointr_nofail(copy); return -ENOMEM; } - if (c->enclosing != SD_BUS_TYPE_ARRAY) - c->index = nindex; - - /* m->body might have changed so let's readjust a */ - a = (uint8_t*) m->body + ((uint8_t*) a - (uint8_t*) b); - *(uint32_t*) a = 0; + m->fds = f; + m->fds[m->n_fds] = copy; + m->free_fds = true; - *array_size = a; - return 0; + return copy; } -static int bus_message_open_variant( - sd_bus_message *m, - struct bus_container *c, - const char *contents) { - - char *e = NULL; - size_t l; +int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored) { + _cleanup_close_ int fd = -1; + struct bus_container *c; + ssize_t align, sz; void *a; - assert(m); - assert(c); - assert(contents); - - if (!signature_is_single(contents)) - return -EINVAL; + assert_return(m, -EINVAL); + assert_return(!m->sealed, -EPERM); + assert_return(bus_type_is_basic(type), -EINVAL); + assert_return(!m->poisoned, -ESTALE); - if (*contents == SD_BUS_TYPE_DICT_ENTRY_BEGIN) - return -EINVAL; + c = message_get_container(m); if (c->signature && c->signature[c->index]) { + /* Container signature is already set */ - if (c->signature[c->index] != SD_BUS_TYPE_VARIANT) + 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(SD_BUS_TYPE_VARIANT), NULL); - if (!e) + e = strextend(&c->signature, CHAR_TO_STR(type), NULL); + if (!e) { + m->poisoned = true; return -ENOMEM; + } } - l = strlen(contents); - a = message_extend_body(m, 1, 1 + l + 1); - if (!a) { - /* Truncate extended signature again */ - if (e) - c->signature[c->index] = 0; + if (BUS_MESSAGE_IS_GVARIANT(m)) { + uint8_t u8; + uint32_t u32; - return -ENOMEM; - } + switch (type) { + + case SD_BUS_TYPE_SIGNATURE: + case SD_BUS_TYPE_STRING: + p = strempty(p); - *(uint8_t*) a = l; - memcpy((uint8_t*) a + 1, contents, l + 1); + /* Fall through... */ + case SD_BUS_TYPE_OBJECT_PATH: + if (!p) + return -EINVAL; - if (c->enclosing != SD_BUS_TYPE_ARRAY) - c->index++; + align = 1; + sz = strlen(p) + 1; + break; - return 0; -} + case SD_BUS_TYPE_BOOLEAN: -static int bus_message_open_struct( - sd_bus_message *m, - struct bus_container *c, - const char *contents) { + u8 = p && *(int*) p; + p = &u8; - size_t nindex; - char *e = NULL; + align = sz = 1; + break; - assert(m); - assert(c); - assert(contents); + case SD_BUS_TYPE_UNIX_FD: - if (!signature_is_valid(contents, false)) - return -EINVAL; + if (!p) + return -EINVAL; - if (c->signature && c->signature[c->index]) { - size_t l; + fd = message_push_fd(m, *(int*) p); + if (fd < 0) + return fd; - l = strlen(contents); + u32 = m->n_fds; + p = &u32; - 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; + align = sz = 4; + break; - nindex = c->index + 1 + l + 1; - } else { - if (c->enclosing != 0) - return -ENXIO; + default: + align = bus_gvariant_get_alignment(CHAR_TO_STR(type)); + sz = bus_gvariant_get_size(CHAR_TO_STR(type)); + break; + } - e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_BEGIN), contents, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_END), NULL); - if (!e) + assert(align > 0); + assert(sz > 0); + + a = message_extend_body(m, align, sz, true); + if (!a) return -ENOMEM; - nindex = e - c->signature; - } + memcpy(a, p, sz); - /* Align contents to 8 byte boundary */ - if (!message_extend_body(m, 8, 0)) { - if (e) - c->signature[c->index] = 0; + if (stored) + *stored = (const uint8_t*) a; - return -ENOMEM; - } + } else { + uint32_t u32; - if (c->enclosing != SD_BUS_TYPE_ARRAY) - c->index = nindex; + switch (type) { - return 0; -} + case SD_BUS_TYPE_STRING: + /* To make things easy we'll serialize a NULL string + * into the empty string */ + p = strempty(p); -static int bus_message_open_dict_entry( - sd_bus_message *m, - struct bus_container *c, - const char *contents) { + /* Fall through... */ + case SD_BUS_TYPE_OBJECT_PATH: - size_t nindex; + if (!p) + return -EINVAL; - assert(m); - assert(c); - assert(contents); + align = 4; + sz = 4 + strlen(p) + 1; + break; - if (!signature_is_pair(contents)) - return -EINVAL; + case SD_BUS_TYPE_SIGNATURE: + + p = strempty(p); + + 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); + break; + } + + assert(align > 0); + assert(sz > 0); + + a = message_extend_body(m, align, sz, false); + if (!a) + return -ENOMEM; + + if (type == SD_BUS_TYPE_STRING || type == 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 - 1; + 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) - return -ENXIO; + c->index++; + + fd = -1; + 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 **s) { + + struct bus_container *c; + void *a; + + assert_return(m, -EINVAL); + assert_return(s, -EINVAL); + assert_return(!m->sealed, -EPERM); + assert_return(!m->poisoned, -ESTALE); + + c = message_get_container(m); if (c->signature && c->signature[c->index]) { - size_t l; + /* Container signature is already set */ - l = strlen(contents); + if (c->signature[c->index] != SD_BUS_TYPE_STRING) + return -ENXIO; + } else { + char *e; - 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) + /* Maybe we can append to the signature? But only if this is the top-level container*/ + if (c->enclosing != 0) return -ENXIO; - nindex = c->index + 1 + l + 1; - } else - return -ENXIO; + e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRING), NULL); + if (!e) { + m->poisoned = true; + return -ENOMEM; + } + } - /* Align contents to 8 byte boundary */ - if (!message_extend_body(m, 8, 0)) - return -ENOMEM; + if (BUS_MESSAGE_IS_GVARIANT(m)) { + a = message_extend_body(m, 1, size + 1, true); + if (!a) + return -ENOMEM; + + *s = a; + } else { + a = message_extend_body(m, 4, 4 + size + 1, false); + if (!a) + return -ENOMEM; + + *(uint32_t*) a = size; + *s = (char*) a + 4; + } + + (*s)[size] = 0; if (c->enclosing != SD_BUS_TYPE_ARRAY) - c->index = nindex; + c->index++; return 0; } -int sd_bus_message_open_container( +_public_ int sd_bus_message_append_string_iovec( sd_bus_message *m, - char type, - const char *contents) { + const struct iovec *iov, + unsigned n) { - struct bus_container *c, *w; - uint32_t *array_size = NULL; - char *signature; + size_t size; + unsigned i; + char *p; int r; - if (!m) - return -EINVAL; - if (m->sealed) - return -EPERM; - if (!contents) + assert_return(m, -EINVAL); + assert_return(!m->sealed, -EPERM); + assert_return(iov || n == 0, -EINVAL); + assert_return(!m->poisoned, -ESTALE); + + size = IOVEC_TOTAL_SIZE(iov, n); + + r = sd_bus_message_append_string_space(m, size, &p); + if (r < 0) + return r; + + for (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, + struct bus_container *c, + const char *contents, + uint32_t **array_size, + size_t *begin, + bool *need_offsets) { + + unsigned nindex; + int alignment, r; + + assert(m); + assert(c); + assert(contents); + assert(array_size); + assert(begin); + assert(need_offsets); + + if (!signature_is_single(contents, true)) return -EINVAL; - /* Make sure we have space for one more container */ - w = realloc(m->containers, sizeof(struct bus_container) * (m->n_containers + 1)); - if (!w) - return -ENOMEM; - m->containers = w; + if (c->signature && c->signature[c->index]) { - c = message_get_container(m); + /* Verify the existing signature */ - signature = strdup(contents); - if (!signature) - return -ENOMEM; + if (c->signature[c->index] != SD_BUS_TYPE_ARRAY) + return -ENXIO; - 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 (!startswith(c->signature + c->index + 1, contents)) + return -ENXIO; - if (r < 0) { - free(signature); - return r; + 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, NULL); + if (!e) { + m->poisoned = true; + return -ENOMEM; + } + + nindex = e - c->signature; } - /* 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 = 0; + if (BUS_MESSAGE_IS_GVARIANT(m)) { + alignment = bus_gvariant_get_alignment(contents); + if (alignment < 0) + return alignment; + + /* Add alignment padding and add to offset list */ + if (!message_extend_body(m, alignment, 0, false)) + return -ENOMEM; + + r = bus_gvariant_is_fixed_size(contents); + if (r < 0) + return r; + + *begin = m->header->body_size; + *need_offsets = r == 0; + } else { + void *a, *op; + size_t os; + struct bus_body_part *o; + + alignment = bus_type_get_alignment(contents[0]); + if (alignment < 0) + return alignment; + + a = message_extend_body(m, 4, 4, false); + 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, false)) + 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; + *array_size = a; + } + + if (c->enclosing != SD_BUS_TYPE_ARRAY) + c->index = nindex; return 0; } -int sd_bus_message_close_container(sd_bus_message *m) { - struct bus_container *c; +static int bus_message_open_variant( + sd_bus_message *m, + struct bus_container *c, + const char *contents) { - if (!m) + assert(m); + assert(c); + assert(contents); + + if (!signature_is_single(contents, false)) return -EINVAL; - if (m->sealed) - return -EPERM; - if (m->n_containers <= 0) + + if (*contents == SD_BUS_TYPE_DICT_ENTRY_BEGIN) return -EINVAL; - c = message_get_container(m); - if (c->enclosing != SD_BUS_TYPE_ARRAY) - if (c->signature && c->signature[c->index] != 0) - return -EINVAL; + if (c->signature && c->signature[c->index]) { - free(c->signature); - m->n_containers--; + 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), NULL); + if (!e) { + m->poisoned = true; + return -ENOMEM; + } + } + + if (BUS_MESSAGE_IS_GVARIANT(m)) { + /* Variants are always aligned to 8 */ + + if (!message_extend_body(m, 8, 0, false)) + return -ENOMEM; + + } else { + size_t l; + void *a; + + l = strlen(contents); + a = message_extend_body(m, 1, 1 + l + 1, false); + 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, + struct bus_container *c, + const char *contents, + size_t *begin, + bool *need_offsets) { -typedef struct { - const char *types; - unsigned n_struct; - unsigned n_array; -} TypeStack; + size_t nindex; + int r; -static int type_stack_push(TypeStack *stack, unsigned max, unsigned *i, const char *types, unsigned n_struct, unsigned n_array) { - assert(stack); - assert(max > 0); + assert(m); + assert(c); + assert(contents); + assert(begin); + assert(need_offsets); - if (*i >= max) + if (!signature_is_valid(contents, false)) return -EINVAL; - stack[*i].types = types; - stack[*i].n_struct = n_struct; - stack[*i].n_array = n_array; - (*i)++; + 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), NULL); + if (!e) { + m->poisoned = true; + return -ENOMEM; + } + + nindex = e - c->signature; + } + + if (BUS_MESSAGE_IS_GVARIANT(m)) { + int alignment; + + alignment = bus_gvariant_get_alignment(contents); + if (alignment < 0) + return alignment; + + if (!message_extend_body(m, alignment, 0, false)) + return -ENOMEM; + + r = bus_gvariant_is_fixed_size(contents); + if (r < 0) + return r; + + *begin = m->header->body_size; + *need_offsets = r == 0; + } else { + /* Align contents to 8 byte boundary */ + if (!message_extend_body(m, 8, 0, false)) + 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, + struct bus_container *c, + const char *contents, + size_t *begin, + bool *need_offsets) { + + int r; + + assert(m); + assert(c); + assert(contents); + assert(begin); + assert(need_offsets); + + 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; + + if (BUS_MESSAGE_IS_GVARIANT(m)) { + int alignment; + + alignment = bus_gvariant_get_alignment(contents); + if (alignment < 0) + return alignment; + + if (!message_extend_body(m, alignment, 0, false)) + return -ENOMEM; + + r = bus_gvariant_is_fixed_size(contents); + if (r < 0) + return r; + + *begin = m->header->body_size; + *need_offsets = r == 0; + } else { + /* Align contents to 8 byte boundary */ + if (!message_extend_body(m, 8, 0, false)) + return -ENOMEM; + } + + return 0; +} + +_public_ int sd_bus_message_open_container( + sd_bus_message *m, + char type, + const char *contents) { + + struct bus_container *c, *w; + uint32_t *array_size = NULL; + char *signature; + size_t before, begin; + bool need_offsets = false; + 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 */ + w = realloc(m->containers, sizeof(struct bus_container) * (m->n_containers + 1)); + if (!w) { + m->poisoned = true; + return -ENOMEM; + } + + m->containers = w; + + c = message_get_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->header->body_size; + + if (type == SD_BUS_TYPE_ARRAY) + r = bus_message_open_array(m, c, contents, &array_size, &begin, &need_offsets); + 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, &begin, &need_offsets); + else if (type == SD_BUS_TYPE_DICT_ENTRY) + r = bus_message_open_dict_entry(m, c, contents, &begin, &need_offsets); + 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->before = before; + w->begin = begin; + w->n_offsets = w->n_offsets_allocated = 0; + w->offsets = NULL; + w->need_offsets = need_offsets; + + return 0; +} + +static size_t determine_word_size(size_t sz, size_t extra) { + if (sz + extra <= 0xFF) + return 1; + else if (sz + extra*2 <= 0xFFFF) + return 2; + else if (sz + extra*4 <= 0xFFFFFFFF) + return 4; + else + return 8; +} + +static size_t read_word_le(void *p, size_t sz) { + union { + uint16_t u16; + uint32_t u32; + uint64_t u64; + } x; + + assert(p); + + if (sz == 1) + return *(uint8_t*) p; + + memcpy(&x, p, sz); + + if (sz == 2) + return le16toh(x.u16); + else if (sz == 4) + return le32toh(x.u32); + else if (sz == 4) + return le64toh(x.u64); + + assert_not_reached("unknown word width"); +} + +static void write_word_le(void *p, size_t sz, size_t value) { + union { + uint16_t u16; + uint32_t u32; + uint64_t u64; + } x; + + assert(p); + assert(sz == 8 || (value < (1ULL << (sz*8)))); + + if (sz == 1) { + *(uint8_t*) p = value; + return; + } else if (sz == 2) + x.u16 = htole16((uint16_t) value); + else if (sz == 4) + x.u32 = htole32((uint32_t) value); + else if (sz == 8) + x.u64 = htole64((uint64_t) value); + else + assert_not_reached("unknown word width"); + + memcpy(p, &x, sz); +} + +static int bus_message_close_array(sd_bus_message *m, struct bus_container *c) { + + assert(m); + assert(c); + + if (!BUS_MESSAGE_IS_GVARIANT(m)) + return 0; + + if (c->need_offsets) { + size_t payload, sz, i; + uint8_t *a; + + /* Variable-width arrays */ + + payload = c->n_offsets > 0 ? c->offsets[c->n_offsets-1] - c->begin : 0; + sz = determine_word_size(payload, c->n_offsets); + + a = message_extend_body(m, 1, sz * c->n_offsets, true); + if (!a) + return -ENOMEM; + + for (i = 0; i < c->n_offsets; i++) + write_word_le(a + sz*i, sz, c->offsets[i] - c->begin); + } else { + void *a; + + /* Fixed-width or empty arrays */ + + a = message_extend_body(m, 1, 0, true); /* let's add offset to parent */ + if (!a) + return -ENOMEM; + } + + return 0; +} + +static int bus_message_close_variant(sd_bus_message *m, struct bus_container *c) { + uint8_t *a; + size_t l; + + assert(m); + assert(c); + + if (!BUS_MESSAGE_IS_GVARIANT(m)) + return 0; + + l = strlen(c->signature); + + a = message_extend_body(m, 1, 1 + l, true); + if (!a) + return -ENOMEM; + + a[0] = 0; + memcpy(a+1, c->signature, l); + + return 0; +} + +static int bus_message_close_struct(sd_bus_message *m, struct bus_container *c, bool add_offset) { + size_t n_variable = 0; + unsigned i = 0; + const char *p; + uint8_t *a; + int r; + + assert(m); + assert(c); + + if (!BUS_MESSAGE_IS_GVARIANT(m)) + return 0; + + p = strempty(c->signature); + while (*p != 0) { + size_t n; + + r = signature_element_length(p, &n); + if (r < 0) + return r; + else { + char t[n+1]; + + memcpy(t, p, n); + t[n] = 0; + + r = bus_gvariant_is_fixed_size(t); + if (r < 0) + return r; + } + + assert(i <= c->n_offsets); + + /* We need to add an offset for each item that has a + * variable size and that is not the last one in the + * list */ + if (r == 0 && p[n] != 0) + n_variable++; + + i++; + p += n; + } + + assert(i == c->n_offsets); + + if (n_variable <= 0) { + a = message_extend_body(m, 1, 0, add_offset); + if (!a) + return -ENOMEM; + } else { + size_t sz; + unsigned j; + + assert(c->offsets[c->n_offsets-1] == m->header->body_size); + + sz = determine_word_size(m->header->body_size - c->begin, n_variable); + + a = message_extend_body(m, 1, sz * n_variable, add_offset); + if (!a) + return -ENOMEM; + + p = strempty(c->signature); + for (i = 0, j = 0; i < c->n_offsets; i++) { + unsigned k; + size_t n; + + r = signature_element_length(p, &n); + if (r < 0) + return r; + else { + char t[n+1]; + + memcpy(t, p, n); + t[n] = 0; + + p += n; + + r = bus_gvariant_is_fixed_size(t); + if (r < 0) + return r; + if (r > 0 || p[0] == 0) + continue; + } + + k = n_variable - 1 - j; + + write_word_le(a + k * sz, sz, c->offsets[i] - c->begin); + + j++; + } + } + + return 0; +} + +_public_ int sd_bus_message_close_container(sd_bus_message *m) { + struct bus_container *c; + int r; + + assert_return(m, -EINVAL); + assert_return(!m->sealed, -EPERM); + assert_return(m->n_containers > 0, -EINVAL); + assert_return(!m->poisoned, -ESTALE); + + c = message_get_container(m); + + if (c->enclosing != SD_BUS_TYPE_ARRAY) + if (c->signature && c->signature[c->index] != 0) + return -EINVAL; + + m->n_containers--; + + if (c->enclosing == SD_BUS_TYPE_ARRAY) + r = bus_message_close_array(m, c); + else if (c->enclosing == SD_BUS_TYPE_VARIANT) + r = bus_message_close_variant(m, c); + else if (c->enclosing == SD_BUS_TYPE_STRUCT || c->enclosing == SD_BUS_TYPE_DICT_ENTRY) + r = bus_message_close_struct(m, c, true); + else + assert_not_reached("Unknown container type"); + + free(c->signature); + free(c->offsets); + + return r; +} + +typedef struct { + const char *types; + unsigned n_struct; + unsigned n_array; +} TypeStack; + +static int type_stack_push(TypeStack *stack, unsigned max, unsigned *i, const char *types, unsigned n_struct, unsigned n_array) { + assert(stack); + assert(max > 0); + + 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(TypeStack *stack, unsigned max, unsigned *i, const char **types, unsigned *n_struct, unsigned *n_array) { + assert(stack); + assert(max > 0); + assert(types); + assert(n_struct); + assert(n_array); + + if (*i <= 0) + return 0; + + (*i)--; + *types = stack[*i].types; + *n_struct = stack[*i].n_struct; + *n_array = stack[*i].n_array; + + return 1; +} + +int bus_message_append_ap( + sd_bus_message *m, + const char *types, + va_list ap) { + + unsigned n_array, n_struct; + TypeStack stack[BUS_CONTAINER_DEPTH]; + unsigned stack_ptr = 0; + int r; + + assert(m); + + if (!types) + return 0; + + n_array = (unsigned) -1; + n_struct = strlen(types); + + for (;;) { + const char *t; + + if (n_array == 0 || (n_array == (unsigned) -1 && 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 != (unsigned) -1) + 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: + case SD_BUS_TYPE_DOUBLE: { + uint64_t x; + + x = va_arg(ap, uint64_t); + 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 == (unsigned) -1) { + 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_open_container(m, SD_BUS_TYPE_VARIANT, s); + if (r < 0) + return r; + + r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array); + if (r < 0) + return r; + + types = s; + n_struct = strlen(s); + n_array = (unsigned) -1; + + 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_open_container(m, *t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s); + if (r < 0) + return r; + } + + if (n_array == (unsigned) -1) { + 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 = (unsigned) -1; + + break; + } + + default: + r = -EINVAL; + } + + if (r < 0) + return r; + } + + return 1; +} + +_public_ int sd_bus_message_append(sd_bus_message *m, const char *types, ...) { + va_list ap; + int r; + + assert_return(m, -EINVAL); + assert_return(types, -EINVAL); + assert_return(!m->sealed, -EPERM); + assert_return(!m->poisoned, -ESTALE); + + va_start(ap, types); + r = bus_message_append_ap(m, types, ap); + va_end(ap); + + return r; +} + +_public_ int sd_bus_message_append_array_space( + sd_bus_message *m, + char type, + size_t size, + void **ptr) { + + ssize_t align, sz; + void *a; + int r; + + assert_return(m, -EINVAL); + assert_return(!m->sealed, -EPERM); + assert_return(bus_type_is_trivial(type) && type != SD_BUS_TYPE_BOOLEAN, -EINVAL); + assert_return(ptr || size == 0, -EINVAL); + assert_return(!m->poisoned, -ESTALE); + + /* alignment and size of the trivial types (except bool) is + * identical for gvariant and dbus1 marshalling */ + align = bus_type_get_alignment(type); + sz = bus_type_get_size(type); + + assert_se(align > 0); + assert_se(sz > 0); + + if (size % sz != 0) + return -EINVAL; + + r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type)); + if (r < 0) + return r; + + a = message_extend_body(m, align, size, false); + if (!a) + return -ENOMEM; + + r = sd_bus_message_close_container(m); + if (r < 0) + return r; + + *ptr = a; + return 0; +} + +_public_ int sd_bus_message_append_array(sd_bus_message *m, + char type, + const void *ptr, + size_t size) { + int r; + void *p; + + assert_return(m, -EINVAL); + assert_return(!m->sealed, -EPERM); + assert_return(bus_type_is_trivial(type), -EINVAL); + assert_return(ptr || size == 0, -EINVAL); + assert_return(!m->poisoned, -ESTALE); + + r = sd_bus_message_append_array_space(m, type, size, &p); + if (r < 0) + return r; + + if (size > 0) + memcpy(p, ptr, size); + + return 0; +} + +_public_ int sd_bus_message_append_array_iovec( + sd_bus_message *m, + char type, + const struct iovec *iov, + unsigned n) { + + size_t size; + unsigned i; + void *p; + int r; + + assert_return(m, -EINVAL); + assert_return(!m->sealed, -EPERM); + assert_return(bus_type_is_trivial(type), -EINVAL); + assert_return(iov || n == 0, -EINVAL); + assert_return(!m->poisoned, -ESTALE); + + size = IOVEC_TOTAL_SIZE(iov, n); + + r = sd_bus_message_append_array_space(m, type, size, &p); + if (r < 0) + return r; + + for (i = 0; i < n; i++) { + + if (iov[i].iov_base) + memcpy(p, iov[i].iov_base, iov[i].iov_len); + else + memset(p, 0, iov[i].iov_len); + + p = (uint8_t*) p + iov[i].iov_len; + } + + return 0; +} + +_public_ int sd_bus_message_append_array_memfd(sd_bus_message *m, + char type, + sd_memfd *memfd) { + _cleanup_close_ int copy_fd = -1; + struct bus_body_part *part; + ssize_t align, sz; + uint64_t size; + void *a; + int r; + + if (!m) + return -EINVAL; + if (!memfd) + return -EINVAL; + if (m->sealed) + return -EPERM; + if (!bus_type_is_trivial(type)) + return -EINVAL; + if (m->poisoned) + return -ESTALE; + + r = sd_memfd_set_sealed(memfd, true); + if (r < 0) + return r; + + copy_fd = sd_memfd_dup_fd(memfd); + if (copy_fd < 0) + return copy_fd; + + r = sd_memfd_get_size(memfd, &size); + if (r < 0) + return r; + + align = bus_type_get_alignment(type); + sz = bus_type_get_size(type); + + assert_se(align > 0); + assert_se(sz > 0); + + if (size % sz != 0) + return -EINVAL; + + if (size > (uint64_t) (uint32_t) -1) + return -EINVAL; + + r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type)); + if (r < 0) + return r; + + a = message_extend_body(m, align, 0, false); + if (!a) + return -ENOMEM; + + part = message_append_part(m); + if (!part) + return -ENOMEM; + + part->memfd = copy_fd; + part->sealed = true; + part->size = size; + copy_fd = -1; + + m->header->body_size += size; + message_extend_containers(m, size); + + return sd_bus_message_close_container(m); +} + +_public_ int sd_bus_message_append_string_memfd(sd_bus_message *m, sd_memfd *memfd) { + _cleanup_close_ int copy_fd = -1; + struct bus_body_part *part; + struct bus_container *c; + uint64_t size; + void *a; + int r; + + assert_return(m, -EINVAL); + assert_return(memfd, -EINVAL); + assert_return(!m->sealed, -EPERM); + assert_return(!m->poisoned, -ESTALE); + + r = sd_memfd_set_sealed(memfd, true); + if (r < 0) + return r; + + copy_fd = sd_memfd_dup_fd(memfd); + if (copy_fd < 0) + return copy_fd; + + r = sd_memfd_get_size(memfd, &size); + if (r < 0) + return r; + + /* We require this to be NUL terminated */ + if (size == 0) + return -EINVAL; + + if (size > (uint64_t) (uint32_t) -1) + return -EINVAL; + + c = message_get_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), NULL); + if (!e) { + m->poisoned = true; + return -ENOMEM; + } + } + + if (!BUS_MESSAGE_IS_GVARIANT(m)) { + a = message_extend_body(m, 4, 4, false); + if (!a) + return -ENOMEM; + + *(uint32_t*) a = size - 1; + } + + part = message_append_part(m); + if (!part) + return -ENOMEM; + + part->memfd = copy_fd; + part->sealed = true; + part->size = size; + copy_fd = -1; + + m->header->body_size += size; + message_extend_containers(m, size); + + if (BUS_MESSAGE_IS_GVARIANT(m)) { + r = message_add_offset(m, m->header->body_size); + if (r < 0) { + m->poisoned = true; + return -ENOMEM; + } + } + + if (c->enclosing != SD_BUS_TYPE_ARRAY) + c->index++; + + return 0; +} + +_public_ int sd_bus_message_append_strv(sd_bus_message *m, char **l) { + char **i; + int r; + + assert_return(m, -EINVAL); + assert_return(!m->sealed, -EPERM); + assert_return(!m->poisoned, -ESTALE); + + r = sd_bus_message_open_container(m, 'a', "s"); + if (r < 0) + return r; + + STRV_FOREACH(i, l) { + r = sd_bus_message_append_basic(m, 's', *i); + if (r < 0) + return r; + } + + return sd_bus_message_close_container(m); +} + +static int bus_message_close_header(sd_bus_message *m) { + uint8_t *a; + size_t sz, i; + + assert(m); + + if (!BUS_MESSAGE_IS_GVARIANT(m)) + return 0; + + if (m->n_header_offsets < 1) + return 0; + + assert(m->header->fields_size == m->header_offsets[m->n_header_offsets-1]); + + sz = determine_word_size(m->header->fields_size, m->n_header_offsets); + + a = message_extend_fields(m, 1, sz * m->n_header_offsets, false); + if (!a) + return -ENOMEM; + + for (i = 0; i < m->n_header_offsets; i++) + write_word_le(a + sz*i, sz, m->header_offsets[i]); + + return 0; +} + +int bus_message_seal(sd_bus_message *m, uint64_t serial) { + struct bus_body_part *part; + size_t l, a; + unsigned i; + int r; + + assert(m); + + if (m->sealed) + return -EPERM; + + if (m->n_containers > 0) + return -EBADMSG; + + if (m->poisoned) + return -ESTALE; + + /* In vtables the return signature of method calls is listed, + * let's check if they match if this is a response */ + if (m->header->type == SD_BUS_MESSAGE_METHOD_RETURN && + m->enforced_reply_signature && + !streq(strempty(m->root_container.signature), m->enforced_reply_signature)) + return -ENOMSG; + + /* If gvariant marshalling is used we need to close the body structure */ + r = bus_message_close_struct(m, &m->root_container, false); + if (r < 0) + return r; + + /* If there's a non-trivial signature set, then add it in here */ + if (!isempty(m->root_container.signature)) { + r = message_append_field_signature(m, BUS_MESSAGE_HEADER_SIGNATURE, m->root_container.signature, NULL); + if (r < 0) + return r; + } + + if (m->n_fds > 0) { + r = message_append_field_uint32(m, BUS_MESSAGE_HEADER_UNIX_FDS, m->n_fds); + if (r < 0) + return r; + } + + r = bus_message_close_header(m); + if (r < 0) + return r; + + m->header->serial = serial; + + /* Add padding at the end of the fields part, since we know + * the body needs to start at an 8 byte alignment. We made + * sure we allocated enough space for this, so all we need to + * do here is to zero it out. */ + l = BUS_MESSAGE_FIELDS_SIZE(m); + a = ALIGN8(l) - l; + if (a > 0) + memset((uint8_t*) BUS_MESSAGE_FIELDS(m) + l, 0, a); + + /* If this is something we can send as memfd, then let's seal + the memfd now. Note that we can send memfds as payload only + for directed messages, and not for broadcasts. */ + if (m->destination && m->bus && m->bus->use_memfd) { + MESSAGE_FOREACH_PART(part, i, m) + if (part->memfd >= 0 && !part->sealed && (part->size > MEMFD_MIN_SIZE || m->bus->use_memfd < 0)) { + bus_body_part_unmap(part); + + if (ioctl(part->memfd, KDBUS_CMD_MEMFD_SEAL_SET, 1) >= 0) + part->sealed = true; + } + } + + m->root_container.end = BUS_MESSAGE_BODY_SIZE(m); + m->root_container.index = 0; + m->root_container.offset_index = 0; + m->root_container.item_size = m->root_container.n_offsets > 0 ? m->root_container.offsets[0] : 0; + + m->sealed = true; + + return 0; +} + +int bus_body_part_map(struct bus_body_part *part) { + void *p; + size_t psz; + + assert_se(part); + + if (part->data) + return 0; + + if (part->size <= 0) + return 0; + + /* For smaller zero parts (as used for padding) we don't need to map anything... */ + if (part->memfd < 0 && part->is_zero && part->size < 8) { + static const uint8_t zeroes[7] = { }; + part->data = (void*) zeroes; + return 0; + } + + psz = PAGE_ALIGN(part->size); + + if (part->memfd >= 0) + p = mmap(NULL, psz, PROT_READ, MAP_SHARED, part->memfd, 0); + else if (part->is_zero) + p = mmap(NULL, psz, PROT_READ, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); + else + return -EINVAL; + + if (p == MAP_FAILED) + return -errno; + + part->mapped = psz; + part->data = p; + part->munmap_this = true; + + return 0; +} + +void bus_body_part_unmap(struct bus_body_part *part) { + + assert_se(part); + + if (part->memfd < 0) + return; + + if (!part->data) + return; + + if (!part->munmap_this) + return; + + assert_se(munmap(part->data, part->mapped) == 0); + + part->data = NULL; + part->mapped = 0; + part->munmap_this = false; + + return; +} + +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, end; + + assert(rindex); + assert(align > 0); + + start = ALIGN_TO((size_t) *rindex, align); + end = start + nbytes; + + if (end > 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 = end; + + return 1; +} + +static bool message_end_of_signature(sd_bus_message *m) { + struct bus_container *c; + + assert(m); + + c = message_get_container(m); + return !c->signature || c->signature[c->index] == 0; +} + +static bool message_end_of_array(sd_bus_message *m, size_t index) { + struct bus_container *c; + + assert(m); + + c = message_get_container(m); + if (c->enclosing != SD_BUS_TYPE_ARRAY) + return false; + + if (BUS_MESSAGE_IS_GVARIANT(m)) + return index >= c->end; + else { + assert(c->array_size); + return index >= c->begin + BUS_MESSAGE_BSWAP32(m, *c->array_size); + } +} + +_public_ int sd_bus_message_at_end(sd_bus_message *m, int complete) { + assert_return(m, -EINVAL); + assert_return(m->sealed, -EPERM); + + if (complete && m->n_containers > 0) + return false; + + if (message_end_of_signature(m)) + return true; + + if (message_end_of_array(m, m->rindex)) + return true; + + return false; +} + +static struct bus_body_part* find_part(sd_bus_message *m, size_t index, size_t sz, void **p) { + struct bus_body_part *part; + size_t begin; + int r; + + assert(m); + + if (m->cached_rindex_part && index >= m->cached_rindex_part_begin) { + part = m->cached_rindex_part; + begin = m->cached_rindex_part_begin; + } else { + part = &m->body; + begin = 0; + } + + while (part) { + if (index < begin) + return NULL; + + if (index + sz <= begin + part->size) { + + r = bus_body_part_map(part); + if (r < 0) + return NULL; + + if (p) + *p = (uint8_t*) part->data + index - begin; + + m->cached_rindex_part = part; + m->cached_rindex_part_begin = begin; + + return part; + } + + begin += part->size; + part = part->next; + } + + return NULL; +} + +static int container_next_item(sd_bus_message *m, struct bus_container *c, size_t *rindex) { + int r; + + assert(m); + assert(c); + assert(rindex); + + if (!BUS_MESSAGE_IS_GVARIANT(m)) + return 0; + + if (c->enclosing == SD_BUS_TYPE_ARRAY) { + int sz; + + sz = bus_gvariant_get_size(c->signature); + if (sz < 0) { + int alignment; + + if (c->offset_index+1 >= c->n_offsets) + goto end; + + /* Variable-size array */ + + alignment = bus_gvariant_get_alignment(c->signature); + assert(alignment > 0); + + *rindex = ALIGN_TO(c->offsets[c->offset_index], alignment); + c->item_size = c->offsets[c->offset_index+1] - *rindex; + } else { + + if (c->offset_index+1 >= (c->end-c->begin)/sz) + goto end; + + /* Fixed-size array */ + *rindex = c->begin + (c->offset_index+1) * sz; + c->item_size = sz; + } + + c->offset_index++; + + } else if (c->enclosing == 0 || + c->enclosing == SD_BUS_TYPE_STRUCT || + c->enclosing == SD_BUS_TYPE_DICT_ENTRY) { + + int alignment; + size_t n, j; + + if (c->offset_index+1 >= c->n_offsets) + goto end; + + r = signature_element_length(c->signature + c->index, &n); + if (r < 0) + return r; + + r = signature_element_length(c->signature + c->index + n, &j); + if (r < 0) + return r; + else { + char t[j+1]; + memcpy(t, c->signature + c->index + n, j); + t[j] = 0; + + alignment = bus_gvariant_get_alignment(t); + } + + assert(alignment > 0); + + *rindex = ALIGN_TO(c->offsets[c->offset_index], alignment); + c->item_size = c->offsets[c->offset_index+1] - *rindex; + + c->offset_index++; + + } else if (c->enclosing == SD_BUS_TYPE_VARIANT) + goto end; + else + assert_not_reached("Unknown container type"); + + return 0; + +end: + /* Reached the end */ + *rindex = c->end; + c->item_size = 0; + return 0; +} + + +static int message_peek_body( + sd_bus_message *m, + size_t *rindex, + size_t align, + size_t nbytes, + void **ret) { + + size_t k, start, end, padding; + struct bus_body_part *part; + uint8_t *q; + + assert(m); + assert(rindex); + assert(align > 0); + + start = ALIGN_TO((size_t) *rindex, align); + padding = start - *rindex; + end = start + nbytes; + + if (end > BUS_MESSAGE_BODY_SIZE(m)) + return -EBADMSG; + + part = find_part(m, *rindex, padding, (void**) &q); + if (!part) + return -EBADMSG; + + if (q) { + /* Verify padding */ + for (k = 0; k < padding; k++) + if (q[k] != 0) + return -EBADMSG; + } + + part = find_part(m, start, nbytes, (void**) &q); + if (!part || (nbytes > 0 && !q)) + return -EBADMSG; + + *rindex = end; + + if (ret) + *ret = q; + + return 0; +} + +static bool validate_nul(const char *s, size_t l) { + + /* Check for NUL chars in the string */ + if (memchr(s, 0, l)) + return false; + + /* Check for NUL termination */ + if (s[l] != 0) + return false; + + return true; +} + +static bool validate_string(const char *s, size_t l) { + + if (!validate_nul(s, l)) + return false; + + /* Check if valid UTF8 */ + if (!utf8_is_valid(s)) + return false; + + return true; +} + +static bool validate_signature(const char *s, size_t l) { + + if (!validate_nul(s, l)) + return false; - return 0; + /* Check if valid signature */ + if (!signature_is_valid(s, true)) + return false; + + return true; } -static int type_stack_pop(TypeStack *stack, unsigned max, unsigned *i, const char **types, unsigned *n_struct, unsigned *n_array) { - assert(stack); - assert(max > 0); - assert(types); - assert(n_struct); - assert(n_array); +static bool validate_object_path(const char *s, size_t l) { - if (*i <= 0) - return 0; + if (!validate_nul(s, l)) + return false; - (*i)--; - *types = stack[*i].types; - *n_struct = stack[*i].n_struct; - *n_array = stack[*i].n_array; + if (!object_path_is_valid(s)) + return false; - return 1; + return true; } -int bus_message_append_ap( - sd_bus_message *m, - const char *types, - va_list ap) { - - unsigned n_array, n_struct; - TypeStack stack[BUS_CONTAINER_DEPTH]; - unsigned stack_ptr = 0; +_public_ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) { + struct bus_container *c; + size_t rindex; + void *q; int r; - assert(m); + assert_return(m, -EINVAL); + assert_return(m->sealed, -EPERM); + assert_return(bus_type_is_basic(type), -EINVAL); - if (!types) + if (message_end_of_signature(m)) + return -ENXIO; + + if (message_end_of_array(m, m->rindex)) return 0; - n_array = (unsigned) -1; - n_struct = strlen(types); + c = message_get_container(m); + if (c->signature[c->index] != type) + return -ENXIO; - for (;;) { - const char *t; + rindex = m->rindex; - if (n_array == 0 || (n_array == (unsigned) -1 && 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; + if (BUS_MESSAGE_IS_GVARIANT(m)) { - r = sd_bus_message_close_container(m); + if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE)) { + bool ok; + + r = message_peek_body(m, &rindex, 1, c->item_size, &q); if (r < 0) return r; - continue; - } - - t = types; - if (n_array != (unsigned) -1) - n_array --; - else { - types ++; - n_struct--; - } - - switch (*t) { + if (type == SD_BUS_TYPE_STRING) + ok = validate_string(q, c->item_size-1); + else if (type == SD_BUS_TYPE_OBJECT_PATH) + ok = validate_object_path(q, c->item_size-1); + else + ok = validate_signature(q, c->item_size-1); - case SD_BUS_TYPE_BYTE: { - uint8_t x; + if (!ok) + return -EBADMSG; - x = (uint8_t) va_arg(ap, int); - r = sd_bus_message_append_basic(m, *t, &x); - break; - } + if (p) + *(const char**) p = q; + } else { + int sz, align; - case SD_BUS_TYPE_BOOLEAN: - case SD_BUS_TYPE_INT32: - case SD_BUS_TYPE_UINT32: - case SD_BUS_TYPE_UNIX_FD: { - uint32_t x; + sz = bus_gvariant_get_size(CHAR_TO_STR(type)); + assert(sz > 0); + if ((size_t) sz != c->item_size) + return -EBADMSG; - /* We assume a boolean is the same as int32_t */ - assert_cc(sizeof(int32_t) == sizeof(int)); + align = bus_gvariant_get_alignment(CHAR_TO_STR(type)); + assert(align > 0); - x = va_arg(ap, uint32_t); - r = sd_bus_message_append_basic(m, *t, &x); - break; - } + r = message_peek_body(m, &rindex, align, c->item_size, &q); + if (r < 0) + return r; - case SD_BUS_TYPE_INT16: - case SD_BUS_TYPE_UINT16: { - uint16_t x; + switch (type) { - x = (uint16_t) va_arg(ap, int); - r = sd_bus_message_append_basic(m, *t, &x); - break; - } + case SD_BUS_TYPE_BYTE: + if (p) + *(uint8_t*) p = *(uint8_t*) q; + break; - case SD_BUS_TYPE_INT64: - case SD_BUS_TYPE_UINT64: - case SD_BUS_TYPE_DOUBLE: { - uint64_t x; + case SD_BUS_TYPE_BOOLEAN: + if (p) + *(int*) p = !!*(uint8_t*) q; + break; - x = va_arg(ap, uint64_t); - r = sd_bus_message_append_basic(m, *t, &x); - break; - } + case SD_BUS_TYPE_INT16: + case SD_BUS_TYPE_UINT16: + if (p) + *(uint16_t*) p = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q); + break; - case SD_BUS_TYPE_STRING: - case SD_BUS_TYPE_OBJECT_PATH: - case SD_BUS_TYPE_SIGNATURE: { - const char *x; + case SD_BUS_TYPE_INT32: + case SD_BUS_TYPE_UINT32: + if (p) + *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q); + break; - x = va_arg(ap, const char*); - r = sd_bus_message_append_basic(m, *t, x); - break; - } + case SD_BUS_TYPE_INT64: + case SD_BUS_TYPE_UINT64: + case SD_BUS_TYPE_DOUBLE: + if (p) + *(uint64_t*) p = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q); + break; - case SD_BUS_TYPE_ARRAY: { - size_t k; + case SD_BUS_TYPE_UNIX_FD: { + uint32_t j; - r = signature_element_length(t + 1, &k); - if (r < 0) - return r; + j = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q); + if (j >= m->n_fds) + return -EBADMSG; - { - char s[k + 1]; - memcpy(s, t + 1, k); - s[k] = 0; + if (p) + *(int*) p = m->fds[j]; - r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, s); - if (r < 0) - return r; + break; } - if (n_array == (unsigned) -1) { - types += k; - n_struct -= k; + default: + assert_not_reached("unexpected type"); } + } - r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array); + r = container_next_item(m, c, &rindex); + if (r < 0) + return r; + } else { + + rindex = m->rindex; + + if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH)) { + uint32_t l; + bool ok; + + r = message_peek_body(m, &rindex, 4, 4, &q); if (r < 0) return r; - types = t + 1; - n_struct = k; - n_array = va_arg(ap, unsigned); + l = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q); + r = message_peek_body(m, &rindex, 1, l+1, &q); + if (r < 0) + return r; - break; - } + if (type == SD_BUS_TYPE_OBJECT_PATH) + ok = validate_object_path(q, l); + else + ok = validate_string(q, l); + if (!ok) + return -EBADMSG; - case SD_BUS_TYPE_VARIANT: { - const char *s; + if (p) + *(const char**) p = q; - s = va_arg(ap, const char*); - if (!s) - return -EINVAL; + } else if (type == SD_BUS_TYPE_SIGNATURE) { + uint8_t l; - r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, s); + r = message_peek_body(m, &rindex, 1, 1, &q); if (r < 0) return r; - r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array); + l = *(uint8_t*) q; + r = message_peek_body(m, &rindex, 1, l+1, &q); if (r < 0) return r; - types = s; - n_struct = strlen(s); - n_array = (unsigned) -1; + if (!validate_signature(q, l)) + return -EBADMSG; - break; - } + if (p) + *(const char**) p = q; - case SD_BUS_TYPE_STRUCT_BEGIN: - case SD_BUS_TYPE_DICT_ENTRY_BEGIN: { - size_t k; + } else { + ssize_t sz, align; - r = signature_element_length(t, &k); + align = bus_type_get_alignment(type); + assert(align > 0); + + sz = bus_type_get_size(type); + assert(sz > 0); + + r = message_peek_body(m, &rindex, align, sz, &q); if (r < 0) return r; - { - char s[k - 1]; - - memcpy(s, t + 1, k - 2); - s[k - 2] = 0; + switch (type) { - r = sd_bus_message_open_container(m, *t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s); - if (r < 0) - return r; - } + case SD_BUS_TYPE_BYTE: + if (p) + *(uint8_t*) p = *(uint8_t*) q; + break; - if (n_array == (unsigned) -1) { - types += k - 1; - n_struct -= k - 1; - } + case SD_BUS_TYPE_BOOLEAN: + if (p) + *(int*) p = !!*(uint32_t*) q; + break; - r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array); - if (r < 0) - return r; + case SD_BUS_TYPE_INT16: + case SD_BUS_TYPE_UINT16: + if (p) + *(uint16_t*) p = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q); + break; - types = t + 1; - n_struct = k - 2; - n_array = (unsigned) -1; + case SD_BUS_TYPE_INT32: + case SD_BUS_TYPE_UINT32: + if (p) + *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q); + break; - break; - } + case SD_BUS_TYPE_INT64: + case SD_BUS_TYPE_UINT64: + case SD_BUS_TYPE_DOUBLE: + if (p) + *(uint64_t*) p = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q); + break; - default: - r = -EINVAL; - } + case SD_BUS_TYPE_UNIX_FD: { + uint32_t j; - if (r < 0) - return r; - } + j = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q); + if (j >= m->n_fds) + return -EBADMSG; - return 0; -} + if (p) + *(int*) p = m->fds[j]; + break; + } -int sd_bus_message_append(sd_bus_message *m, const char *types, ...) { - va_list ap; - int r; + default: + assert_not_reached("Unknown basic type..."); + } + } + } - if (!m) - return -EINVAL; - if (m->sealed) - return -EPERM; - if (!types) - return 0; + m->rindex = rindex; - va_start(ap, types); - r = bus_message_append_ap(m, types, ap); - va_end(ap); + if (c->enclosing != SD_BUS_TYPE_ARRAY) + c->index++; - return r; + return 1; } -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; +static int bus_message_enter_array( + sd_bus_message *m, + struct bus_container *c, + const char *contents, + uint32_t **array_size, + size_t *item_size, + size_t **offsets, + size_t *n_offsets) { - assert(rindex); - assert(align > 0); + size_t rindex; + void *q; + int r, alignment; - start = ALIGN_TO((size_t) *rindex, align); - n = start + nbytes; + assert(m); + assert(c); + assert(contents); + assert(array_size); + assert(item_size); + assert(offsets); + assert(n_offsets); - if (n > sz) - return -EBADMSG; + if (!signature_is_single(contents, true)) + return -EINVAL; - /* Verify that padding is 0 */ - for (k = *rindex; k < start; k++) - if (((const uint8_t*) p)[k] != 0) - return -EBADMSG; + if (!c->signature || c->signature[c->index] == 0) + return -ENXIO; - if (r) - *r = (uint8_t*) p + start; + if (c->signature[c->index] != SD_BUS_TYPE_ARRAY) + return -ENXIO; - *rindex = n; + if (!startswith(c->signature + c->index + 1, contents)) + return -ENXIO; - return 1; -} + rindex = m->rindex; -static bool message_end_of_array(sd_bus_message *m, size_t index) { - struct bus_container *c; + if (!BUS_MESSAGE_IS_GVARIANT(m)) { + /* dbus1 */ - assert(m); + r = message_peek_body(m, &rindex, 4, 4, &q); + if (r < 0) + return r; - c = message_get_container(m); - if (!c->array_size) - return false; + if (BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q) > BUS_ARRAY_MAX_SIZE) + return -EBADMSG; - return index >= c->begin + BUS_MESSAGE_BSWAP32(m, *c->array_size); -} + alignment = bus_type_get_alignment(contents[0]); + if (alignment < 0) + return alignment; -static int message_peek_body(sd_bus_message *m, size_t *rindex, size_t align, size_t nbytes, void **ret) { - assert(m); - assert(rindex); - assert(align > 0); + r = message_peek_body(m, &rindex, alignment, 0, NULL); + if (r < 0) + return r; - if (message_end_of_array(m, *rindex)) - return 0; + *array_size = (uint32_t*) q; - return buffer_peek(m->body, BUS_MESSAGE_BODY_SIZE(m), rindex, align, nbytes, ret); -} + } else if (c->item_size <= 0) { -static bool validate_nul(const char *s, size_t l) { + /* gvariant: empty array */ + *item_size = 0; + *offsets = NULL; + *n_offsets = 0; - /* Check for NUL chars in the string */ - if (memchr(s, 0, l)) - return false; + } else if (bus_gvariant_is_fixed_size(contents)) { - /* Check for NUL termination */ - if (s[l] != 0) - return false; + /* gvariant: fixed length array */ + *item_size = bus_gvariant_get_size(contents); + *offsets = NULL; + *n_offsets = 0; - return true; -} + } else { + size_t where, p = 0, framing, sz; + unsigned i; -static bool validate_string(const char *s, size_t l) { + /* gvariant: variable length array */ + sz = determine_word_size(c->item_size, 0); - if (!validate_nul(s, l)) - return false; + where = rindex + c->item_size - sz; + r = message_peek_body(m, &where, 1, sz, &q); + if (r < 0) + return r; - /* Check if valid UTF8 */ - if (!utf8_is_valid(s)) - return false; + framing = read_word_le(q, sz); + if (framing > c->item_size - sz) + return -EBADMSG; + if ((c->item_size - framing) % sz != 0) + return -EBADMSG; - return true; -} + *n_offsets = (c->item_size - framing) / sz; -static bool validate_signature(const char *s, size_t l) { + where = rindex + framing; + r = message_peek_body(m, &where, 1, *n_offsets * sz, &q); + if (r < 0) + return r; - if (!validate_nul(s, l)) - return false; + *offsets = new(size_t, *n_offsets); + if (!*offsets) + return -ENOMEM; - /* Check if valid signature */ - if (!signature_is_valid(s, true)) - return false; + for (i = 0; i < *n_offsets; i++) { + size_t x; - return true; -} + x = read_word_le((uint8_t*) q + i * sz, sz); + if (x > c->item_size - sz) + return -EBADMSG; + if (x < p) + return -EBADMSG; -static bool validate_object_path(const char *s, size_t l) { + (*offsets)[i] = rindex + x; + p = x; + } - if (!validate_nul(s, l)) - return false; + *item_size = (*offsets)[0] - rindex; + } - if (!object_path_is_valid(s)) - return false; + m->rindex = rindex; - return true; + if (c->enclosing != SD_BUS_TYPE_ARRAY) + c->index += 1 + strlen(contents); + + return 1; } -int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) { - struct bus_container *c; - int r; +static int bus_message_enter_variant( + sd_bus_message *m, + struct bus_container *c, + const char *contents, + size_t *item_size) { + + size_t rindex; + uint8_t l; void *q; + int r; - if (!m) - return -EINVAL; - if (!m->sealed) - return -EPERM; - if (!bus_type_is_basic(type)) - return -EINVAL; - if (!p) + assert(m); + assert(c); + assert(contents); + assert(item_size); + + if (!signature_is_single(contents, false)) return -EINVAL; - c = message_get_container(m); + if (*contents == SD_BUS_TYPE_DICT_ENTRY_BEGIN) + return -EINVAL; if (!c->signature || c->signature[c->index] == 0) - return 0; + return -ENXIO; - if (c->signature[c->index] != type) + if (c->signature[c->index] != SD_BUS_TYPE_VARIANT) return -ENXIO; - switch (type) { + rindex = m->rindex; - case SD_BUS_TYPE_STRING: - case SD_BUS_TYPE_OBJECT_PATH: { - uint32_t l; - size_t rindex; + if (BUS_MESSAGE_IS_GVARIANT(m)) { + size_t k, where; - rindex = m->rindex; - r = message_peek_body(m, &rindex, 4, 4, &q); - if (r <= 0) - return r; + k = strlen(contents); + if (1+k > c->item_size) + return -EBADMSG; - l = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q); - r = message_peek_body(m, &rindex, 1, l+1, &q); + where = rindex + c->item_size - (1+k); + r = message_peek_body(m, &where, 1, 1+k, &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; - } + if (*(char*) q != 0) + return -EBADMSG; - m->rindex = rindex; - *(const char**) p = q; - break; - } + if (memcmp((uint8_t*) q+1, contents, k)) + return -ENXIO; - case SD_BUS_TYPE_SIGNATURE: { - uint8_t l; - size_t rindex; + *item_size = c->item_size - (1+k); - rindex = m->rindex; + } else { r = message_peek_body(m, &rindex, 1, 1, &q); - if (r <= 0) + 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; + if (!streq(q, contents)) + return -ENXIO; } - 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; + m->rindex = rindex; - switch (type) { + if (c->enclosing != SD_BUS_TYPE_ARRAY) + c->index++; - case SD_BUS_TYPE_BYTE: - *(uint8_t*) p = *(uint8_t*) q; - break; + return 1; +} - case SD_BUS_TYPE_BOOLEAN: - *(int*) p = !!*(uint32_t*) q; - break; +static int build_struct_offsets( + sd_bus_message *m, + const char *signature, + size_t size, + size_t *item_size, + size_t **offsets, + size_t *n_offsets) { + + unsigned n_variable = 0, n_total = 0, v; + size_t previous = 0, where; + const char *p; + size_t sz; + void *q; + int r; - case SD_BUS_TYPE_INT16: - case SD_BUS_TYPE_UINT16: - *(uint16_t*) p = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q); - break; + assert(m); + assert(item_size); + assert(offsets); + assert(n_offsets); + + if (isempty(signature)) { + *item_size = 0; + *offsets = NULL; + *n_offsets = 0; + return 0; + } - case SD_BUS_TYPE_INT32: - case SD_BUS_TYPE_UINT32: - *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q); - break; + sz = determine_word_size(size, 0); + if (sz <= 0) + return -EBADMSG; - 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; + /* First, loop over signature and count variable elements and + * elements in general. We use this to know how large the + * offset array is at the end of the structure. Note that + * GVariant only stores offsets for all variable size elements + * that are not the last item. */ - case SD_BUS_TYPE_UNIX_FD: { - uint32_t j; + p = signature; + while (*p != 0) { + size_t n; - j = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q); - if (j >= m->n_fds) - return -EBADMSG; + r = signature_element_length(p, &n); + if (r < 0) + return r; + else { + char t[n+1]; - *(int*) p = m->fds[j]; - break; - } + memcpy(t, p, n); + t[n] = 0; - default: - assert_not_reached("Unknown basic type..."); + r = bus_gvariant_is_fixed_size(t); } - m->rindex = rindex; + if (r < 0) + return r; + if (r == 0 && p[n] != 0) /* except the last item */ + n_variable ++; + n_total++; - break; - } + p += n; } - if (c->enclosing != SD_BUS_TYPE_ARRAY) - c->index++; + if (size < n_variable * sz) + return -EBADMSG; - return 1; -} + where = m->rindex + size - (n_variable * sz); + r = message_peek_body(m, &where, 1, n_variable * sz, &q); + if (r < 0) + return r; -static int bus_message_enter_array( - sd_bus_message *m, - struct bus_container *c, - const char *contents, - uint32_t **array_size) { + v = n_variable; - size_t rindex; - void *q; - int r, alignment; + *offsets = new(size_t, n_total); + if (!*offsets) + return -ENOMEM; - assert(m); - assert(c); - assert(contents); - assert(array_size); + *n_offsets = 0; - if (!signature_is_single(contents)) - return -EINVAL; + /* Second, loop again and build an offset table */ + p = signature; + while (*p != 0) { + size_t n, offset; + int k; - alignment = bus_type_get_alignment(contents[0]); - if (alignment < 0) - return alignment; + r = signature_element_length(p, &n); + if (r < 0) + return r; + else { + char t[n+1]; - if (!c->signature || c->signature[c->index] == 0) - return 0; + memcpy(t, p, n); + t[n] = 0; - if (c->signature[c->index] != SD_BUS_TYPE_ARRAY) - return -ENXIO; + k = bus_gvariant_get_size(t); + if (k < 0) { + size_t x; - if (!startswith(c->signature + c->index + 1, contents)) - return -ENXIO; + /* variable size */ + if (v > 0) { + v--; - rindex = m->rindex; - r = message_peek_body(m, &rindex, 4, 4, &q); - if (r <= 0) - return r; + x = read_word_le((uint8_t*) q + v*sz, sz); + if (x >= size) + return -EBADMSG; + if (m->rindex + x < previous) + return -EBADMSG; + } else + /* The last item's end + * is determined from + * the start of the + * offset array */ + x = size - (n_variable * sz); - if (BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q) > BUS_ARRAY_MAX_SIZE) - return -EBADMSG; + offset = m->rindex + x; - r = message_peek_body(m, &rindex, alignment, 0, NULL); - if (r < 0) - return r; - if (r == 0) - return -EBADMSG; + } else { + size_t align; - if (c->enclosing != SD_BUS_TYPE_ARRAY) - c->index += 1 + strlen(contents); + /* fixed size */ + align = bus_gvariant_get_alignment(t); + assert(align > 0); - m->rindex = rindex; + offset = (*n_offsets == 0 ? m->rindex : ALIGN_TO((*offsets)[*n_offsets-1], align)) + k; + } + } + + previous = (*offsets)[(*n_offsets)++] = offset; + p += n; + } - *array_size = (uint32_t*) q; + assert(v == 0); + assert(*n_offsets == n_total); - return 1; + *item_size = (*offsets)[0] - m->rindex; + return 0; } -static int bus_message_enter_variant( +static int enter_struct_or_dict_entry( sd_bus_message *m, struct bus_container *c, - const char *contents) { + const char *contents, + size_t *item_size, + size_t **offsets, + size_t *n_offsets) { - size_t rindex; - uint8_t l; - void *q; int r; assert(m); assert(c); assert(contents); + assert(item_size); + assert(offsets); + assert(n_offsets); - 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 (!BUS_MESSAGE_IS_GVARIANT(m)) { - if (!streq(q, contents)) - return -ENXIO; + /* dbus1 */ + r = message_peek_body(m, &m->rindex, 8, 0, NULL); + if (r < 0) + return r; - if (c->enclosing != SD_BUS_TYPE_ARRAY) - c->index++; + } else if (c->item_size <= 0) { - m->rindex = rindex; + /* gvariant empty struct */ + *item_size = 0; + *offsets = NULL; + *n_offsets = 0; + } else + /* gvariant with contents */ + return build_struct_offsets(m, contents, c->item_size, item_size, offsets, n_offsets); - return 1; + return 0; } static int bus_message_enter_struct( sd_bus_message *m, struct bus_container *c, - const char *contents) { + const char *contents, + size_t *item_size, + size_t **offsets, + size_t *n_offsets) { size_t l; int r; @@ -1853,12 +3724,15 @@ static int bus_message_enter_struct( assert(m); assert(c); assert(contents); + assert(item_size); + assert(offsets); + assert(n_offsets); if (!signature_is_valid(contents, false)) return -EINVAL; if (!c->signature || c->signature[c->index] == 0) - return 0; + return -ENXIO; l = strlen(contents); @@ -1867,8 +3741,8 @@ static int bus_message_enter_struct( 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) + r = enter_struct_or_dict_entry(m, c, contents, item_size, offsets, n_offsets); + if (r < 0) return r; if (c->enclosing != SD_BUS_TYPE_ARRAY) @@ -1880,7 +3754,10 @@ static int bus_message_enter_struct( static int bus_message_enter_dict_entry( sd_bus_message *m, struct bus_container *c, - const char *contents) { + const char *contents, + size_t *item_size, + size_t **offsets, + size_t *n_offsets) { size_t l; int r; @@ -1905,8 +3782,8 @@ static int bus_message_enter_dict_entry( 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) + r = enter_struct_or_dict_entry(m, c, contents, item_size, offsets, n_offsets); + if (r < 0) return r; if (c->enclosing != SD_BUS_TYPE_ARRAY) @@ -1915,18 +3792,39 @@ static int bus_message_enter_dict_entry( return 1; } -int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *contents) { +_public_ 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; + size_t before; + size_t *offsets = NULL; + size_t n_offsets = 0, item_size = 0; int r; - if (!m) - return -EINVAL; - if (!m->sealed) - return -EPERM; - if (!contents) - return -EINVAL; + 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 @@ -1952,28 +3850,35 @@ int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *con return -ENOMEM; m->containers = w; - c = message_get_container(m); + if (message_end_of_signature(m)) + return -ENXIO; - if (!c->signature || c->signature[c->index] == 0) + if (message_end_of_array(m, m->rindex)) return 0; + c = message_get_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); + r = bus_message_enter_array(m, c, contents, &array_size, &item_size, &offsets, &n_offsets); else if (type == SD_BUS_TYPE_VARIANT) - r = bus_message_enter_variant(m, c, contents); + r = bus_message_enter_variant(m, c, contents, &item_size); else if (type == SD_BUS_TYPE_STRUCT) - r = bus_message_enter_struct(m, c, contents); + r = bus_message_enter_struct(m, c, contents, &item_size, &offsets, &n_offsets); else if (type == SD_BUS_TYPE_DICT_ENTRY) - r = bus_message_enter_dict_entry(m, c, contents); + r = bus_message_enter_dict_entry(m, c, contents, &item_size, &offsets, &n_offsets); else r = -EINVAL; if (r <= 0) { free(signature); + free(offsets); return r; } @@ -1982,58 +3887,102 @@ int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *con w->enclosing = type; w->signature = signature; w->index = 0; - w->array_size = array_size; + + w->before = before; w->begin = m->rindex; + w->end = m->rindex + c->item_size; + + w->array_size = array_size; + w->item_size = item_size; + w->offsets = offsets; + w->n_offsets = n_offsets; + w->offset_index = 0; return 1; } -int sd_bus_message_exit_container(sd_bus_message *m) { +_public_ int sd_bus_message_exit_container(sd_bus_message *m) { struct bus_container *c; + unsigned saved; + int r; - if (!m) - return -EINVAL; - if (!m->sealed) - return -EPERM; - if (m->n_containers <= 0) - return -EINVAL; + assert_return(m, -EINVAL); + assert_return(m->sealed, -EPERM); + assert_return(m->n_containers > 0, -ENXIO); c = message_get_container(m); - if (c->enclosing == SD_BUS_TYPE_ARRAY) { + + if (c->enclosing != SD_BUS_TYPE_ARRAY) { + if (c->signature && c->signature[c->index] != 0) + return -EBUSY; + } + + if (BUS_MESSAGE_IS_GVARIANT(m)) { + if (m->rindex < c->end) + return -EBUSY; + + } else 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); + free(c->offsets); m->n_containers--; + c = message_get_container(m); + + saved = c->index; + c->index = c->saved_index; + r = container_next_item(m, c, &m->rindex); + c->index = saved; + if (r < 0) + return r; + return 1; } -int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents) { +static void message_quit_container(sd_bus_message *m) { struct bus_container *c; - int r; - if (!m) - return -EINVAL; - if (!m->sealed) - return -EPERM; + assert(m); + assert(m->sealed); + assert(m->n_containers > 0); c = message_get_container(m); - if (!c->signature || c->signature[c->index] == 0) + /* Undo seeks */ + assert(m->rindex >= c->before); + m->rindex = c->before; + + /* Free container */ + free(c->signature); + free(c->offsets); + m->n_containers--; + + /* Correct index of new top-level container */ + c = message_get_container(m); + c->index = c->saved_index; +} + +_public_ int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents) { + struct bus_container *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_container(m); + if (bus_type_is_basic(c->signature[c->index])) { if (contents) *contents = NULL; @@ -2100,27 +4049,62 @@ int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **content 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; + if (BUS_MESSAGE_IS_GVARIANT(m)) { + size_t k; - 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 (c->item_size < 2) + return -EBADMSG; - if (!validate_signature(q, l)) - return -EBADMSG; + /* Look for the NUL delimiter that + separates the payload from the + signature. Since the body might be + in a different part that then the + signature we map byte by byte. */ + + for (k = 2; k <= c->item_size; k++) { + size_t where; + + where = m->rindex + c->item_size - k; + r = message_peek_body(m, &where, 1, k, &q); + if (r < 0) + return r; + + if (*(char*) q == 0) + break; + } + + if (k > c->item_size) + return -EBADMSG; + + free(m->peeked_signature); + m->peeked_signature = strndup((char*) q + 1, k - 1); + if (!m->peeked_signature) + return -ENOMEM; + + if (!signature_is_valid(m->peeked_signature, true)) + return -EBADMSG; + + *contents = m->peeked_signature; + } else { + size_t rindex, l; + + 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; - *contents = q; + if (!validate_signature(q, l)) + return -EBADMSG; + + *contents = q; + } } if (type) @@ -2133,35 +4117,37 @@ int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **content eof: if (type) - *type = c->enclosing; + *type = 0; if (contents) *contents = NULL; return 0; } -int sd_bus_message_rewind(sd_bus_message *m, int complete) { +_public_ int sd_bus_message_rewind(sd_bus_message *m, int complete) { struct bus_container *c; - if (!m) - return -EINVAL; - if (!m->sealed) - return -EPERM; + assert_return(m, -EINVAL); + assert_return(m->sealed, -EPERM); if (complete) { - reset_containers(m); + message_reset_containers(m); m->rindex = 0; - m->root_container.index = 0; c = message_get_container(m); } else { c = message_get_container(m); + c->offset_index = 0; c->index = 0; m->rindex = c->begin; } + c->offset_index = 0; + c->item_size = c->n_offsets > 0 ? c->offsets[0] : c->end; + return !isempty(c->signature); } + static int message_read_ap( sd_bus_message *m, const char *types, @@ -2170,11 +4156,12 @@ static int message_read_ap( unsigned n_array, n_struct; TypeStack stack[BUS_CONTAINER_DEPTH]; unsigned stack_ptr = 0; + unsigned n_loop = 0; int r; assert(m); - if (!types) + if (isempty(types)) return 0; /* Ideally, we'd just call ourselves recursively on every @@ -2184,12 +4171,14 @@ static int message_read_ap( * in a single stackframe. We hence implement our own * home-grown stack in an array. */ - n_array = (unsigned) -1; - n_struct = strlen(types); + n_array = (unsigned) -1; /* lenght 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 == (unsigned) -1 && n_struct == 0)) { r = type_stack_pop(stack, ELEMENTSOF(stack), &stack_ptr, &types, &n_struct, &n_array); if (r < 0) @@ -2233,8 +4222,12 @@ static int message_read_ap( r = sd_bus_message_read_basic(m, *t, p); if (r < 0) return r; - if (r == 0) + if (r == 0) { + if (n_loop <= 1) + return 0; + return -ENXIO; + } break; } @@ -2254,8 +4247,12 @@ static int message_read_ap( r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, s); if (r < 0) return r; - if (r == 0) + if (r == 0) { + if (n_loop <= 1) + return 0; + return -ENXIO; + } } if (n_array == (unsigned) -1) { @@ -2284,8 +4281,12 @@ static int message_read_ap( r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, s); if (r < 0) return r; - if (r == 0) + 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) @@ -2311,52 +4312,255 @@ static int message_read_ap( 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; - } + 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 == (unsigned) -1) { + 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 = (unsigned) -1; + + break; + } + + default: + return -EINVAL; + } + } + + return 1; +} + +_public_ int sd_bus_message_read(sd_bus_message *m, const char *types, ...) { + va_list ap; + int r; + + assert_return(m, -EINVAL); + assert_return(m->sealed, -EPERM); + assert_return(types, -EINVAL); + + va_start(ap, types); + r = message_read_ap(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); + assert_return(types, -EINVAL); + + if (isempty(types)) + return 0; + + switch (*types) { + + 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; + + { + 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; + assert(r != 0); + + 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 **ptr, + size_t *size) { + struct bus_container *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(ptr, -EINVAL); + assert_return(size, -EINVAL); + assert_return(!BUS_MESSAGE_NEED_BSWAP(m), -ENOTSUP); - if (n_array == (unsigned) -1) { - types += k - 1; - n_struct -= k - 1; - } + r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type)); + if (r <= 0) + return r; - r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array); - if (r < 0) - return r; + c = message_get_container(m); - types = t + 1; - n_struct = k - 2; - n_array = (unsigned) -1; + if (BUS_MESSAGE_IS_GVARIANT(m)) { + align = bus_gvariant_get_alignment(CHAR_TO_STR(type)); + if (align < 0) + return align; - break; - } + sz = c->end - c->begin; + } else { + align = bus_type_get_alignment(type); + if (align < 0) + return align; - default: - return -EINVAL; - } + sz = BUS_MESSAGE_BSWAP32(m, *c->array_size); } - return 1; -} + if (sz == 0) + /* Zero length array, let's return some aligned + * pointer that is not NULL */ + p = (uint8_t*) NULL + align; + else { + r = message_peek_body(m, &m->rindex, align, sz, &p); + if (r < 0) + goto fail; + } -int sd_bus_message_read(sd_bus_message *m, const char *types, ...) { - va_list ap; - int r; + r = sd_bus_message_exit_container(m); + if (r < 0) + goto fail; - if (!m) - return -EINVAL; - if (!m->sealed) - return -EPERM; - if (!types) - return -EINVAL; + *ptr = (const void*) p; + *size = sz; - va_start(ap, types); - r = message_read_ap(m, types, ap); - va_end(ap); + return 1; +fail: + message_quit_container(m); return r; } @@ -2371,12 +4575,13 @@ static int message_peek_fields( assert(rindex); assert(align > 0); - return buffer_peek(m->fields, BUS_MESSAGE_FIELDS_SIZE(m), rindex, align, nbytes, ret); + return buffer_peek(BUS_MESSAGE_FIELDS(m), BUS_MESSAGE_FIELDS_SIZE(m), rindex, align, nbytes, ret); } static int message_peek_field_uint32( sd_bus_message *m, size_t *ri, + size_t item_size, uint32_t *ret) { int r; @@ -2385,6 +4590,11 @@ static int message_peek_field_uint32( assert(m); assert(ri); + if (BUS_MESSAGE_IS_GVARIANT(m) && item_size != 4) + return -EBADMSG; + + /* identical for gvariant and dbus1 */ + r = message_peek_fields(m, ri, 4, 4, &q); if (r < 0) return r; @@ -2399,6 +4609,7 @@ 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; @@ -2408,13 +4619,25 @@ static int message_peek_field_string( assert(m); assert(ri); - r = message_peek_field_uint32(m, ri, &l); - if (r < 0) - return r; + if (BUS_MESSAGE_IS_GVARIANT(m)) { - r = message_peek_fields(m, ri, 1, l+1, &q); - if (r < 0) - return r; + if (item_size <= 0) + return -EBADMSG; + + r = message_peek_fields(m, ri, 1, item_size, &q); + if (r < 0) + return r; + + l = item_size - 1; + } else { + r = message_peek_field_uint32(m, ri, 4, &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)) @@ -2436,6 +4659,7 @@ static int message_peek_field_string( static int message_peek_field_signature( sd_bus_message *m, size_t *ri, + size_t item_size, const char **ret) { size_t l; @@ -2445,14 +4669,26 @@ static int message_peek_field_signature( assert(m); assert(ri); - r = message_peek_fields(m, ri, 1, 1, &q); - if (r < 0) - return r; + if (BUS_MESSAGE_IS_GVARIANT(m)) { - l = *(uint8_t*) q; - r = message_peek_fields(m, ri, 1, l+1, &q); - if (r < 0) - return r; + if (item_size <= 0) + return -EBADMSG; + + r = message_peek_fields(m, ri, 1, item_size, &q); + if (r < 0) + return r; + + l = item_size - 1; + } else { + 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; @@ -2475,6 +4711,7 @@ static int message_skip_fields( assert(m); assert(ri); assert(signature); + assert(!BUS_MESSAGE_IS_GVARIANT(m)); original_index = *ri; @@ -2492,7 +4729,7 @@ static int message_skip_fields( if (t == SD_BUS_TYPE_STRING) { - r = message_peek_field_string(m, NULL, ri, NULL); + r = message_peek_field_string(m, NULL, ri, 0, NULL); if (r < 0) return r; @@ -2500,7 +4737,7 @@ static int message_skip_fields( } else if (t == SD_BUS_TYPE_OBJECT_PATH) { - r = message_peek_field_string(m, object_path_is_valid, ri, NULL); + r = message_peek_field_string(m, object_path_is_valid, ri, 0, NULL); if (r < 0) return r; @@ -2508,7 +4745,7 @@ static int message_skip_fields( } else if (t == SD_BUS_TYPE_SIGNATURE) { - r = message_peek_field_signature(m, ri, NULL); + r = message_peek_field_signature(m, ri, 0, NULL); if (r < 0) return r; @@ -2546,7 +4783,7 @@ static int message_skip_fields( if (alignment < 0) return alignment; - r = message_peek_field_uint32(m, ri, &nas); + r = message_peek_field_uint32(m, ri, 0, &nas); if (r < 0) return r; if (nas > BUS_ARRAY_MAX_SIZE) @@ -2566,7 +4803,7 @@ static int message_skip_fields( } else if (t == SD_BUS_TYPE_VARIANT) { const char *s; - r = message_peek_field_signature(m, ri, &s); + r = message_peek_field_signature(m, ri, 0, &s); if (r < 0) return r; @@ -2600,464 +4837,322 @@ static int message_skip_fields( } } -static int message_parse_fields(sd_bus_message *m) { +int bus_message_parse_fields(sd_bus_message *m) { size_t ri; int r; uint32_t unix_fds = 0; + void *offsets = NULL; + unsigned n_offsets = 0; + size_t sz = 0; + unsigned i = 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; + if (BUS_MESSAGE_IS_GVARIANT(m)) { + void *q; - switch (*header) { - case _SD_BUS_MESSAGE_HEADER_INVALID: - return -EBADMSG; + sz = determine_word_size(BUS_MESSAGE_FIELDS_SIZE(m), 0); + if (sz > 0) { + size_t framing; - case SD_BUS_MESSAGE_HEADER_PATH: + ri = BUS_MESSAGE_FIELDS_SIZE(m) - sz; + r = message_peek_fields(m, &ri, 1, sz, &q); + if (r < 0) + return r; - if (m->path) + framing = read_word_le(q, sz); + if (framing >= BUS_MESSAGE_FIELDS_SIZE(m) - sz) return -EBADMSG; - - if (!streq(signature, "o")) + if ((BUS_MESSAGE_FIELDS_SIZE(m) - framing) % sz != 0) return -EBADMSG; - r = message_peek_field_string(m, object_path_is_valid, &ri, &m->path); - break; + ri = framing; + r = message_peek_fields(m, &ri, 1, BUS_MESSAGE_FIELDS_SIZE(m) - framing, &offsets); + if (r < 0) + return r; - case SD_BUS_MESSAGE_HEADER_INTERFACE: + n_offsets = (BUS_MESSAGE_FIELDS_SIZE(m) - framing) / sz; + } + } - if (m->interface) - return -EBADMSG; + ri = 0; + while (ri < BUS_MESSAGE_FIELDS_SIZE(m)) { + _cleanup_free_ char *sig = NULL; + const char *signature; + uint8_t *header; + size_t item_size = (size_t) -1; - if (!streq(signature, "s")) - return -EBADMSG; + if (BUS_MESSAGE_IS_GVARIANT(m)) { + if (i >= n_offsets) + break; - r = message_peek_field_string(m, interface_name_is_valid, &ri, &m->interface); - break; + if (i == 0) + ri = 0; + else + ri = ALIGN_TO(read_word_le((uint8_t*) offsets + (i-1)*sz, sz), 8); + } - case SD_BUS_MESSAGE_HEADER_MEMBER: + r = message_peek_fields(m, &ri, 8, 1, (void**) &header); + if (r < 0) + return r; - if (m->member) - return -EBADMSG; + if (BUS_MESSAGE_IS_GVARIANT(m)) { + size_t where, end; + char *b; + void *q; - if (!streq(signature, "s")) - return -EBADMSG; + end = read_word_le((uint8_t*) offsets + i*sz, sz); - r = message_peek_field_string(m, member_name_is_valid, &ri, &m->member); - break; + if (end < ri) + return -EBADMSG; - case SD_BUS_MESSAGE_HEADER_ERROR_NAME: + where = ri = ALIGN_TO(ri, 8); + item_size = end - ri; + r = message_peek_fields(m, &where, 1, item_size, &q); + if (r < 0) + return r; - if (m->error.name) + b = memrchr(q, 0, item_size); + if (!b) return -EBADMSG; - if (!streq(signature, "s")) - return -EBADMSG; + sig = strndup(b+1, item_size - (b+1-(char*) q)); + if (!sig) + return -ENOMEM; - r = message_peek_field_string(m, error_name_is_valid, &ri, &m->error.name); - break; + signature = sig; + item_size = b - (char*) q; + } else { + r = message_peek_field_signature(m, &ri, 0, &signature); + if (r < 0) + return r; + } + + switch (*header) { + case _BUS_MESSAGE_HEADER_INVALID: + return -EBADMSG; - case SD_BUS_MESSAGE_HEADER_DESTINATION: + case BUS_MESSAGE_HEADER_PATH: - if (m->destination) + if (m->path) return -EBADMSG; - if (!streq(signature, "s")) + if (!streq(signature, "o")) return -EBADMSG; - r = message_peek_field_string(m, service_name_is_valid, &ri, &m->destination); + r = message_peek_field_string(m, object_path_is_valid, &ri, item_size, &m->path); break; - case SD_BUS_MESSAGE_HEADER_SENDER: + case BUS_MESSAGE_HEADER_INTERFACE: - if (m->sender) + if (m->interface) return -EBADMSG; if (!streq(signature, "s")) return -EBADMSG; - r = message_peek_field_string(m, service_name_is_valid, &ri, &m->sender); + r = message_peek_field_string(m, interface_name_is_valid, &ri, item_size, &m->interface); break; + case BUS_MESSAGE_HEADER_MEMBER: - case SD_BUS_MESSAGE_HEADER_SIGNATURE: { - const char *s; - char *c; - - if (m->root_container.signature) + if (m->member) return -EBADMSG; - if (!streq(signature, "g")) + if (!streq(signature, "s")) 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; + r = message_peek_field_string(m, member_name_is_valid, &ri, item_size, &m->member); break; - } - case SD_BUS_MESSAGE_HEADER_REPLY_SERIAL: - if (m->reply_serial != 0) - return -EBADMSG; + case BUS_MESSAGE_HEADER_ERROR_NAME: - if (!streq(signature, "u")) + if (m->error.name) return -EBADMSG; - r = message_peek_field_uint32(m, &ri, &m->reply_serial); - if (r < 0) - return r; - - if (m->reply_serial == 0) + if (!streq(signature, "s")) return -EBADMSG; - break; + r = message_peek_field_string(m, error_name_is_valid, &ri, item_size, &m->error.name); + if (r >= 0) + m->error._need_free = -1; - case SD_BUS_MESSAGE_HEADER_UNIX_FDS: - if (unix_fds != 0) - return -EBADMSG; + break; - if (!streq(signature, "u")) - return -EBADMSG; + case BUS_MESSAGE_HEADER_DESTINATION: - r = message_peek_field_uint32(m, &ri, &unix_fds); - if (r < 0) + if (m->destination) return -EBADMSG; - if (unix_fds == 0) + if (!streq(signature, "s")) return -EBADMSG; + r = message_peek_field_string(m, service_name_is_valid, &ri, item_size, &m->destination); 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; -} - -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; - - 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); -} + case BUS_MESSAGE_HEADER_SENDER: -int bus_message_dump(sd_bus_message *m) { - unsigned level = 1; - int r; + if (m->sender) + return -EBADMSG; - assert(m); + if (!streq(signature, "s")) + return -EBADMSG; - 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 = message_peek_field_string(m, service_name_is_valid, &ri, item_size, &m->sender); - r = sd_bus_message_rewind(m, true); - if (r < 0) { - log_error("Failed to rewind: %s", strerror(-r)); - return r; - } + if (r >= 0 && m->sender[0] == ':' && m->bus && m->bus->bus_client && !m->bus->is_kernel) { + m->creds.unique_name = (char*) m->sender; + m->creds.mask |= SD_BUS_CREDS_UNIQUE_NAME & m->bus->creds_mask; + } - printf("BEGIN_MESSAGE \"%s\" {\n", strempty(m->root_container.signature)); + break; - 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; + case BUS_MESSAGE_HEADER_SIGNATURE: { + const char *s; + char *c; - r = sd_bus_message_exit_container(m); - if (r < 0) { - log_error("Failed to exit container: %s", strerror(-r)); - return r; - } + if (m->root_container.signature) + return -EBADMSG; - level--; + if (!streq(signature, "g")) + return -EBADMSG; - prefix = strrep("\t", level); - if (!prefix) - return log_oom(); + r = message_peek_field_signature(m, &ri, item_size, &s); + if (r < 0) + return r; - 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); + c = strdup(s); + if (!c) + return -ENOMEM; - continue; + free(m->root_container.signature); + m->root_container.signature = c; + break; } - prefix = strrep("\t", level); - if (!prefix) - return log_oom(); + case BUS_MESSAGE_HEADER_REPLY_SERIAL: + if (m->reply_serial != 0) + return -EBADMSG; + + if (!streq(signature, "u")) + return -EBADMSG; - 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)); + r = message_peek_field_uint32(m, &ri, item_size, &m->reply_serial); + if (r < 0) 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); + if (m->reply_serial == 0) + return -EBADMSG; - level ++; + break; - continue; - } + case BUS_MESSAGE_HEADER_UNIX_FDS: + if (unix_fds != 0) + return -EBADMSG; - r = sd_bus_message_read_basic(m, type, &basic); - if (r < 0) { - log_error("Failed to get basic: %s", strerror(-r)); - return r; - } + if (!streq(signature, "u")) + return -EBADMSG; - switch (type) { + r = message_peek_field_uint32(m, &ri, item_size, &unix_fds); + if (r < 0) + return -EBADMSG; - case SD_BUS_TYPE_BYTE: - printf("%sBYTE: %u\n", prefix, basic.u8); - break; + if (unix_fds == 0) + return -EBADMSG; - 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; + default: + if (!BUS_MESSAGE_IS_GVARIANT(m)) + r = message_skip_fields(m, &ri, (uint32_t) -1, (const char **) &signature); + } - case SD_BUS_TYPE_UINT16: - printf("%sUINT16: %u\n", prefix, basic.u16); - break; + if (r < 0) + return r; - case SD_BUS_TYPE_INT32: - printf("%sINT32: %i\n", prefix, basic.s32); - break; + i++; + } - case SD_BUS_TYPE_UINT32: - printf("%sUINT32: %u\n", prefix, basic.u32); - break; + if (m->n_fds != unix_fds) + return -EBADMSG; - case SD_BUS_TYPE_INT64: - printf("%sINT64: %lli\n", prefix, (long long) basic.s64); - break; + switch (m->header->type) { - case SD_BUS_TYPE_UINT64: - printf("%sUINT64: %llu\n", prefix, (unsigned long long) basic.u64); - break; + case SD_BUS_MESSAGE_SIGNAL: + if (!m->path || !m->interface || !m->member) + return -EBADMSG; + break; - case SD_BUS_TYPE_DOUBLE: - printf("%sDOUBLE: %g\n", prefix, basic.d64); - break; + case SD_BUS_MESSAGE_METHOD_CALL: - case SD_BUS_TYPE_STRING: - printf("%sSTRING: \"%s\"\n", prefix, basic.string); - break; + if (!m->path || !m->member) + return -EBADMSG; - case SD_BUS_TYPE_OBJECT_PATH: - printf("%sOBJECT_PATH: \"%s\"\n", prefix, basic.string); - break; + break; - case SD_BUS_TYPE_SIGNATURE: - printf("%sSIGNATURE: \"%s\"\n", prefix, basic.string); - break; + case SD_BUS_MESSAGE_METHOD_RETURN: - case SD_BUS_TYPE_UNIX_FD: - printf("%sUNIX_FD: %i\n", prefix, basic.i); - break; + if (m->reply_serial == 0) + return -EBADMSG; + break; - default: - assert_not_reached("Unknown basic type."); - } + case SD_BUS_MESSAGE_METHOD_ERROR: + + if (m->reply_serial == 0 || !m->error.name) + return -EBADMSG; + break; } - printf("} END_MESSAGE\n"); + m->root_container.end = BUS_MESSAGE_BODY_SIZE(m); + + if (BUS_MESSAGE_IS_GVARIANT(m)) { + r = build_struct_offsets( + m, + m->root_container.signature, + BUS_MESSAGE_BODY_SIZE(m), + &m->root_container.item_size, + &m->root_container.offsets, + &m->root_container.n_offsets); + if (r < 0) + return r; + } + + /* Try to read the error message, but if we can't it's a non-issue */ + if (m->header->type == SD_BUS_MESSAGE_METHOD_ERROR) + sd_bus_message_read(m, "s", &m->error.message); + return 0; } +_public_ int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) { + assert_return(m, -EINVAL); + assert_return(destination, -EINVAL); + assert_return(!m->sealed, -EPERM); + assert_return(!m->destination, -EEXIST); + + return message_append_field_string(m, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &m->destination); +} + int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz) { size_t total; void *p, *e; + unsigned i; + struct bus_body_part *part; assert(m); assert(buffer); assert(sz); - total = bus_message_size(m); + total = BUS_MESSAGE_SIZE(m); p = malloc(total); if (!p) return -ENOMEM; - e = mempcpy(p, m->header, sizeof(*m->header)); - - if (m->fields) { - e = mempcpy(e, m->fields, m->header->fields_size); - - if (m->header->fields_size % 8 != 0) - e = mempset(e, 0, 8 - (m->header->fields_size % 8)); - } - - if (m->body) - e = mempcpy(e, m->body, m->header->body_size); + e = mempcpy(p, m->header, BUS_MESSAGE_BODY_BEGIN(m)); + MESSAGE_FOREACH_PART(part, i, m) + e = mempcpy(e, part->data, part->size); assert(total == (size_t) ((uint8_t*) e - (uint8_t*) p)); @@ -3074,7 +5169,7 @@ int bus_message_read_strv_extend(sd_bus_message *m, char ***l) { assert(l); r = sd_bus_message_enter_container(m, 'a', "s"); - if (r < 0) + if (r <= 0) return r; for (;;) { @@ -3095,13 +5190,31 @@ int bus_message_read_strv_extend(sd_bus_message *m, char ***l) { if (r < 0) return r; - return 0; + return 1; +} + +_public_ int sd_bus_message_read_strv(sd_bus_message *m, char ***l) { + char **strv = NULL; + int r; + + assert_return(m, -EINVAL); + assert_return(m->sealed, -EPERM); + assert_return(l, -EINVAL); + + r = bus_message_read_strv_extend(m, &strv); + if (r <= 0) { + strv_free(strv); + return r; + } + + *l = strv; + return 1; } const char* bus_message_get_arg(sd_bus_message *m, unsigned i) { int r; - const char *t; - char type; + const char *t = NULL; + unsigned j; assert(m); @@ -3109,7 +5222,9 @@ const char* bus_message_get_arg(sd_bus_message *m, unsigned i) { if (r < 0) return NULL; - while (i > 0) { + for (j = 0; j <= i; j++) { + char type; + r = sd_bus_message_peek_type(m, &type, NULL); if (r < 0) return NULL; @@ -3122,23 +5237,169 @@ const char* bus_message_get_arg(sd_bus_message *m, unsigned i) { 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; } -size_t bus_message_size(sd_bus_message *m) { - assert(m); - assert(m->sealed); +bool bus_header_is_complete(struct bus_header *h, size_t size) { + size_t full; + + assert(h); + assert(size); + + if (size < sizeof(struct bus_header)) + return false; + + full = sizeof(struct bus_header) + + (h->endian == BUS_NATIVE_ENDIAN ? h->fields_size : bswap_32(h->fields_size)); + + return size >= full; +} + +int bus_header_message_size(struct bus_header *h, size_t *sum) { + size_t fs, bs; + + assert(h); + assert(sum); + + if (h->endian == BUS_NATIVE_ENDIAN) { + fs = h->fields_size; + bs = h->body_size; + } else if (h->endian == BUS_REVERSE_ENDIAN) { + fs = bswap_32(h->fields_size); + bs = bswap_32(h->body_size); + } else + return -EBADMSG; + + *sum = sizeof(struct bus_header) + ALIGN8(fs) + bs; + return 0; +} + +_public_ int sd_bus_message_get_errno(sd_bus_message *m) { + assert_return(m, -EINVAL); + + if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR) + return 0; + + return sd_bus_error_get_errno(&m->error); +} + +_public_ const char* sd_bus_message_get_signature(sd_bus_message *m, int complete) { + struct bus_container *c; + + assert_return(m, NULL); + + c = complete ? &m->root_container : message_get_container(m); + return strempty(c->signature); +} + +_public_ int sd_bus_message_copy(sd_bus_message *m, sd_bus_message *source, int all) { + bool done_something = false; + int r; + + assert_return(m, -EINVAL); + assert_return(source, -EINVAL); + assert_return(!m->sealed, -EPERM); + assert_return(source->sealed, -EPERM); + + do { + const char *contents; + 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(source, &type, &contents); + if (r < 0) + return r; + if (r == 0) + break; + + done_something = true; + + if (bus_type_is_container(type) > 0) { + + r = sd_bus_message_enter_container(source, type, contents); + if (r < 0) + return r; + + r = sd_bus_message_open_container(m, type, contents); + if (r < 0) + return r; + + r = sd_bus_message_copy(m, source, true); + if (r < 0) + return r; + + r = sd_bus_message_close_container(m); + if (r < 0) + return r; + + r = sd_bus_message_exit_container(source); + if (r < 0) + return r; + + continue; + } + + r = sd_bus_message_read_basic(source, type, &basic); + if (r < 0) + return r; + + assert(r > 0); + + if (type == SD_BUS_TYPE_OBJECT_PATH || + type == SD_BUS_TYPE_SIGNATURE || + type == SD_BUS_TYPE_STRING) + r = sd_bus_message_append_basic(m, type, basic.string); + else + r = sd_bus_message_append_basic(m, type, &basic); + + if (r < 0) + return r; + + } while (all); + + return done_something; +} + +_public_ int sd_bus_message_verify_type(sd_bus_message *m, char type, const char *contents) { + const char *c; + char t; + int r; + + assert_return(m, -EINVAL); + assert_return(m->sealed, -EPERM); + assert_return(!type || bus_type_is_valid(type), -EINVAL); + assert_return(!contents || signature_is_valid(contents, true), -EINVAL); + assert_return(type || contents, -EINVAL); + assert_return(!contents || !type || bus_type_is_container(type), -EINVAL); + + r = sd_bus_message_peek_type(m, &t, &c); + if (r <= 0) + return r; + + if (type != 0 && type != t) + return 0; + + if (contents && !streq_ptr(contents, c)) + return 0; + + return 1; +} + +_public_ sd_bus *sd_bus_message_get_bus(sd_bus_message *m) { + assert_return(m, NULL); - return - sizeof(*m->header) + - ALIGN8(m->header->fields_size) + - m->header->body_size; + return m->bus; }