diff options
author | Lennart Poettering <lennart@poettering.net> | 2013-12-05 02:46:54 +0100 |
---|---|---|
committer | Lennart Poettering <lennart@poettering.net> | 2013-12-05 02:47:36 +0100 |
commit | c1b9d935725103e95901f347b8981647ce4dd546 (patch) | |
tree | 4f5474c2022f7812d7e261b29896e89de14cf490 /src/libsystemd-bus/bus-message.c | |
parent | 65dae17a2f890b12a07dd4901b3db02b1031c463 (diff) |
bus: add support for serializing to gvariant
(deserialization is still missing, hence this is not hooked up to kdbus)
Diffstat (limited to 'src/libsystemd-bus/bus-message.c')
-rw-r--r-- | src/libsystemd-bus/bus-message.c | 900 |
1 files changed, 685 insertions, 215 deletions
diff --git a/src/libsystemd-bus/bus-message.c b/src/libsystemd-bus/bus-message.c index 0cfbf5a65b..73b0bab8f5 100644 --- a/src/libsystemd-bus/bus-message.c +++ b/src/libsystemd-bus/bus-message.c @@ -34,6 +34,7 @@ #include "bus-internal.h" #include "bus-type.h" #include "bus-signature.h" +#include "bus-gvariant.h" static int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored); @@ -152,7 +153,7 @@ static void message_free(sd_bus_message *m) { free(m); } -static void *message_extend_fields(sd_bus_message *m, size_t align, size_t sz) { +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; @@ -205,6 +206,13 @@ static void *message_extend_fields(sd_bus_message *m, size_t align, size_t sz) { m->free_header = true; + if (add_offset) { + if (m->n_header_offsets >= ELEMENTSOF(m->header_offsets)) + goto poison; + + m->header_offsets[m->n_header_offsets++] = new_size - sizeof(struct bus_header); + } + return (uint8_t*) np + start; poison: @@ -224,25 +232,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 (m->is_gvariant) { - ((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 = (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 + 1; + + } 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; } @@ -258,24 +289,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 (m->is_gvariant) + /* 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; } @@ -285,17 +325,31 @@ 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 (m->is_gvariant) { + /* (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; + 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; - p[0] = h; - p[1] = 1; - p[2] = SD_BUS_TYPE_UINT32; - p[3] = 0; + p[0] = h; + p[1] = 1; + p[2] = SD_BUS_TYPE_UINT32; + p[3] = 0; - ((uint32_t*) p)[1] = x; + ((uint32_t*) p)[1] = x; + } return 0; } @@ -440,6 +494,7 @@ static sd_bus_message *message_new(sd_bus *bus, uint8_t type) { 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 = m->is_gvariant = bus ? bus->use_gvariant : false; if (bus) m->bus = sd_bus_ref(bus); @@ -1034,6 +1089,27 @@ static int part_make_space( return 0; } +static int message_add_offset(sd_bus_message *m, size_t offset) { + struct bus_container *c; + + assert(m); + assert(m->is_gvariant); + + /* 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 (!c->need_offsets) + return 0; + + if (!GREEDY_REALLOC(c->offsets, c->n_allocated, c->n_offsets + 1)) + return -ENOMEM; + + c->offsets[c->n_offsets++] = offset; + return 0; +} + static void message_extend_containers(sd_bus_message *m, size_t expand) { struct bus_container *c; @@ -1043,12 +1119,14 @@ static void message_extend_containers(sd_bus_message *m, size_t expand) { return; /* Update counters */ - for (c = m->containers; c < m->containers + m->n_containers; c++) + for (c = m->containers; c < m->containers + m->n_containers; c++) { + if (c->array_size) *c->array_size += expand; + } } -static void *message_extend_body(sd_bus_message *m, size_t align, size_t sz) { +static void *message_extend_body(sd_bus_message *m, size_t align, size_t sz, bool add_offset) { struct bus_body_part *part = NULL; size_t start_body, end_body, padding, start_part, end_part, added; bool add_new_part; @@ -1126,17 +1204,51 @@ static void *message_extend_body(sd_bus_message *m, size_t align, size_t sz) { m->header->body_size = end_body; message_extend_containers(m, added); + if (add_offset) { + r = message_add_offset(m, end_body); + if (r < 0) { + m->poisoned = true; + return NULL; + } + } + return p; } +static int message_push_fd(sd_bus_message *m, int fd) { + int *f, copy; + + assert(m); + + 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; + } + + m->fds = f; + m->fds[m->n_fds] = copy; + m->free_fds = true; + + return copy; +} + int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored) { + _cleanup_close_ int fd = -1; struct bus_container *c; ssize_t align, sz; - uint32_t k; void *a; - int fd = -1; - uint32_t fdi = 0; - int r; assert_return(m, -EINVAL); assert_return(!m->sealed, -EPERM); @@ -1164,150 +1276,157 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void } } - switch (type) { + if (m->is_gvariant) { + uint8_t u8; + uint32_t u32; - case SD_BUS_TYPE_STRING: - /* To make things easy we'll serialize a NULL string - * into the empty string */ - p = strempty(p); + switch (type) { - /* Fall through... */ - case SD_BUS_TYPE_OBJECT_PATH: + case SD_BUS_TYPE_SIGNATURE: + case SD_BUS_TYPE_STRING: + p = strempty(p); - if (!p) { - r = -EINVAL; - goto fail; - } + /* Fall through... */ + case SD_BUS_TYPE_OBJECT_PATH: + if (!p) + return -EINVAL; - align = 4; - sz = 4 + strlen(p) + 1; - break; + align = 1; + sz = strlen(p) + 1; + break; - case SD_BUS_TYPE_SIGNATURE: + case SD_BUS_TYPE_BOOLEAN: - if (!p) { - r = -EINVAL; - goto fail; - } + u8 = p && *(int*) p; + p = &u8; - align = 1; - sz = 1 + strlen(p) + 1; - break; + align = sz = 1; + break; - case SD_BUS_TYPE_BOOLEAN: + case SD_BUS_TYPE_UNIX_FD: - if (!p) { - r = -EINVAL; - goto fail; - } + if (!p) + return -EINVAL; - align = sz = 4; + fd = message_push_fd(m, *(int*) p); + if (fd < 0) + return fd; - assert_cc(sizeof(int) == sizeof(uint32_t)); - memcpy(&k, p, 4); - k = !!k; - p = &k; - break; + u32 = m->n_fds; + p = &u32; - case SD_BUS_TYPE_UNIX_FD: { - int z, *f; + align = sz = 4; + break; - if (!p) { - r = -EINVAL; - goto fail; + default: + align = bus_gvariant_get_alignment(CHAR_TO_STR(type)); + sz = bus_gvariant_get_size(type); + break; } - if (!m->allow_fds) { - r = -ENOTSUP; - goto fail; - } + assert(align > 0); + assert(sz > 0); - align = sz = 4; + a = message_extend_body(m, align, sz, true); + if (!a) + return -ENOMEM; - z = *(int*) p; - if (z < 0) { - r = -EINVAL; - goto fail; - } + memcpy(a, p, sz); - fd = fcntl(z, F_DUPFD_CLOEXEC, 3); - if (fd < 0) { - r = -errno; - goto fail; - } + if (stored) + *stored = (const uint8_t*) a; - f = realloc(m->fds, sizeof(int) * (m->n_fds + 1)); - if (!f) { - m->poisoned = true; - r = -ENOMEM; - goto fail; - } + } else { + uint32_t u32; - fdi = m->n_fds; - f[fdi] = fd; - m->fds = f; - m->free_fds = true; - break; - } + switch (type) { - default: - if (!p) { - r = -EINVAL; - goto fail; - } + case SD_BUS_TYPE_STRING: + /* To make things easy we'll serialize a NULL string + * into the empty string */ + p = strempty(p); - align = bus_type_get_alignment(type); - sz = bus_type_get_size(type); - break; - } + /* Fall through... */ + case SD_BUS_TYPE_OBJECT_PATH: - assert(align > 0); - assert(sz > 0); + if (!p) + return -EINVAL; - a = message_extend_body(m, align, sz); - if (!a) { - r = -ENOMEM; - goto fail; - } + align = 4; + sz = 4 + strlen(p) + 1; + break; - 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); + case SD_BUS_TYPE_SIGNATURE: - if (stored) - *stored = (const uint8_t*) a + 4; + p = strempty(p); - } else if (type == SD_BUS_TYPE_SIGNATURE) { - *(uint8_t*) a = sz - 1; - memcpy((uint8_t*) a + 1, p, sz - 1); + align = 1; + sz = 1 + strlen(p) + 1; + break; - if (stored) - *stored = (const uint8_t*) a + 1; - } else if (type == SD_BUS_TYPE_UNIX_FD) { - *(uint32_t*) a = fdi; + case SD_BUS_TYPE_BOOLEAN: - if (stored) - *stored = a; + u32 = p && *(int*) p; + align = sz = 4; + break; - m->n_fds ++; + case SD_BUS_TYPE_UNIX_FD: - } else { - memcpy(a, p, sz); + if (!p) + return -EINVAL; - if (stored) - *stored = a; + 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) c->index++; + fd = -1; return 0; - -fail: - if (fd >= 0) - close_nointr_nofail(fd); - - return r; } _public_ int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p) { @@ -1348,12 +1467,20 @@ _public_ int sd_bus_message_append_string_space( } } - a = message_extend_body(m, 4, 4 + size + 1); - if (!a) - return -ENOMEM; + if (m->is_gvariant) { + 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; + *(uint32_t*) a = size; + *s = (char*) a + 4; + } (*s)[size] = 0; @@ -1401,26 +1528,23 @@ static int bus_message_open_array( sd_bus_message *m, struct bus_container *c, const char *contents, - uint32_t **array_size) { + uint32_t **array_size, + size_t *begin, + bool *need_offsets) { unsigned nindex; - void *a, *op; - int alignment; - size_t os; - struct bus_body_part *o; + 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; - alignment = bus_type_get_alignment(contents[0]); - if (alignment < 0) - return alignment; - if (c->signature && c->signature[c->index]) { /* Verify the existing signature */ @@ -1449,27 +1573,53 @@ static int bus_message_open_array( nindex = e - c->signature; } - a = message_extend_body(m, 4, 4); - if (!a) - return -ENOMEM; + if (m->is_gvariant) { + alignment = bus_gvariant_get_alignment(contents); + if (alignment < 0) + return alignment; - o = m->body_end; - op = m->body_end->data; - os = m->body_end->size; + /* Add alignment padding and add to offset list */ + if (!message_extend_body(m, alignment, 0, false)) + return -ENOMEM; - /* Add alignment between size and first element */ - if (!message_extend_body(m, alignment, 0)) - 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; - /* 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; return 0; } @@ -1478,9 +1628,6 @@ static int bus_message_open_variant( struct bus_container *c, const char *contents) { - size_t l; - void *a; - assert(m); assert(c); assert(contents); @@ -1509,13 +1656,24 @@ static int bus_message_open_variant( } } - l = strlen(contents); - a = message_extend_body(m, 1, 1 + l + 1); - if (!a) - return -ENOMEM; + if (m->is_gvariant) { + /* 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); + *(uint8_t*) a = l; + memcpy((uint8_t*) a + 1, contents, l + 1); + } if (c->enclosing != SD_BUS_TYPE_ARRAY) c->index++; @@ -1526,13 +1684,18 @@ static int bus_message_open_variant( static int bus_message_open_struct( sd_bus_message *m, struct bus_container *c, - const char *contents) { + const char *contents, + size_t *begin, + bool *need_offsets) { size_t nindex; + int r; assert(m); assert(c); assert(contents); + assert(begin); + assert(need_offsets); if (!signature_is_valid(contents, false)) return -EINVAL; @@ -1563,9 +1726,27 @@ static int bus_message_open_struct( nindex = e - c->signature; } - /* Align contents to 8 byte boundary */ - if (!message_extend_body(m, 8, 0)) - return -ENOMEM; + if (m->is_gvariant) { + 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; @@ -1576,13 +1757,17 @@ static int bus_message_open_struct( static int bus_message_open_dict_entry( sd_bus_message *m, struct bus_container *c, - const char *contents) { + const char *contents, + size_t *begin, + bool *need_offsets) { - size_t nindex; + int r; assert(m); assert(c); assert(contents); + assert(begin); + assert(need_offsets); if (!signature_is_pair(contents)) return -EINVAL; @@ -1599,17 +1784,30 @@ static int bus_message_open_dict_entry( !startswith(c->signature + c->index + 1, contents) || c->signature[c->index + 1 + l] != SD_BUS_TYPE_DICT_ENTRY_END) return -ENXIO; - - nindex = c->index + 1 + l + 1; } else return -ENXIO; - /* Align contents to 8 byte boundary */ - if (!message_extend_body(m, 8, 0)) - return -ENOMEM; + if (m->is_gvariant) { + int alignment; - if (c->enclosing != SD_BUS_TYPE_ARRAY) - c->index = nindex; + 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; } @@ -1622,7 +1820,8 @@ _public_ int sd_bus_message_open_container( struct bus_container *c, *w; uint32_t *array_size = NULL; char *signature; - size_t before; + size_t before, begin; + bool need_offsets = false; int r; assert_return(m, -EINVAL); @@ -1653,13 +1852,13 @@ _public_ int sd_bus_message_open_container( before = m->header->body_size; if (type == SD_BUS_TYPE_ARRAY) - r = bus_message_open_array(m, c, contents, &array_size); + 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); + 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); + r = bus_message_open_dict_entry(m, c, contents, &begin, &need_offsets); else r = -EINVAL; @@ -1675,13 +1874,207 @@ _public_ int sd_bus_message_open_container( w->index = 0; w->array_size = array_size; w->before = before; - w->begin = m->rindex; + w->begin = begin; + w->n_offsets = w->n_allocated = 0; + w->offsets = NULL; + w->need_offsets = need_offsets; + + return 0; +} + +static int bus_message_close_array(sd_bus_message *m, struct bus_container *c) { + + assert(m); + assert(c); + + if (!m->is_gvariant) + return 0; + + if (c->need_offsets) { + uint8_t *a; + unsigned i; + size_t sz; + + /* Variable-width arrays */ + + sz = c->n_offsets > 0 ? c->offsets[c->n_offsets-1] - c->begin : 0; + if (sz + c->n_offsets <= 0xFF) { + a = message_extend_body(m, 1, c->n_offsets, true); + if (!a) + return -ENOMEM; + + for (i = 0; i < c->n_offsets; i++) + a[i] = (uint8_t) (c->offsets[i] - c->begin); + + } else if (sz + c->n_offsets*2 <= 0xFFFF) { + a = message_extend_body(m, 1, c->n_offsets * 2, true); + if (!a) + return -ENOMEM; + + for (i = 0; i < c->n_offsets; i++) { + uint16_t x = (uint16_t) (c->offsets[i] - c->begin); + memcpy(a + (i*2), &x, 2); + } + + } else if (sz + c->n_offsets*4 <= 0xFFFFFFFF) { + a = message_extend_body(m, 1, c->n_offsets * 4, true); + if (!a) + return -ENOMEM; + + for (i = 0; i < c->n_offsets; i++) { + uint32_t x = (uint32_t) (c->offsets[i] - c->begin); + memcpy(a + (i*4), &x, 4); + } + } else { + a = message_extend_body(m, 1, c->n_offsets * 8, true); + if (!a) + return -ENOMEM; + + for (i = 0; i < c->n_offsets; i++) { + uint64_t x = (uint64_t) (c->offsets[i] - c->begin); + memcpy(a + (i*8), &x, 8); + } + } + + } 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 (!m->is_gvariant) + 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 (!m->is_gvariant) + return 0; + + p = 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++; + else + c->offsets[i] = (size_t) -1; + + i++; + p += n; + } + + if (n_variable <= 0) { + a = message_extend_body(m, 1, 0, true); + if (!a) + return -ENOMEM; + } else { + size_t sz, z; + unsigned j; + + assert(c->offsets[c->n_offsets-1] == m->header->body_size || + c->offsets[c->n_offsets-1] == (size_t) -1); + + sz = m->header->body_size - c->begin; + if (sz + n_variable <= 0xFF) + z = 1; + else if (sz + (n_variable)*2 <= 0xFFFF) + z = 2; + else if (sz + (n_variable)*4 <= 0xFFFFFFFF) + z = 4; + else + z = 8; + + a = message_extend_body(m, 1, z * n_variable, add_offset); + if (!a) + return -ENOMEM; + + for (i = 0, j = 0; i < c->n_offsets; i++) { + size_t v; + unsigned k; + + if (c->offsets[i] == (size_t) -1) + continue; + + v = c->offsets[i] - c->begin; + k = n_variable - 1 - j; + + if (z == 1) + ((uint8_t*) a)[k] = (uint8_t) v; + else if (z == 2) { + uint16_t x = (uint16_t) v; + memcpy(a + k * 2, &x, 2); + } else if (z == 4) { + uint32_t x = (uint32_t) v; + memcpy(a + k * 4, &x, 4); + } else if (z == 8) { + uint64_t x = (uint64_t) v; + memcpy(a + k * 8, &x, 8); + } else + assert_not_reached("Wrong offset width"); + + 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); @@ -1689,14 +2082,24 @@ _public_ int sd_bus_message_close_container(sd_bus_message *m) { 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; - free(c->signature); m->n_containers--; - return 0; + 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); + return r; } typedef struct { @@ -1951,10 +2354,12 @@ _public_ int sd_bus_message_append(sd_bus_message *m, const char *types, ...) { return r; } -_public_ int sd_bus_message_append_array_space(sd_bus_message *m, - char type, - size_t size, - void **ptr) { +_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; @@ -1978,7 +2383,7 @@ _public_ int sd_bus_message_append_array_space(sd_bus_message *m, if (r < 0) return r; - a = message_extend_body(m, align, size); + a = message_extend_body(m, align, size, false); if (!a) return -ENOMEM; @@ -2098,7 +2503,7 @@ _public_ int sd_bus_message_append_array_memfd(sd_bus_message *m, if (r < 0) return r; - a = message_extend_body(m, align, 0); + a = message_extend_body(m, align, 0, false); if (!a) return -ENOMEM; @@ -2169,11 +2574,13 @@ _public_ int sd_bus_message_append_string_memfd(sd_bus_message *m, sd_memfd *mem } } - a = message_extend_body(m, 4, 4); - if (!a) - return -ENOMEM; + if (!m->is_gvariant) { + a = message_extend_body(m, 4, 4, false); + if (!a) + return -ENOMEM; - *(uint32_t*) a = size - 1; + *(uint32_t*) a = size - 1; + } part = message_append_part(m); if (!part) @@ -2184,8 +2591,16 @@ _public_ int sd_bus_message_append_string_memfd(sd_bus_message *m, sd_memfd *mem part->size = size; copy_fd = -1; - message_extend_containers(m, size); m->header->body_size += size; + message_extend_containers(m, size); + + if (m->is_gvariant) { + 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++; @@ -3946,6 +4361,52 @@ int bus_message_parse_fields(sd_bus_message *m) { return 0; } +static int bus_message_close_header(sd_bus_message *m) { + uint8_t *a; + size_t z, i; + + assert(m); + + if (!m->is_gvariant) + return 0; + + if (m->n_header_offsets <= 1) + return 0; + + assert(m->header->fields_size == m->header_offsets[m->n_header_offsets-1]); + + if (m->header->fields_size + m->n_header_offsets <= 0xFF) + z = 1; + else if (m->header->fields_size + 2*m->n_header_offsets <= 0xFFFF) + z = 2; + else if (m->header->fields_size + 4*m->n_header_offsets <= 0xFFFFFFFF) + z = 4; + else + z = 8; + + a = message_extend_fields(m, 1, z * m->n_header_offsets, false); + if (!a) + return -ENOMEM; + + for (i = 0; i < m->n_header_offsets; i++) { + if (z == 1) + ((uint8_t*) a)[i] = (uint8_t) m->header_offsets[i]; + else if (z == 2) { + uint16_t x = (uint16_t) m->header_offsets[i]; + memcpy(a + 2*i, &x, 2); + } else if (z == 4) { + uint32_t x = (uint32_t) m->header_offsets[i]; + memcpy(a + 4*i, &x, 4); + } else if (z == 8) { + uint64_t x = (uint64_t) m->header_offsets[i]; + memcpy(a + 8*i, &x, 8); + } else + assert_not_reached("unknown type"); + } + + return 0; +} + int bus_message_seal(sd_bus_message *m, uint64_t serial) { struct bus_body_part *part; size_t l, a; @@ -3970,6 +4431,11 @@ int bus_message_seal(sd_bus_message *m, uint64_t serial) { !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); @@ -3983,6 +4449,10 @@ int bus_message_seal(sd_bus_message *m, uint64_t serial) { return r; } + r = bus_message_close_header(m); + if (r < 0) + return r; + /* 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 |