[systemd-commits] 2 commits - CODING_STYLE Makefile.am src/libsystemd-bus
Lennart Poettering
lennart at kemper.freedesktop.org
Mon Dec 9 14:08:23 PST 2013
CODING_STYLE | 80 +
Makefile.am | 6
src/libsystemd-bus/GVARIANT-SERIALIZATION | 4
src/libsystemd-bus/bus-gvariant.c | 94 +-
src/libsystemd-bus/bus-gvariant.h | 2
src/libsystemd-bus/bus-internal.h | 1
src/libsystemd-bus/bus-kernel.c | 6
src/libsystemd-bus/bus-message.c | 1302 ++++++++++++++++++++++--------
src/libsystemd-bus/bus-message.h | 19
src/libsystemd-bus/kdbus.h | 5
src/libsystemd-bus/test-bus-gvariant.c | 64 +
11 files changed, 1209 insertions(+), 374 deletions(-)
New commits:
commit 6647dc6659e1e42b3cff3cf5033ea5624000e650
Author: Lennart Poettering <lennart at poettering.net>
Date: Mon Dec 9 23:03:21 2013 +0100
bus: demarshal gvariant
diff --git a/Makefile.am b/Makefile.am
index 7bedd76..c13956d 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -2162,11 +2162,15 @@ test_bus_gvariant_LDADD = \
libsystemd-id128-internal.la \
libsystemd-daemon-internal.la \
libsystemd-shared.la \
- $(GLIB_LIBS)
+ libsystemd-bus-dump.la \
+ libsystemd-capability.la \
+ $(GLIB_LIBS) \
+ $(CAP_LIBS)
test_bus_gvariant_CFLAGS = \
$(AM_CFLAGS) \
$(GLIB_CFLAGS)
+ $(CAP_CFLAGS)
test_bus_creds_SOURCES = \
src/libsystemd-bus/test-bus-creds.c
diff --git a/src/libsystemd-bus/GVARIANT-SERIALIZATION b/src/libsystemd-bus/GVARIANT-SERIALIZATION
index b23c7e4..5dffc25 100644
--- a/src/libsystemd-bus/GVARIANT-SERIALIZATION
+++ b/src/libsystemd-bus/GVARIANT-SERIALIZATION
@@ -57,3 +57,7 @@ And that's already it.
Note: on kdbus only native endian messages marshalled in gvariant may
be sent. If a client receives a message in non-native endianness
or in dbus1 marshalling it shall ignore the message.
+
+Note: The GVariant "MAYBE" type is not supported, so that messages can
+ be fully converted forth and back between dbus1 and gvariant
+ representations.
diff --git a/src/libsystemd-bus/bus-gvariant.c b/src/libsystemd-bus/bus-gvariant.c
index d2e134e..dc40009 100644
--- a/src/libsystemd-bus/bus-gvariant.c
+++ b/src/libsystemd-bus/bus-gvariant.c
@@ -24,30 +24,90 @@
#include "bus-gvariant.h"
#include "bus-signature.h"
-int bus_gvariant_get_size(char c) {
+int bus_gvariant_get_size(const char *signature) {
+ const char *p;
+ int sum = 0, r;
+
+ /* For fixed size structs. Fails for variable size structs. */
+
+ p = 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_get_alignment(t);
+ if (r < 0)
+ return r;
+
+ sum = ALIGN_TO(sum, r);
+ }
- switch (c) {
+ switch (*p) {
- case SD_BUS_TYPE_BOOLEAN:
- case SD_BUS_TYPE_BYTE:
- return 1;
+ case SD_BUS_TYPE_BOOLEAN:
+ case SD_BUS_TYPE_BYTE:
+ sum += 1;
+ break;
- case SD_BUS_TYPE_INT16:
- case SD_BUS_TYPE_UINT16:
- return 2;
+ case SD_BUS_TYPE_INT16:
+ case SD_BUS_TYPE_UINT16:
+ sum += 2;
+ break;
- case SD_BUS_TYPE_INT32:
- case SD_BUS_TYPE_UINT32:
- case SD_BUS_TYPE_UNIX_FD:
- return 4;
+ case SD_BUS_TYPE_INT32:
+ case SD_BUS_TYPE_UINT32:
+ case SD_BUS_TYPE_UNIX_FD:
+ sum += 4;
+ break;
- case SD_BUS_TYPE_INT64:
- case SD_BUS_TYPE_UINT64:
- case SD_BUS_TYPE_DOUBLE:
- return 8;
+ case SD_BUS_TYPE_INT64:
+ case SD_BUS_TYPE_UINT64:
+ case SD_BUS_TYPE_DOUBLE:
+ sum += 8;
+ break;
+
+ case SD_BUS_TYPE_STRUCT_BEGIN:
+ case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
+ char t[n-1];
+
+ memcpy(t, p + 1, n - 2);
+ t[n - 2] = 0;
+
+ r = bus_gvariant_get_size(t);
+ if (r < 0)
+ return r;
+
+ sum += r;
+ break;
+ }
+
+ case SD_BUS_TYPE_STRING:
+ case SD_BUS_TYPE_OBJECT_PATH:
+ case SD_BUS_TYPE_SIGNATURE:
+ case SD_BUS_TYPE_ARRAY:
+ case SD_BUS_TYPE_VARIANT:
+ return -EINVAL;
+
+ default:
+ assert_not_reached("Unknown signature type");
+ }
+
+ p += n;
}
- return -EINVAL;
+ r = bus_gvariant_get_alignment(signature);
+ if (r < 0)
+ return r;
+
+ return ALIGN_TO(sum, r);
}
int bus_gvariant_get_alignment(const char *signature) {
diff --git a/src/libsystemd-bus/bus-gvariant.h b/src/libsystemd-bus/bus-gvariant.h
index 091a472..435e8f1 100644
--- a/src/libsystemd-bus/bus-gvariant.h
+++ b/src/libsystemd-bus/bus-gvariant.h
@@ -21,6 +21,6 @@
along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
-int bus_gvariant_get_size(char c);
+int bus_gvariant_get_size(const char *signature);
int bus_gvariant_get_alignment(const char *signature);
int bus_gvariant_is_fixed_size(const char *signature);
diff --git a/src/libsystemd-bus/bus-internal.h b/src/libsystemd-bus/bus-internal.h
index d3db13b..4881e04 100644
--- a/src/libsystemd-bus/bus-internal.h
+++ b/src/libsystemd-bus/bus-internal.h
@@ -159,7 +159,6 @@ struct sd_bus {
bool match_callbacks_modified:1;
bool filter_callbacks_modified:1;
bool nodes_modified:1;
- bool use_gvariant:1;
int use_memfd;
diff --git a/src/libsystemd-bus/bus-kernel.c b/src/libsystemd-bus/bus-kernel.c
index 495d7e5..a3afb2e 100644
--- a/src/libsystemd-bus/bus-kernel.c
+++ b/src/libsystemd-bus/bus-kernel.c
@@ -254,7 +254,7 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
m->kdbus->dst_id =
well_known ? 0 :
m->destination ? unique : KDBUS_DST_ID_BROADCAST;
- m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS1;
+ m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
m->kdbus->cookie = m->header->serial;
m->kdbus->timeout_ns = m->timeout * NSEC_PER_USEC;
@@ -618,7 +618,7 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
assert(bus);
assert(k);
- assert(k->payload_type == KDBUS_PAYLOAD_DBUS1);
+ assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
KDBUS_ITEM_FOREACH(d, k, items) {
size_t l;
@@ -885,7 +885,7 @@ int bus_kernel_read_message(sd_bus *bus) {
}
k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + off);
- if (k->payload_type == KDBUS_PAYLOAD_DBUS1)
+ if (k->payload_type == KDBUS_PAYLOAD_DBUS)
r = bus_kernel_make_message(bus, k);
else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
r = bus_kernel_translate_message(bus, k);
diff --git a/src/libsystemd-bus/bus-message.c b/src/libsystemd-bus/bus-message.c
index 4c0e27f..2e355a7 100644
--- a/src/libsystemd-bus/bus-message.c
+++ b/src/libsystemd-bus/bus-message.c
@@ -105,8 +105,10 @@ static void message_reset_containers(sd_bus_message *m) {
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;
@@ -146,6 +148,7 @@ static void message_free(sd_bus_message *m) {
message_reset_containers(m);
free(m->root_container.signature);
+ free(m->root_container.offsets);
free(m->peeked_signature);
@@ -240,7 +243,7 @@ static int message_append_field_string(
/* Signature "(yv)" where the variant contains "s" */
- if (m->is_gvariant) {
+ if (BUS_MESSAGE_IS_GVARIANT(m)) {
/* (field id byte + 7x padding, ((string + NUL) + NUL + signature string 's') */
p = message_extend_fields(m, 8, 1 + 7 + l + 1 + 1 + 1, true);
@@ -255,7 +258,7 @@ static int message_append_field_string(
p[8+l+2] = type;
if (ret)
- *ret = (char*) p + 1;
+ *ret = (char*) p + 8;
} else {
/* (field id byte + (signature length + signature 's' + NUL) + (string length + string + NUL)) */
@@ -297,7 +300,7 @@ static int message_append_field_signature(
/* Signature "(yv)" where the variant contains "g" */
- if (m->is_gvariant)
+ 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 {
@@ -325,7 +328,7 @@ static int message_append_field_uint32(sd_bus_message *m, uint8_t h, uint32_t x)
assert(m);
- if (m->is_gvariant) {
+ 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);
@@ -377,7 +380,8 @@ int bus_message_from_header(
return -EBADMSG;
h = buffer;
- if (h->version != 1)
+ if (h->version != 1 &&
+ h->version != 2)
return -EBADMSG;
if (h->serial == 0)
@@ -494,7 +498,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;
+ m->root_container.need_offsets = BUS_MESSAGE_IS_GVARIANT(m);
if (bus)
m->bus = sd_bus_ref(bus);
@@ -1093,7 +1097,7 @@ static int message_add_offset(sd_bus_message *m, size_t offset) {
struct bus_container *c;
assert(m);
- assert(m->is_gvariant);
+ assert(BUS_MESSAGE_IS_GVARIANT(m));
/* Add offset to current container, unless this is the first
* item in it, which will have the 0 offset, which we can
@@ -1103,7 +1107,7 @@ static int message_add_offset(sd_bus_message *m, size_t offset) {
if (!c->need_offsets)
return 0;
- if (!GREEDY_REALLOC(c->offsets, c->n_allocated, c->n_offsets + 1))
+ if (!GREEDY_REALLOC(c->offsets, c->n_offsets_allocated, c->n_offsets + 1))
return -ENOMEM;
c->offsets[c->n_offsets++] = offset;
@@ -1276,7 +1280,7 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void
}
}
- if (m->is_gvariant) {
+ if (BUS_MESSAGE_IS_GVARIANT(m)) {
uint8_t u8;
uint32_t u32;
@@ -1320,7 +1324,7 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void
default:
align = bus_gvariant_get_alignment(CHAR_TO_STR(type));
- sz = bus_gvariant_get_size(type);
+ sz = bus_gvariant_get_size(CHAR_TO_STR(type));
break;
}
@@ -1367,6 +1371,8 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void
case SD_BUS_TYPE_BOOLEAN:
u32 = p && *(int*) p;
+ p = &u32;
+
align = sz = 4;
break;
@@ -1467,7 +1473,7 @@ _public_ int sd_bus_message_append_string_space(
}
}
- if (m->is_gvariant) {
+ if (BUS_MESSAGE_IS_GVARIANT(m)) {
a = message_extend_body(m, 1, size + 1, true);
if (!a)
return -ENOMEM;
@@ -1573,7 +1579,7 @@ static int bus_message_open_array(
nindex = e - c->signature;
}
- if (m->is_gvariant) {
+ if (BUS_MESSAGE_IS_GVARIANT(m)) {
alignment = bus_gvariant_get_alignment(contents);
if (alignment < 0)
return alignment;
@@ -1656,7 +1662,7 @@ static int bus_message_open_variant(
}
}
- if (m->is_gvariant) {
+ if (BUS_MESSAGE_IS_GVARIANT(m)) {
/* Variants are always aligned to 8 */
if (!message_extend_body(m, 8, 0, false))
@@ -1726,7 +1732,7 @@ static int bus_message_open_struct(
nindex = e - c->signature;
}
- if (m->is_gvariant) {
+ if (BUS_MESSAGE_IS_GVARIANT(m)) {
int alignment;
alignment = bus_gvariant_get_alignment(contents);
@@ -1787,7 +1793,7 @@ static int bus_message_open_dict_entry(
} else
return -ENXIO;
- if (m->is_gvariant) {
+ if (BUS_MESSAGE_IS_GVARIANT(m)) {
int alignment;
alignment = bus_gvariant_get_alignment(contents);
@@ -1875,67 +1881,98 @@ _public_ int sd_bus_message_open_container(
w->array_size = array_size;
w->before = before;
w->begin = begin;
- w->n_offsets = w->n_allocated = 0;
+ 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 <= 0 && extra == 0)
+ return 0;
+ else 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 (!m->is_gvariant)
+ if (!BUS_MESSAGE_IS_GVARIANT(m))
return 0;
if (c->need_offsets) {
+ size_t payload, sz, i;
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 = htole16((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 = htole32((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;
+ payload = c->n_offsets > 0 ? c->offsets[c->n_offsets-1] - c->begin : 0;
+ sz = determine_word_size(payload, c->n_offsets);
- for (i = 0; i < c->n_offsets; i++) {
- uint64_t x = htole64((uint64_t) (c->offsets[i] - c->begin));
- memcpy(a + (i*8), &x, 8);
- }
- }
+ 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;
@@ -1956,7 +1993,7 @@ static int bus_message_close_variant(sd_bus_message *m, struct bus_container *c)
assert(m);
assert(c);
- if (!m->is_gvariant)
+ if (!BUS_MESSAGE_IS_GVARIANT(m))
return 0;
l = strlen(c->signature);
@@ -1981,7 +2018,7 @@ static int bus_message_close_struct(sd_bus_message *m, struct bus_container *c,
assert(m);
assert(c);
- if (!m->is_gvariant)
+ if (!BUS_MESSAGE_IS_GVARIANT(m))
return 0;
p = c->signature;
@@ -2009,61 +2046,55 @@ static int bus_message_close_struct(sd_bus_message *m, struct bus_container *c,
* list */
if (r == 0 && p[n] != 0)
n_variable++;
- else
- c->offsets[i] = (size_t) -1;
i++;
p += n;
}
+ assert(i == c->n_offsets);
+
if (n_variable <= 0) {
- a = message_extend_body(m, 1, 0, true);
+ a = message_extend_body(m, 1, 0, add_offset);
if (!a)
return -ENOMEM;
} else {
- size_t sz, z;
+ size_t sz;
unsigned j;
- assert(c->offsets[c->n_offsets-1] == m->header->body_size ||
- c->offsets[c->n_offsets-1] == (size_t) -1);
+ assert(c->offsets[c->n_offsets-1] == m->header->body_size);
- 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;
+ sz = determine_word_size(m->header->body_size - c->begin, n_variable);
- a = message_extend_body(m, 1, z * n_variable, add_offset);
+ a = message_extend_body(m, 1, sz * n_variable, add_offset);
if (!a)
return -ENOMEM;
+ p = c->signature;
for (i = 0, j = 0; i < c->n_offsets; i++) {
- size_t v;
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;
- if (c->offsets[i] == (size_t) -1)
- continue;
+ r = bus_gvariant_is_fixed_size(t);
+ if (r < 0)
+ return r;
+ if (r > 0 || p[0] == 0)
+ 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 = htole16((uint16_t) v);
- memcpy(a + k * 2, &x, 2);
- } else if (z == 4) {
- uint32_t x = htole32((uint32_t) v);
- memcpy(a + k * 4, &x, 4);
- } else if (z == 8) {
- uint64_t x = htole64((uint64_t) v);
- memcpy(a + k * 8, &x, 8);
- } else
- assert_not_reached("Wrong offset width");
+ write_word_le(a + k * sz, sz, c->offsets[i] - c->begin);
j++;
}
@@ -2099,6 +2130,8 @@ _public_ int sd_bus_message_close_container(sd_bus_message *m) {
assert_not_reached("Unknown container type");
free(c->signature);
+ free(c->offsets);
+
return r;
}
@@ -2574,7 +2607,7 @@ _public_ int sd_bus_message_append_string_memfd(sd_bus_message *m, sd_memfd *mem
}
}
- if (!m->is_gvariant) {
+ if (!BUS_MESSAGE_IS_GVARIANT(m)) {
a = message_extend_body(m, 4, 4, false);
if (!a)
return -ENOMEM;
@@ -2594,7 +2627,7 @@ _public_ int sd_bus_message_append_string_memfd(sd_bus_message *m, sd_memfd *mem
m->header->body_size += size;
message_extend_containers(m, size);
- if (m->is_gvariant) {
+ if (BUS_MESSAGE_IS_GVARIANT(m)) {
r = message_add_offset(m, m->header->body_size);
if (r < 0) {
m->poisoned = true;
@@ -2729,10 +2762,15 @@ static bool message_end_of_array(sd_bus_message *m, size_t index) {
assert(m);
c = message_get_container(m);
- if (!c->array_size)
+ if (c->enclosing != SD_BUS_TYPE_ARRAY)
return false;
- return index >= c->begin + BUS_MESSAGE_BSWAP32(m, *c->array_size);
+ 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) {
@@ -2792,6 +2830,88 @@ static struct bus_body_part* find_part(sd_bus_message *m, size_t index, size_t s
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 {
+ /* Fixed-size array */
+ *rindex += 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,
@@ -2890,6 +3010,7 @@ static bool validate_object_path(const char *s, size_t l) {
_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;
@@ -2907,132 +3028,209 @@ _public_ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) {
if (c->signature[c->index] != type)
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)) {
- rindex = m->rindex;
- r = message_peek_body(m, &rindex, 4, 4, &q);
- if (r <= 0)
- return r;
+ if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE)) {
+ bool ok;
- l = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
- r = message_peek_body(m, &rindex, 1, l+1, &q);
- if (r < 0)
- return r;
- if (r == 0)
- return -EBADMSG;
+ r = message_peek_body(m, &rindex, 1, c->item_size, &q);
+ if (r <= 0)
+ return r;
+
+ 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);
- if (type == SD_BUS_TYPE_OBJECT_PATH) {
- if (!validate_object_path(q, l))
+ if (!ok)
return -EBADMSG;
+
+ if (p)
+ *(const char**) p = q;
} else {
- if (!validate_string(q, l))
+ int sz, align;
+
+ sz = bus_gvariant_get_size(CHAR_TO_STR(type));
+ assert(sz > 0);
+ if ((size_t) sz != c->item_size)
return -EBADMSG;
- }
- m->rindex = rindex;
- if (p)
- *(const char**) p = q;
+ align = bus_gvariant_get_alignment(CHAR_TO_STR(type));
+ assert(align > 0);
- break;
- }
+ r = message_peek_body(m, &rindex, align, c->item_size, &q);
+ if (r <= 0)
+ return r;
- case SD_BUS_TYPE_SIGNATURE: {
- uint8_t l;
- size_t rindex;
+ switch (type) {
- rindex = m->rindex;
- r = message_peek_body(m, &rindex, 1, 1, &q);
- if (r <= 0)
- return r;
+ case SD_BUS_TYPE_BYTE:
+ if (p)
+ *(uint8_t*) p = *(uint8_t*) q;
+ break;
- l = *(uint8_t*) q;
- r = message_peek_body(m, &rindex, 1, l+1, &q);
- if (r < 0)
- return r;
- if (r == 0)
- return -EBADMSG;
+ case SD_BUS_TYPE_BOOLEAN:
+ if (p)
+ *(int*) p = !!*(uint8_t*) q;
+ break;
- if (!validate_signature(q, l))
- return -EBADMSG;
+ 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_INT32:
+ case SD_BUS_TYPE_UINT32:
+ if (p)
+ *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
+ break;
- m->rindex = rindex;
+ 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;
- if (p)
- *(const char**) p = q;
- break;
- }
+ case SD_BUS_TYPE_UNIX_FD: {
+ uint32_t j;
- default: {
- ssize_t sz, align;
- size_t rindex;
+ j = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
+ if (j >= m->n_fds)
+ return -EBADMSG;
- align = bus_type_get_alignment(type);
- sz = bus_type_get_size(type);
- assert(align > 0 && sz > 0);
+ if (p)
+ *(int*) p = m->fds[j];
- rindex = m->rindex;
- r = message_peek_body(m, &rindex, align, sz, &q);
- if (r <= 0)
+ break;
+ }
+
+ default:
+ assert_not_reached("unexpected type");
+ }
+ }
+
+ r = container_next_item(m, c, &rindex);
+ if (r < 0)
return r;
+ } else {
- switch (type) {
+ rindex = m->rindex;
- case SD_BUS_TYPE_BYTE:
- if (p)
- *(uint8_t*) p = *(uint8_t*) q;
- break;
+ if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH)) {
+ uint32_t l;
+ bool ok;
- case SD_BUS_TYPE_BOOLEAN:
- if (p)
- *(int*) p = !!*(uint32_t*) q;
- break;
+ r = message_peek_body(m, &rindex, 4, 4, &q);
+ 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;
+ l = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
+ r = message_peek_body(m, &rindex, 1, l+1, &q);
+ if (r < 0)
+ return r;
+ if (r == 0)
+ return -EBADMSG;
- case SD_BUS_TYPE_INT32:
- case SD_BUS_TYPE_UINT32:
- if (p)
- *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
- 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_INT64:
- case SD_BUS_TYPE_UINT64:
- case SD_BUS_TYPE_DOUBLE:
if (p)
- *(uint64_t*) p = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q);
- break;
+ *(const char**) p = q;
- case SD_BUS_TYPE_UNIX_FD: {
- uint32_t j;
+ } else if (type == SD_BUS_TYPE_SIGNATURE) {
+ uint8_t l;
+
+ 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;
- j = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
- if (j >= m->n_fds)
+ if (!validate_signature(q, l))
return -EBADMSG;
if (p)
- *(int*) p = m->fds[j];
- break;
- }
+ *(const char**) p = q;
- default:
- assert_not_reached("Unknown basic type...");
- }
+ } else {
+ ssize_t sz, align;
- m->rindex = rindex;
+ align = bus_type_get_alignment(type);
+ assert(align > 0);
- break;
- }
+ sz = bus_type_get_size(type);
+ assert(sz > 0);
+
+ r = message_peek_body(m, &rindex, align, sz, &q);
+ if (r <= 0)
+ return r;
+
+ switch (type) {
+
+ case SD_BUS_TYPE_BYTE:
+ if (p)
+ *(uint8_t*) p = *(uint8_t*) q;
+ break;
+
+ case SD_BUS_TYPE_BOOLEAN:
+ if (p)
+ *(int*) p = !!*(uint32_t*) q;
+ 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_INT32:
+ case SD_BUS_TYPE_UINT32:
+ if (p)
+ *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
+ break;
+
+ case SD_BUS_TYPE_INT64:
+ case SD_BUS_TYPE_UINT64:
+ case SD_BUS_TYPE_DOUBLE:
+ if (p)
+ *(uint64_t*) p = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q);
+ break;
+
+ case SD_BUS_TYPE_UNIX_FD: {
+ uint32_t j;
+
+ j = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
+ if (j >= m->n_fds)
+ return -EBADMSG;
+
+ if (p)
+ *(int*) p = m->fds[j];
+ break;
+ }
+
+ default:
+ assert_not_reached("Unknown basic type...");
+ }
+ }
}
+ m->rindex = rindex;
+
if (c->enclosing != SD_BUS_TYPE_ARRAY)
c->index++;
@@ -3043,7 +3241,10 @@ static int bus_message_enter_array(
sd_bus_message *m,
struct bus_container *c,
const char *contents,
- uint32_t **array_size) {
+ uint32_t **array_size,
+ size_t *item_size,
+ size_t **offsets,
+ size_t *n_offsets) {
size_t rindex;
void *q;
@@ -3053,16 +3254,15 @@ static int bus_message_enter_array(
assert(c);
assert(contents);
assert(array_size);
+ assert(item_size);
+ assert(offsets);
+ assert(n_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] == 0)
- return 0;
+ return -ENXIO;
if (c->signature[c->index] != SD_BUS_TYPE_ARRAY)
return -ENXIO;
@@ -3071,25 +3271,96 @@ static int bus_message_enter_array(
return -ENXIO;
rindex = m->rindex;
- r = message_peek_body(m, &rindex, 4, 4, &q);
- if (r <= 0)
- return r;
-
- if (BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q) > BUS_ARRAY_MAX_SIZE)
- return -EBADMSG;
- r = message_peek_body(m, &rindex, alignment, 0, NULL);
- if (r < 0)
- return r;
- if (r == 0)
- return -EBADMSG;
+ if (!BUS_MESSAGE_IS_GVARIANT(m)) {
+ /* dbus1 */
- if (c->enclosing != SD_BUS_TYPE_ARRAY)
- c->index += 1 + strlen(contents);
+ r = message_peek_body(m, &rindex, 4, 4, &q);
+ if (r <= 0)
+ return r;
- m->rindex = rindex;
+ if (BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q) > BUS_ARRAY_MAX_SIZE)
+ return -EBADMSG;
- *array_size = (uint32_t*) q;
+ alignment = bus_type_get_alignment(contents[0]);
+ if (alignment < 0)
+ return alignment;
+
+ r = message_peek_body(m, &rindex, alignment, 0, NULL);
+ if (r < 0)
+ return r;
+ if (r == 0)
+ return -EBADMSG;
+
+ *array_size = (uint32_t*) q;
+
+ } else if (c->item_size <= 0) {
+
+ /* gvariant: empty array */
+ *item_size = 0;
+ *offsets = NULL;
+ *n_offsets = 0;
+
+ } else if (bus_gvariant_is_fixed_size(contents)) {
+
+ /* gvariant: fixed length array */
+ *item_size = bus_gvariant_get_size(contents);
+ *offsets = NULL;
+ *n_offsets = 0;
+
+ } else {
+ size_t where, p = 0, framing, sz;
+ unsigned i;
+
+ /* gvariant: variable length array */
+ sz = determine_word_size(c->item_size, 0);
+
+ where = rindex + c->item_size - sz;
+ r = message_peek_body(m, &where, 1, sz, &q);
+ if (r < 0)
+ return r;
+ if (r == 0)
+ return -EBADMSG;
+
+ framing = read_word_le(q, sz);
+ if (framing > c->item_size - sz)
+ return -EBADMSG;
+ if ((c->item_size - framing) % sz != 0)
+ return -EBADMSG;
+
+ *n_offsets = (c->item_size - framing) / sz;
+
+ where = rindex + framing;
+ r = message_peek_body(m, &where, 1, *n_offsets * sz, &q);
+ if (r < 0)
+ return r;
+ if (r == 0)
+ return -EBADMSG;
+
+ *offsets = new(size_t, *n_offsets);
+ if (!*offsets)
+ return -ENOMEM;
+
+ for (i = 0; i < *n_offsets; i++) {
+ size_t x;
+
+ x = read_word_le((uint8_t*) q + i * sz, sz);
+ if (x > c->item_size - sz)
+ return -EBADMSG;
+ if (x < p)
+ return -EBADMSG;
+
+ (*offsets)[i] = rindex + x;
+ p = x;
+ }
+
+ *item_size = (*offsets)[0] - rindex;
+ }
+
+ m->rindex = rindex;
+
+ if (c->enclosing != SD_BUS_TYPE_ARRAY)
+ c->index += 1 + strlen(contents);
return 1;
}
@@ -3097,7 +3368,8 @@ static int bus_message_enter_array(
static int bus_message_enter_variant(
sd_bus_message *m,
struct bus_container *c,
- const char *contents) {
+ const char *contents,
+ size_t *item_size) {
size_t rindex;
uint8_t l;
@@ -3107,6 +3379,7 @@ static int bus_message_enter_variant(
assert(m);
assert(c);
assert(contents);
+ assert(item_size);
if (!signature_is_single(contents, false))
return -EINVAL;
@@ -3115,41 +3388,239 @@ static int bus_message_enter_variant(
return -EINVAL;
if (!c->signature || c->signature[c->index] == 0)
- return 0;
+ return -ENXIO;
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 (BUS_MESSAGE_IS_GVARIANT(m)) {
+ size_t k, where;
+
+ k = strlen(contents);
+ if (1+k > c->item_size)
+ return -EBADMSG;
+
+ 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 (*(char*) q != 0)
+ return -EBADMSG;
+
+ if (memcmp((uint8_t*) q+1, contents, k))
+ return -ENXIO;
+
+ *item_size = c->item_size - (1+k);
+
+ } else {
+ r = message_peek_body(m, &rindex, 1, 1, &q);
+ if (r < 0)
+ return r;
+ if (r == 0)
+ return -EBADMSG;
+
+ l = *(uint8_t*) q;
+ r = message_peek_body(m, &rindex, 1, l+1, &q);
+ if (r < 0)
+ return r;
+ if (r == 0)
+ return -EBADMSG;
+
+ if (!validate_signature(q, l))
+ return -EBADMSG;
+
+ if (!streq(q, contents))
+ return -ENXIO;
+ }
+
+ m->rindex = rindex;
+
+ if (c->enclosing != SD_BUS_TYPE_ARRAY)
+ c->index++;
+
+ return 1;
+}
+
+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;
+
+ assert(m);
+ assert(signature);
+ assert(item_size);
+ assert(offsets);
+ assert(n_offsets);
+
+ sz = determine_word_size(size, 0);
+
+ /* 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. */
+
+ p = 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;
+ if (r == 0 && p[n] != 0) /* except the last item */
+ n_variable ++;
+ n_total++;
+
+ p += n;
+ }
+
+ if (size < n_variable * sz)
+ return -EBADMSG;
+
+ where = m->rindex + size - (n_variable * sz);
+ r = message_peek_body(m, &where, 1, n_variable * sz, &q);
if (r < 0)
return r;
if (r == 0)
return -EBADMSG;
- if (!validate_signature(q, l))
- return -EBADMSG;
+ v = n_variable;
- if (!streq(q, contents))
- return -ENXIO;
+ *offsets = new(size_t, n_total);
+ if (!*offsets)
+ return -ENOMEM;
- if (c->enclosing != SD_BUS_TYPE_ARRAY)
- c->index++;
+ *n_offsets = 0;
- m->rindex = rindex;
+ /* Second, loop again and build an offset table */
+ p = signature;
+ while (*p != 0) {
+ size_t n, offset;
+ int k;
- return 1;
+ r = signature_element_length(p, &n);
+ if (r < 0)
+ return r;
+ else {
+ char t[n+1];
+
+ memcpy(t, p, n);
+ t[n] = 0;
+
+ k = bus_gvariant_get_size(t);
+ if (k < 0) {
+ size_t x;
+
+ /* variable size */
+ if (v > 0) {
+ v--;
+
+ 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);
+
+ offset = m->rindex + x;
+
+ } else {
+ size_t align;
+
+ /* fixed size */
+ align = bus_gvariant_get_alignment(t);
+ assert(align > 0);
+
+ offset = (*n_offsets == 0 ? m->rindex : ALIGN_TO((*offsets)[*n_offsets-1], align)) + k;
+ }
+ }
+
+ previous = (*offsets)[(*n_offsets)++] = offset;
+ p += n;
+ }
+
+ assert(v == 0);
+ assert(*n_offsets == n_total);
+
+ *item_size = (*offsets)[0] - m->rindex;
+ return 0;
+}
+
+static int enter_struct_or_dict_entry(
+ sd_bus_message *m,
+ struct bus_container *c,
+ const char *contents,
+ size_t *item_size,
+ size_t **offsets,
+ size_t *n_offsets) {
+
+ int r;
+
+ assert(m);
+ assert(c);
+ assert(contents);
+ assert(item_size);
+ assert(offsets);
+ assert(n_offsets);
+
+ if (!BUS_MESSAGE_IS_GVARIANT(m)) {
+
+ /* dbus1 */
+ r = message_peek_body(m, &m->rindex, 8, 0, NULL);
+ if (r <= 0)
+ return r;
+
+ } else if (c->item_size <= 0) {
+
+ /* 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 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;
@@ -3157,12 +3628,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);
@@ -3171,8 +3645,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)
@@ -3184,7 +3658,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;
@@ -3209,8 +3686,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)
@@ -3226,6 +3703,8 @@ _public_ int sd_bus_message_enter_container(sd_bus_message *m,
uint32_t *array_size = NULL;
char *signature;
size_t before;
+ size_t *offsets = NULL;
+ size_t n_offsets = 0, item_size = 0;
int r;
assert_return(m, -EINVAL);
@@ -3291,18 +3770,19 @@ _public_ int sd_bus_message_enter_container(sd_bus_message *m,
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;
}
@@ -3311,36 +3791,57 @@ _public_ int sd_bus_message_enter_container(sd_bus_message *m,
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;
}
_public_ int sd_bus_message_exit_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, -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 -EBUSY;
}
free(c->signature);
+ free(c->offsets);
m->n_containers--;
+ c = message_get_container(m);
+
+ r = container_next_item(m, c, &m->rindex);
+ if (r < 0)
+ return r;
+
return 1;
}
@@ -3359,6 +3860,7 @@ static void message_quit_container(sd_bus_message *m) {
/* Free container */
free(c->signature);
+ free(c->offsets);
m->n_containers--;
/* Correct index of new top-level container */
@@ -3447,27 +3949,68 @@ _public_ int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char
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 (r == 0)
+ goto eof;
+
+ 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;
+ if (r == 0)
+ goto eof;
- *contents = q;
+ l = *(uint8_t*) q;
+ r = message_peek_body(m, &rindex, 1, l+1, &q);
+ if (r < 0)
+ return r;
+ if (r == 0)
+ return -EBADMSG;
+
+ if (!validate_signature(q, l))
+ return -EBADMSG;
+
+ *contents = q;
+ }
}
if (type)
@@ -3495,12 +4038,12 @@ _public_ int sd_bus_message_rewind(sd_bus_message *m, int complete) {
if (complete) {
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;
}
@@ -3880,16 +4423,25 @@ _public_ int sd_bus_message_read_array(sd_bus_message *m,
assert_return(size, -EINVAL);
assert_return(!BUS_MESSAGE_NEED_BSWAP(m), -ENOTSUP);
- align = bus_type_get_alignment(type);
- if (align < 0)
- return align;
-
r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
if (r <= 0)
return r;
c = message_get_container(m);
- sz = BUS_MESSAGE_BSWAP32(m, *c->array_size);
+
+ if (BUS_MESSAGE_IS_GVARIANT(m)) {
+ align = bus_gvariant_get_alignment(CHAR_TO_STR(type));
+ if (align < 0)
+ return align;
+
+ sz = c->item_size;
+ } else {
+ align = bus_type_get_alignment(type);
+ if (align < 0)
+ return align;
+
+ sz = BUS_MESSAGE_BSWAP32(m, *c->array_size);
+ }
if (sz == 0)
/* Zero length array, let's return some aligned
@@ -3936,6 +4488,7 @@ static int message_peek_fields(
static int message_peek_field_uint32(
sd_bus_message *m,
size_t *ri,
+ size_t item_size,
uint32_t *ret) {
int r;
@@ -3944,6 +4497,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;
@@ -3958,6 +4516,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;
@@ -3967,13 +4526,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))
@@ -3995,6 +4566,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;
@@ -4004,14 +4576,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;
@@ -4034,6 +4618,7 @@ static int message_skip_fields(
assert(m);
assert(ri);
assert(signature);
+ assert(!BUS_MESSAGE_IS_GVARIANT(m));
original_index = *ri;
@@ -4051,7 +4636,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;
@@ -4059,7 +4644,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;
@@ -4067,7 +4652,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;
@@ -4105,7 +4690,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)
@@ -4125,7 +4710,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;
@@ -4163,20 +4748,92 @@ 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;
+ unsigned i = 0;
assert(m);
- for (ri = 0; ri < BUS_MESSAGE_FIELDS_SIZE(m); ) {
+ if (BUS_MESSAGE_IS_GVARIANT(m)) {
+ void *q;
+
+ sz = determine_word_size(BUS_MESSAGE_FIELDS_SIZE(m), 0);
+ if (sz > 0) {
+ size_t framing;
+
+ ri = BUS_MESSAGE_FIELDS_SIZE(m) - sz;
+ r = message_peek_fields(m, &ri, 1, sz, &q);
+ if (r < 0)
+ return r;
+
+ framing = read_word_le(q, sz);
+ if (framing >= BUS_MESSAGE_FIELDS_SIZE(m) - sz)
+ return -EBADMSG;
+ if ((BUS_MESSAGE_FIELDS_SIZE(m) - framing) % sz != 0)
+ return -EBADMSG;
+
+ ri = framing;
+ r = message_peek_fields(m, &ri, 1, BUS_MESSAGE_FIELDS_SIZE(m) - framing, &offsets);
+ if (r < 0)
+ return r;
+
+ n_offsets = (BUS_MESSAGE_FIELDS_SIZE(m) - framing) / sz;
+ }
+ }
+
+ 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 (BUS_MESSAGE_IS_GVARIANT(m)) {
+ if (i >= n_offsets)
+ break;
+
+ if (i == 0)
+ ri = 0;
+ else
+ ri = ALIGN_TO(read_word_le((uint8_t*) offsets + (i-1)*sz, sz), 8);
+ }
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)) {
+ size_t where, end;
+ char *b;
+ void *q;
+
+ end = read_word_le((uint8_t*) offsets + i*sz, sz);
+
+ if (end < ri)
+ return -EBADMSG;
+
+ 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;
+
+ b = memrchr(q, 0, item_size);
+ if (!b)
+ return -EBADMSG;
+
+ sig = strndup(b+1, item_size - (b+1-(char*) q));
+ if (!sig)
+ return -ENOMEM;
+
+ 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:
@@ -4190,7 +4847,7 @@ int bus_message_parse_fields(sd_bus_message *m) {
if (!streq(signature, "o"))
return -EBADMSG;
- r = message_peek_field_string(m, object_path_is_valid, &ri, &m->path);
+ r = message_peek_field_string(m, object_path_is_valid, &ri, item_size, &m->path);
break;
case BUS_MESSAGE_HEADER_INTERFACE:
@@ -4201,7 +4858,7 @@ int bus_message_parse_fields(sd_bus_message *m) {
if (!streq(signature, "s"))
return -EBADMSG;
- r = message_peek_field_string(m, interface_name_is_valid, &ri, &m->interface);
+ r = message_peek_field_string(m, interface_name_is_valid, &ri, item_size, &m->interface);
break;
case BUS_MESSAGE_HEADER_MEMBER:
@@ -4212,7 +4869,7 @@ int bus_message_parse_fields(sd_bus_message *m) {
if (!streq(signature, "s"))
return -EBADMSG;
- r = message_peek_field_string(m, member_name_is_valid, &ri, &m->member);
+ r = message_peek_field_string(m, member_name_is_valid, &ri, item_size, &m->member);
break;
case BUS_MESSAGE_HEADER_ERROR_NAME:
@@ -4223,7 +4880,7 @@ int bus_message_parse_fields(sd_bus_message *m) {
if (!streq(signature, "s"))
return -EBADMSG;
- r = message_peek_field_string(m, error_name_is_valid, &ri, &m->error.name);
+ r = message_peek_field_string(m, error_name_is_valid, &ri, item_size, &m->error.name);
if (r >= 0)
m->error._need_free = -1;
@@ -4237,7 +4894,7 @@ int bus_message_parse_fields(sd_bus_message *m) {
if (!streq(signature, "s"))
return -EBADMSG;
- r = message_peek_field_string(m, service_name_is_valid, &ri, &m->destination);
+ r = message_peek_field_string(m, service_name_is_valid, &ri, item_size, &m->destination);
break;
case BUS_MESSAGE_HEADER_SENDER:
@@ -4248,7 +4905,7 @@ int bus_message_parse_fields(sd_bus_message *m) {
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, service_name_is_valid, &ri, item_size, &m->sender);
if (r >= 0 && m->sender[0] == ':' && m->bus && m->bus->bus_client && !m->bus->is_kernel) {
m->creds.unique_name = (char*) m->sender;
@@ -4268,7 +4925,7 @@ int bus_message_parse_fields(sd_bus_message *m) {
if (!streq(signature, "g"))
return -EBADMSG;
- r = message_peek_field_signature(m, &ri, &s);
+ r = message_peek_field_signature(m, &ri, item_size, &s);
if (r < 0)
return r;
@@ -4288,7 +4945,7 @@ int bus_message_parse_fields(sd_bus_message *m) {
if (!streq(signature, "u"))
return -EBADMSG;
- r = message_peek_field_uint32(m, &ri, &m->reply_serial);
+ r = message_peek_field_uint32(m, &ri, item_size, &m->reply_serial);
if (r < 0)
return r;
@@ -4304,7 +4961,7 @@ int bus_message_parse_fields(sd_bus_message *m) {
if (!streq(signature, "u"))
return -EBADMSG;
- r = message_peek_field_uint32(m, &ri, &unix_fds);
+ r = message_peek_field_uint32(m, &ri, item_size, &unix_fds);
if (r < 0)
return -EBADMSG;
@@ -4314,11 +4971,14 @@ int bus_message_parse_fields(sd_bus_message *m) {
break;
default:
- r = message_skip_fields(m, &ri, (uint32_t) -1, (const char **) &signature);
+ if (!BUS_MESSAGE_IS_GVARIANT(m))
+ r = message_skip_fields(m, &ri, (uint32_t) -1, (const char **) &signature);
}
if (r < 0)
return r;
+
+ i++;
}
if (m->n_fds != unix_fds)
@@ -4354,6 +5014,20 @@ int bus_message_parse_fields(sd_bus_message *m) {
break;
}
+ 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);
@@ -4363,46 +5037,26 @@ int bus_message_parse_fields(sd_bus_message *m) {
static int bus_message_close_header(sd_bus_message *m) {
uint8_t *a;
- size_t z, i;
+ size_t sz, i;
assert(m);
- if (!m->is_gvariant)
+ if (!BUS_MESSAGE_IS_GVARIANT(m))
return 0;
- if (m->n_header_offsets <= 1)
+ 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;
+ sz = determine_word_size(m->header->fields_size, m->n_header_offsets);
- a = message_extend_fields(m, 1, z * m->n_header_offsets, false);
+ 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++) {
- if (z == 1)
- ((uint8_t*) a)[i] = (uint8_t) m->header_offsets[i];
- else if (z == 2) {
- uint16_t x = htole16((uint16_t) m->header_offsets[i]);
- memcpy(a + 2*i, &x, 2);
- } else if (z == 4) {
- uint32_t x = htole32((uint32_t) m->header_offsets[i]);
- memcpy(a + 4*i, &x, 4);
- } else if (z == 8) {
- uint64_t x = htole64((uint64_t) m->header_offsets[i]);
- memcpy(a + 8*i, &x, 8);
- } else
- assert_not_reached("unknown type");
- }
+ for (i = 0; i < m->n_header_offsets; i++)
+ write_word_le(a + sz*i, sz, m->header_offsets[i]);
return 0;
}
@@ -4453,6 +5107,8 @@ int bus_message_seal(sd_bus_message *m, uint64_t serial) {
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
@@ -4475,7 +5131,11 @@ int bus_message_seal(sd_bus_message *m, uint64_t serial) {
}
}
- m->header->serial = serial;
+ 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;
diff --git a/src/libsystemd-bus/bus-message.h b/src/libsystemd-bus/bus-message.h
index b862cb9..75a560b 100644
--- a/src/libsystemd-bus/bus-message.h
+++ b/src/libsystemd-bus/bus-message.h
@@ -34,18 +34,20 @@
struct bus_container {
char enclosing;
+ bool need_offsets:1;
+ /* Indexes into the signature string */
unsigned index, saved_index;
-
char *signature;
- uint32_t *array_size;
- size_t before, begin;
+ size_t before, begin, end;
- size_t *offsets;
- size_t n_offsets, n_allocated;
+ /* dbus1: pointer to the array size value, if this is a value */
+ uint32_t *array_size;
- bool need_offsets;
+ /* gvariant: list of offsets to end of children if this is struct/dict entry/array */
+ size_t *offsets, n_offsets, n_offsets_allocated, offset_index;
+ size_t item_size;
};
struct bus_header {
@@ -98,7 +100,6 @@ struct sd_bus_message {
bool free_fds:1;
bool release_kdbus:1;
bool poisoned:1;
- bool is_gvariant:1;
struct bus_header *header;
struct bus_body_part body;
@@ -180,6 +181,10 @@ static inline void* BUS_MESSAGE_FIELDS(sd_bus_message *m) {
return (uint8_t*) m->header + sizeof(struct bus_header);
}
+static inline bool BUS_MESSAGE_IS_GVARIANT(sd_bus_message *m) {
+ return m->header->version == 2;
+}
+
int bus_message_seal(sd_bus_message *m, uint64_t serial);
int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz);
int bus_message_read_strv_extend(sd_bus_message *m, char ***l);
diff --git a/src/libsystemd-bus/kdbus.h b/src/libsystemd-bus/kdbus.h
index 1138c01..5d5467a 100644
--- a/src/libsystemd-bus/kdbus.h
+++ b/src/libsystemd-bus/kdbus.h
@@ -331,8 +331,7 @@ enum kdbus_msg_flags {
*/
enum kdbus_payload_type {
KDBUS_PAYLOAD_KERNEL,
- KDBUS_PAYLOAD_DBUS1 = 0x4442757356657231ULL, /* 'DBusVer1' */
- KDBUS_PAYLOAD_GVARIANT = 0x4756617269616e74ULL, /* 'GVariant' */
+ KDBUS_PAYLOAD_DBUS = 0x4442757356657231ULL, /* 'DBusVer1' */
};
/**
@@ -591,7 +590,7 @@ enum kdbus_name_list_flags {
* @offset: The returned offset in the caller's pool buffer.
* The user must use KDBUS_CMD_FREE to free the
* allocated memory.
- *
+ *
* This structure is used with the KDBUS_CMD_NAME_LIST ioctl.
*/
struct kdbus_cmd_name_list {
diff --git a/src/libsystemd-bus/test-bus-gvariant.c b/src/libsystemd-bus/test-bus-gvariant.c
index f8698cc..57015ae 100644
--- a/src/libsystemd-bus/test-bus-gvariant.c
+++ b/src/libsystemd-bus/test-bus-gvariant.c
@@ -29,9 +29,11 @@
#include "bus-util.h"
#include "bus-internal.h"
#include "bus-message.h"
+#include "bus-dump.h"
static void test_bus_gvariant_is_fixed_size(void) {
assert(bus_gvariant_is_fixed_size("") > 0);
+ assert(bus_gvariant_is_fixed_size("()") > 0);
assert(bus_gvariant_is_fixed_size("y") > 0);
assert(bus_gvariant_is_fixed_size("u") > 0);
assert(bus_gvariant_is_fixed_size("b") > 0);
@@ -54,8 +56,41 @@ static void test_bus_gvariant_is_fixed_size(void) {
assert(bus_gvariant_is_fixed_size("((u)yyy(b(iiivi)))") == 0);
}
+static void test_bus_gvariant_get_size(void) {
+ assert(bus_gvariant_get_size("") == 0);
+ assert(bus_gvariant_get_size("()") == 0);
+ assert(bus_gvariant_get_size("y") == 1);
+ assert(bus_gvariant_get_size("u") == 4);
+ assert(bus_gvariant_get_size("b") == 1);
+ assert(bus_gvariant_get_size("n") == 2);
+ assert(bus_gvariant_get_size("q") == 2);
+ assert(bus_gvariant_get_size("i") == 4);
+ assert(bus_gvariant_get_size("t") == 8);
+ assert(bus_gvariant_get_size("d") == 8);
+ assert(bus_gvariant_get_size("s") < 0);
+ assert(bus_gvariant_get_size("o") < 0);
+ assert(bus_gvariant_get_size("g") < 0);
+ assert(bus_gvariant_get_size("h") == 4);
+ assert(bus_gvariant_get_size("ay") < 0);
+ assert(bus_gvariant_get_size("v") < 0);
+ assert(bus_gvariant_get_size("(u)") == 4);
+ assert(bus_gvariant_get_size("(uuuuy)") == 20);
+ assert(bus_gvariant_get_size("(uusuuy)") < 0);
+ assert(bus_gvariant_get_size("a{ss}") < 0);
+ assert(bus_gvariant_get_size("((u)yyy(b(iiii)))") == 28);
+ assert(bus_gvariant_get_size("((u)yyy(b(iiivi)))") < 0);
+ assert(bus_gvariant_get_size("((b)(t))") == 16);
+ assert(bus_gvariant_get_size("((b)(b)(t))") == 16);
+ assert(bus_gvariant_get_size("(bt)") == 16);
+ assert(bus_gvariant_get_size("((t)(b))") == 16);
+ assert(bus_gvariant_get_size("(tb)") == 16);
+ assert(bus_gvariant_get_size("((b)(b))") == 2);
+ assert(bus_gvariant_get_size("((t)(t))") == 16);
+}
+
static void test_bus_gvariant_get_alignment(void) {
assert(bus_gvariant_get_alignment("") == 1);
+ assert(bus_gvariant_get_alignment("()") == 1);
assert(bus_gvariant_get_alignment("y") == 1);
assert(bus_gvariant_get_alignment("b") == 1);
assert(bus_gvariant_get_alignment("u") == 4);
@@ -79,18 +114,32 @@ static void test_bus_gvariant_get_alignment(void) {
assert(bus_gvariant_get_alignment("(ss)") == 1);
assert(bus_gvariant_get_alignment("(ssu)") == 4);
assert(bus_gvariant_get_alignment("a(ssu)") == 4);
+ assert(bus_gvariant_get_alignment("(u)") == 4);
+ assert(bus_gvariant_get_alignment("(uuuuy)") == 4);
+ assert(bus_gvariant_get_alignment("(uusuuy)") == 4);
+ assert(bus_gvariant_get_alignment("a{ss}") == 1);
+ assert(bus_gvariant_get_alignment("((u)yyy(b(iiii)))") == 4);
+ assert(bus_gvariant_get_alignment("((u)yyy(b(iiivi)))") == 8);
+ assert(bus_gvariant_get_alignment("((b)(t))") == 8);
+ assert(bus_gvariant_get_alignment("((b)(b)(t))") == 8);
+ assert(bus_gvariant_get_alignment("(bt)") == 8);
+ assert(bus_gvariant_get_alignment("((t)(b))") == 8);
+ assert(bus_gvariant_get_alignment("(tb)") == 8);
+ assert(bus_gvariant_get_alignment("((b)(b))") == 1);
+ assert(bus_gvariant_get_alignment("((t)(t))") == 8);
}
static void test_marshal(void) {
- _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
+ _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *n = NULL;
_cleanup_bus_unref_ sd_bus *bus = NULL;
+ _cleanup_free_ void *blob;
+ size_t sz;
assert_se(sd_bus_open_system(&bus) >= 0);
- bus->use_gvariant = true; /* dirty hack */
+ bus->message_version = 2; /* dirty hack to enable gvariant*/
assert_se(sd_bus_message_new_method_call(bus, "a.service.name", "/an/object/path/which/is/really/really/long/so/that/we/hit/the/eight/bit/boundary/by/quite/some/margin/to/test/this/stuff/that/it/really/works", "an.interface.name", "AMethodName", &m) >= 0);
- /* assert_se(sd_bus_message_append(m, "ssy(sts)v", "first-string-parameter", "second-string-parameter", 9, "a", (uint64_t) 7777, "b", "(su)", "xxx", 4712) >= 0); */
assert_se(sd_bus_message_append(m,
"a(usv)", 2,
4711, "first-string-parameter", "(st)", "X", (uint64_t) 1111,
@@ -121,11 +170,20 @@ static void test_marshal(void) {
}
#endif
+ assert_se(bus_message_dump(m, NULL, true) >= 0);
+
+ assert_se(bus_message_get_blob(m, &blob, &sz) >= 0);
+
+ assert_se(bus_message_from_malloc(NULL, blob, sz, NULL, 0, NULL, NULL, &n) >= 0);
+ blob = NULL;
+
+ assert_se(bus_message_dump(n, NULL, true) >= 0);
}
int main(int argc, char *argv[]) {
test_bus_gvariant_is_fixed_size();
+ test_bus_gvariant_get_size();
test_bus_gvariant_get_alignment();
test_marshal();
commit d3a485135a98184cba28992752834a1bb4769003
Author: Lennart Poettering <lennart at poettering.net>
Date: Mon Dec 9 22:51:35 2013 +0100
extend CODING_STYLE document a bit
diff --git a/CODING_STYLE b/CODING_STYLE
index c5f1e2e..996897b 100644
--- a/CODING_STYLE
+++ b/CODING_STYLE
@@ -4,7 +4,8 @@
- Variables and functions *must* be static, unless they have a
prototype, and are supposed to be exported.
-- structs in MixedCase, variables + functions in lower_case
+- structs in MixedCase (with exceptions, such as public API structs),
+ variables + functions in lower_case.
- The destructors always unregister the object from the next bigger
object, not the other way around
@@ -22,30 +23,35 @@
more than one cause, it *really* should have "int" as return value
for the error code.
-- Don't bother with error checking if writing to stdout/stderr worked.
+- Don't bother with error checking whether writing to stdout/stderr
+ worked.
- Do not log errors from "library" code, only do so from "main
- program" code.
+ program" code. (With one exception: it's OK to log with DEBUG level
+ from any code, with the exception of maybe inner loops).
- Always check OOM. There's no excuse. In program code you can use
- "log_oom()" for then printing a short message.
+ "log_oom()" for then printing a short message, but not in "library" code.
- Do not issue NSS requests (that includes user name and host name
- lookups) from the main daemon as this might trigger deadlocks when
- those lookups involve synchronously talking to services that we
- would need to start up
+ lookups) from PID 1 as this might trigger deadlocks when those
+ lookups involve synchronously talking to services that we would need
+ to start up
-- Don't synchronously talk to any other service, due to risk of
- deadlocks
+- Don't synchronously talk to any other service from PID 1, due to
+ risk of deadlocks
- Avoid fixed sized string buffers, unless you really know the maximum
size and that maximum size is small. They are a source of errors,
- since they result in strings to be truncated. Often it is nicer to
- use dynamic memory, or alloca(). If you do allocate fixed size
- strings on the stack, then it's probably only OK if you either use a
- maximum size such as LINE_MAX, or count in detail the maximum size a
- string can have. Or in other words, if you use "char buf[256]" then
- you are likely doing something wrong!
+ since they possibly result in truncated strings. Often it is nicer
+ to use dynamic memory, alloca() or VLAs. If you do allocate fixed
+ size strings on the stack, then it's probably only OK if you either
+ use a maximum size such as LINE_MAX, or count in detail the maximum
+ size a string can have. (DECIMAL_STR_MAX and DECIMAL_STR_WIDTH
+ macros are your friends for this!)
+
+ Or in other words, if you use "char buf[256]" then you are likely
+ doing something wrong!
- Stay uniform. For example, always use "usec_t" for time
values. Don't usec mix msec, and usec and whatnot.
@@ -113,11 +119,51 @@
}
- Use "goto" for cleaning up, and only use it for that. i.e. you may
- only jump to the end of a function, and little else.
+ only jump to the end of a function, and little else. Never jump
+ backwards!
- Think about the types you use. If a value cannot sensibly be
negative don't use "int", but use "unsigned".
- Don't use types like "short". They *never* make sense. Use ints,
longs, long longs, all in unsigned+signed fashion, and the fixed
- size types uint32_t and so on, but nothing else.
+ size types uint32_t and so on, as well as size_t but nothing else.
+
+- Public API calls (i.e. functions exported by our shared libraries)
+ must be marked "_public_" and need to be prefixed with "sd_". No
+ other functions should be prefixed like that.
+
+- In public API calls you *must* validate all your input arguments for
+ programming error with assert_return() and return a sensible return
+ code. In all other calls it is recommended to check for programming
+ errors with a more brutal assert(). We are more forgiving to public
+ users then for ourselves! Note that assert() and assert_return()
+ really only should be used for detecting programming errors, not for
+ runtime errors. assert() and assert_return() by usage of _likely_()
+ inform the compiler that he shouldn't expect these checks to fail,
+ and they inform fellow programmers about the expected validity and
+ range of parameters.
+
+- Never use strtol(), atoi() and similar calls. Use safe_atoli(),
+ safe_atou32() and suchlike instead. They are much nicer to use in
+ most cases and correctly check for parsing errors.
+
+- For every function you add, think about whether it is a "logging"
+ function or a "non-logging" function. "Logging" functions do logging
+ on their own, "non-logging" function never log on their own and
+ expect their callers to log. All functions in "library" code,
+ i.e. in src/shared/ and suchlike must be "non-logging". Everytime a
+ "logging" function calls a "non-logging" function it should log
+ about the resulting errors. If a "logging" function calls another
+ "logging" function, then it should not generate log messages, so
+ that log messages are not generated twice for the same errors.
+
+- Avoid static variables, except for caches and very few other
+ cases. Think about thread-safety! While most of our code is never
+ used in threaded environments at least the library code should make
+ sure it works correctly in them. Instead of doing a lot of locking
+ for that we tend to prefer using TLS to do per-thread caching (which
+ only works for small, fixed-size cache objects), or we disable
+ caching for any thread that is not the main thread. Use
+ is_main_thread() to detect whether the calling thread is the main
+ thread.
More information about the systemd-commits
mailing list