X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Flibsystemd-bus%2Fbus-message.c;h=4c0e27f9446d96d19c563d30429c6eefa697ffb8;hb=ea6ad56836bcbb09038eb1c0912e97dc8686b1d8;hp=bc67c323808a6930729e4a5ff512793893bf6687;hpb=a3e7f417d72ba3251fd6b3a228a2721a4b725a03;p=elogind.git diff --git a/src/libsystemd-bus/bus-message.c b/src/libsystemd-bus/bus-message.c index bc67c3238..4c0e27f94 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); @@ -129,7 +130,7 @@ static void message_free(sd_bus_message *m) { uint64_t off; off = (uint8_t *)m->kdbus - (uint8_t *)m->bus->kdbus_buffer; - ioctl(m->bus->input_fd, KDBUS_CMD_MSG_RELEASE, &off); + ioctl(m->bus->input_fd, KDBUS_CMD_FREE, &off); } if (m->bus) @@ -143,20 +144,16 @@ static void message_free(sd_bus_message *m) { if (m->iovec != m->iovec_fixed) free(m->iovec); - free(m->cmdline_array); - message_reset_containers(m); free(m->root_container.signature); free(m->peeked_signature); - free(m->unit); - free(m->user_unit); - free(m->session); + bus_creds_done(&m->creds); 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; @@ -209,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: @@ -228,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" */ + + if (m->is_gvariant) { - p[0] = h; - p[1] = 1; - p[2] = type; - p[3] = 0; + /* (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; - ((uint32_t*) p)[1] = l; - memcpy(p + 8, s, l + 1); + 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; + 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; } @@ -262,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" */ + + 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; - p[0] = h; - p[1] = 1; - p[2] = SD_BUS_TYPE_SIGNATURE; - p[3] = 0; - p[4] = l; - memcpy(p + 5, s, l + 1); + 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; + if (ret) + *ret = (const char*) p + 5; + } return 0; } @@ -289,22 +325,37 @@ 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; } int bus_message_from_header( + sd_bus *bus, void *buffer, size_t length, int *fds, @@ -335,8 +386,8 @@ int bus_message_from_header( if (h->type == _SD_BUS_MESSAGE_TYPE_INVALID) return -EBADMSG; - if (h->endian != SD_BUS_LITTLE_ENDIAN && - h->endian != SD_BUS_BIG_ENDIAN) + if (h->endian != BUS_LITTLE_ENDIAN && + h->endian != BUS_BIG_ENDIAN) return -EBADMSG; a = ALIGN(sizeof(sd_bus_message)) + ALIGN(extra); @@ -357,22 +408,28 @@ int bus_message_from_header( 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)) + ALIGN(extra); - 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, @@ -382,9 +439,10 @@ int bus_message_from_malloc( sd_bus_message **ret) { sd_bus_message *m; + size_t sz; int r; - r = bus_message_from_header(buffer, length, fds, n_fds, ucred, label, 0, &m); + r = bus_message_from_header(bus, buffer, length, fds, n_fds, ucred, label, 0, &m); if (r < 0) return r; @@ -393,11 +451,14 @@ int bus_message_from_malloc( goto fail; } - m->n_body_parts = 1; - m->body.data = (uint8_t*) buffer + sizeof(struct bus_header) + ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)); - m->body.size = length - sizeof(struct bus_header) - ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)); - m->body.sealed = true; - m->body.memfd = -1; + 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; @@ -429,10 +490,11 @@ 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 = m->is_gvariant = bus ? bus->use_gvariant : false; if (bus) m->bus = sd_bus_ref(bus); @@ -440,7 +502,7 @@ static sd_bus_message *message_new(sd_bus *bus, uint8_t type) { return m; } -int sd_bus_message_new_signal( +_public_ int sd_bus_message_new_signal( sd_bus *bus, const char *path, const char *interface, @@ -450,30 +512,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; @@ -485,7 +542,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, @@ -496,38 +553,32 @@ int sd_bus_message_new_method_call( sd_bus_message *t; int r; - if (destination && !service_name_is_valid(destination)) - return -EINVAL; - if (!object_path_is_valid(path)) - return -EINVAL; - if (interface && !interface_name_is_valid(interface)) - return -EINVAL; - if (!member_name_is_valid(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; } @@ -541,7 +592,6 @@ fail: } static int message_new_reply( - sd_bus *bus, sd_bus_message *call, uint8_t type, sd_bus_message **m) { @@ -549,35 +599,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->destination); + 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; @@ -587,16 +633,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) { @@ -604,16 +648,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; @@ -623,6 +665,8 @@ int sd_bus_message_new_method_error( goto fail; } + t->error._need_free = -1; + *m = t; return 0; @@ -631,54 +675,57 @@ fail: return r; } -int sd_bus_message_new_method_errorf( - sd_bus *bus, +_public_ int sd_bus_message_new_method_errorf( sd_bus_message *call, sd_bus_message **m, const char *name, const char *format, ...) { - sd_bus_message *t; + _cleanup_free_ sd_bus_error error = SD_BUS_ERROR_NULL; va_list ap; - int r; - if (!name) - return -EINVAL; - if (!m) - return -EINVAL; + assert_return(name, -EINVAL); + assert_return(m, -EINVAL); - r = message_new_reply(bus, call, SD_BUS_MESSAGE_TYPE_METHOD_ERROR, &t); - if (r < 0) - return r; + va_start(ap, format); + bus_error_setfv(&error, name, format, ap); + va_end(ap); - r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, name, &t->error.name); - if (r < 0) - goto fail; + return sd_bus_message_new_method_error(call, &error, m); +} - if (format) { - _cleanup_free_ char *message = NULL; +_public_ int sd_bus_message_new_method_errno( + sd_bus_message *call, + int error, + const sd_bus_error *p, + sd_bus_message **m) { - va_start(ap, format); - r = vasprintf(&message, format, ap); - va_end(ap); + _cleanup_free_ sd_bus_error berror = SD_BUS_ERROR_NULL; - if (r < 0) { - r = -ENOMEM; - goto fail; - } + if (sd_bus_error_is_set(p)) + return sd_bus_message_new_method_error(call, p, m); - r = message_append_basic(t, SD_BUS_TYPE_STRING, message, (const void**) &t->error.message); - if (r < 0) - goto fail; - } + sd_bus_error_set_errno(&berror, error); - *m = t; - return 0; + return sd_bus_message_new_method_error(call, &berror, m); +} -fail: - message_free(t); - return r; +_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( @@ -693,24 +740,24 @@ int bus_message_new_synthetic_error( assert(sd_bus_error_is_set(e)); assert(m); - t = message_new(bus, SD_BUS_MESSAGE_TYPE_METHOD_ERROR); + t = message_new(bus, SD_BUS_MESSAGE_METHOD_ERROR); if (!t) return -ENOMEM; - t->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED; + t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED; t->reply_serial = serial; - 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 (bus && bus->unique_name) { - r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, bus->unique_name, &t->destination); + 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, 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; @@ -720,6 +767,8 @@ int bus_message_new_synthetic_error( goto fail; } + t->error._need_free = -1; + *m = t; return 0; @@ -728,9 +777,8 @@ fail: return r; } -sd_bus_message* sd_bus_message_ref(sd_bus_message *m) { - if (!m) - return NULL; +_public_ sd_bus_message* sd_bus_message_ref(sd_bus_message *m) { + assert_return(m, NULL); assert(m->n_ref > 0); m->n_ref++; @@ -738,9 +786,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--; @@ -751,450 +798,191 @@ 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 (!uid) - return -EINVAL; - if (!m->uid_valid) - return -ESRCH; +_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); - *uid = m->uid; + *usec = m->monotonic; return 0; } -int sd_bus_message_get_gid(sd_bus_message *m, gid_t *gid) { - if (!m) - return -EINVAL; - if (!gid) - return -EINVAL; - if (!m->gid_valid) - return -ESRCH; +_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); - *gid = m->gid; + *usec = m->realtime; return 0; } -int sd_bus_message_get_pid(sd_bus_message *m, pid_t *pid) { - if (!m) - return -EINVAL; - if (!pid) - return -EINVAL; - if (m->pid <= 0) - return -ESRCH; - - *pid = m->pid; - return 0; -} +_public_ sd_bus_creds *sd_bus_message_get_creds(sd_bus_message *m) { + assert_return(m, NULL); -int sd_bus_message_get_tid(sd_bus_message *m, pid_t *tid) { - if (!m) - return -EINVAL; - if (!tid) - return -EINVAL; - if (m->tid <= 0) - return -ESRCH; + if (m->creds.mask == 0) + return NULL; - *tid = m->tid; - return 0; + return &m->creds; } -int sd_bus_message_get_pid_starttime(sd_bus_message *m, uint64_t *usec) { - if (!m) - return -EINVAL; - if (!usec) - return -EINVAL; - if (m->pid_starttime <= 0) - return -ESRCH; - - *usec = m->pid_starttime; - return 0; -} +_public_ int sd_bus_message_is_signal(sd_bus_message *m, + const char *interface, + const char *member) { + assert_return(m, -EINVAL); -int sd_bus_message_get_selinux_context(sd_bus_message *m, const char **ret) { - if (!m) - return -EINVAL; - if (!m->label) - return -ESRCH; + if (m->header->type != SD_BUS_MESSAGE_SIGNAL) + return 0; - *ret = m->label; - return 0; -} + if (interface && (!m->interface || !streq(m->interface, interface))) + return 0; -int sd_bus_message_get_monotonic_timestamp(sd_bus_message *m, uint64_t *usec) { - if (!m) - return -EINVAL; - if (!usec) - return -EINVAL; - if (m->monotonic <= 0) - return -ESRCH; + if (member && (!m->member || !streq(m->member, member))) + return 0; - *usec = m->monotonic; - return 0; + return 1; } -int sd_bus_message_get_realtime_timestamp(sd_bus_message *m, uint64_t *usec) { - if (!m) - return -EINVAL; - if (!usec) - return -EINVAL; - if (m->realtime <= 0) - return -ESRCH; +_public_ int sd_bus_message_is_method_call(sd_bus_message *m, + const char *interface, + const char *member) { + assert_return(m, -EINVAL); - *usec = m->realtime; - return 0; -} + if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL) + return 0; -int sd_bus_message_get_comm(sd_bus_message *m, const char **ret) { - if (!m) - return -EINVAL; - if (!ret) - return -EINVAL; - if (!m->comm) - return -ESRCH; + if (interface && (!m->interface || !streq(m->interface, interface))) + return 0; - *ret = m->comm; - return 0; + if (member && (!m->member || !streq(m->member, member))) + return 0; + + return 1; } -int sd_bus_message_get_tid_comm(sd_bus_message *m, const char **ret) { - if (!m) - return -EINVAL; - if (!ret) - return -EINVAL; - if (!m->tid_comm) - return -ESRCH; +_public_ int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) { + assert_return(m, -EINVAL); - *ret = m->tid_comm; - return 0; -} + if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR) + return 0; -int sd_bus_message_get_exe(sd_bus_message *m, const char **ret) { - if (!m) - return -EINVAL; - if (!ret) - return -EINVAL; - if (!m->exe) - return -ESRCH; + if (name && (!m->error.name || !streq(m->error.name, name))) + return 0; - *ret = m->exe; - return 0; + return 1; } -int sd_bus_message_get_cgroup(sd_bus_message *m, const char **ret) { - if (!m) - return -EINVAL; - if (!ret) - return -EINVAL; - if (!m->cgroup) - return -ESRCH; +_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; - *ret = m->cgroup; return 0; } -int sd_bus_message_get_unit(sd_bus_message *m, const char **ret) { - int r; - - if (!m) - return -EINVAL; - if (!ret) - return -EINVAL; - if (!m->cgroup) - return -ESRCH; +_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 (!m->unit) { - r = cg_path_get_unit(m->cgroup, &m->unit); - if (r < 0) - return r; - } + if (b) + m->header->flags |= BUS_MESSAGE_NO_AUTO_START; + else + m->header->flags &= ~BUS_MESSAGE_NO_AUTO_START; - *ret = m->unit; return 0; } -int sd_bus_message_get_user_unit(sd_bus_message *m, const char **ret) { - int r; - - if (!m) - return -EINVAL; - if (!ret) - return -EINVAL; - if (!m->cgroup) - return -ESRCH; +static struct bus_container *message_get_container(sd_bus_message *m) { + assert(m); - if (!m->user_unit) { - r = cg_path_get_user_unit(m->cgroup, &m->user_unit); - if (r < 0) - return r; - } + if (m->n_containers == 0) + return &m->root_container; - *ret = m->user_unit; - return 0; + assert(m->containers); + return m->containers + m->n_containers - 1; } -int sd_bus_message_get_session(sd_bus_message *m, const char **ret) { - int r; - - if (!m) - return -EINVAL; - if (!ret) - return -EINVAL; - if (!m->cgroup) - return -ESRCH; - - if (!m->session) { - r = cg_path_get_session(m->cgroup, &m->session); - if (r < 0) - return r; - } - - *ret = m->session; - return 0; -} - -int sd_bus_message_get_owner_uid(sd_bus_message *m, uid_t *uid) { - if (!m) - return -EINVAL; - if (!uid) - return -EINVAL; - if (!m->cgroup) - return -ESRCH; - - return cg_path_get_owner_uid(m->cgroup, uid); -} - -int sd_bus_message_get_cmdline(sd_bus_message *m, char ***cmdline) { - size_t n, i; - const char *p; - bool first; - - if (!m) - return -EINVAL; - - if (!m->cmdline) - return -ENOENT; - - for (p = m->cmdline, n = 0; p < m->cmdline + m->cmdline_length; p++) - if (*p == 0) - n++; - - m->cmdline_array = new(char*, n + 1); - if (!m->cmdline_array) - return -ENOMEM; - - for (p = m->cmdline, i = 0, first = true; p < m->cmdline + m->cmdline_length; p++) { - if (first) - m->cmdline_array[i++] = (char*) p; - - first = *p == 0; - } - - m->cmdline_array[i] = NULL; - *cmdline = m->cmdline_array; - - return 0; -} - -int sd_bus_message_get_audit_sessionid(sd_bus_message *m, uint32_t *sessionid) { - if (!m) - return -EINVAL; - if (!sessionid) - return -EINVAL; - if (!m->audit) - return -ESRCH; - - *sessionid = m->audit->sessionid; - return 0; -} - -int sd_bus_message_get_audit_loginuid(sd_bus_message *m, uid_t *uid) { - if (!m) - return -EINVAL; - if (!uid) - return -EINVAL; - if (!m->audit) - return -ESRCH; - - *uid = m->audit->loginuid; - return 0; -} - -int sd_bus_message_has_effective_cap(sd_bus_message *m, int capability) { - unsigned sz; - - if (!m) - return -EINVAL; - if (capability < 0) - return -EINVAL; - if (!m->capability) - return -ESRCH; - - sz = m->capability_size / 4; - if ((unsigned) capability >= sz*8) - return 0; - - return !!(m->capability[2 * sz + (capability / 8)] & (1 << (capability % 8))); -} - -int sd_bus_message_is_signal(sd_bus_message *m, const char *interface, const char *member) { - if (!m) - return -EINVAL; - - if (m->header->type != SD_BUS_MESSAGE_TYPE_SIGNAL) - return 0; - - if (interface && (!m->interface || !streq(m->interface, interface))) - return 0; - - if (member && (!m->member || !streq(m->member, member))) - return 0; - - return 1; -} - -int sd_bus_message_is_method_call(sd_bus_message *m, const char *interface, const char *member) { - if (!m) - return -EINVAL; - - if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL) - return 0; - - if (interface && (!m->interface || !streq(m->interface, interface))) - return 0; - - if (member && (!m->member || !streq(m->member, member))) - return 0; - - return 1; -} - -int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) { - if (!m) - return -EINVAL; - - if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_ERROR) - return 0; - - if (name && (!m->error.name || !streq(m->error.name, name))) - return 0; - - 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; - - if (b) - m->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED; - else - m->header->flags &= ~SD_BUS_MESSAGE_NO_REPLY_EXPECTED; - - return 0; -} - -static struct bus_container *message_get_container(sd_bus_message *m) { - assert(m); - - if (m->n_containers == 0) - return &m->root_container; - - assert(m->containers); - return m->containers + m->n_containers - 1; -} - -struct bus_body_part *message_append_part(sd_bus_message *m) { - struct bus_body_part *part; +struct bus_body_part *message_append_part(sd_bus_message *m) { + struct bus_body_part *part; assert(m); @@ -1284,7 +1072,7 @@ static int part_make_space( part->munmap_this = true; } else { - n = realloc(part->data, sz); + n = realloc(part->data, MAX(sz, 1u)); if (!n) { m->poisoned = true; return -ENOMEM; @@ -1301,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; @@ -1310,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; @@ -1393,28 +1204,56 @@ 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; - if (!m) - return -EINVAL; - if (!p) - return -EINVAL; - if (m->sealed) - return -EPERM; - if (!bus_type_is_basic(type)) - return -EINVAL; - if (m->poisoned) - return -ESTALE; + assert_return(m, -EINVAL); + assert_return(!m->sealed, -EPERM); + assert_return(bus_type_is_basic(type), -EINVAL); + assert_return(!m->poisoned, -ESTALE); c = message_get_container(m); @@ -1437,137 +1276,175 @@ 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: - case SD_BUS_TYPE_OBJECT_PATH: + switch (type) { - align = 4; - sz = 4 + strlen(p) + 1; - break; + case SD_BUS_TYPE_SIGNATURE: + case SD_BUS_TYPE_STRING: + p = strempty(p); - case SD_BUS_TYPE_SIGNATURE: + /* Fall through... */ + case SD_BUS_TYPE_OBJECT_PATH: + if (!p) + return -EINVAL; - align = 1; - sz = 1 + strlen(p) + 1; - break; + align = 1; + sz = strlen(p) + 1; + break; - case SD_BUS_TYPE_BOOLEAN: - align = sz = 4; + case SD_BUS_TYPE_BOOLEAN: - assert_cc(sizeof(int) == sizeof(uint32_t)); - memcpy(&k, p, 4); - k = !!k; - p = &k; - break; + u8 = p && *(int*) p; + p = &u8; - case SD_BUS_TYPE_UNIX_FD: { - int z, *f; + align = sz = 1; + break; - if (!m->allow_fds) { - r = -ENOTSUP; - goto fail; - } + case SD_BUS_TYPE_UNIX_FD: - align = sz = 4; + if (!p) + return -EINVAL; - z = *(int*) p; - if (z < 0) { - r = -EINVAL; - goto fail; - } + fd = message_push_fd(m, *(int*) p); + if (fd < 0) + return fd; - fd = fcntl(z, F_DUPFD_CLOEXEC, 3); - if (fd < 0) { - r = -errno; - goto fail; - } + u32 = m->n_fds; + p = &u32; - f = realloc(m->fds, sizeof(int) * (m->n_fds + 1)); - if (!f) { - m->poisoned = true; - r = -ENOMEM; - goto fail; + align = sz = 4; + break; + + default: + align = bus_gvariant_get_alignment(CHAR_TO_STR(type)); + sz = bus_gvariant_get_size(type); + break; } - fdi = m->n_fds; - f[fdi] = fd; - m->fds = f; - m->free_fds = true; - break; - } + assert(align > 0); + assert(sz > 0); - default: - align = bus_type_get_alignment(type); - sz = bus_type_get_size(type); - break; - } + a = message_extend_body(m, align, sz, true); + if (!a) + return -ENOMEM; - assert(align > 0); - assert(sz > 0); + memcpy(a, p, sz); - a = message_extend_body(m, align, sz); - if (!a) { - r = -ENOMEM; - goto fail; - } + if (stored) + *stored = (const uint8_t*) a; - 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); + } else { + uint32_t u32; - if (stored) - *stored = (const uint8_t*) a + 4; + switch (type) { - } else if (type == SD_BUS_TYPE_SIGNATURE) { - *(uint8_t*) a = sz - 1; - memcpy((uint8_t*) a + 1, p, sz - 1); + case SD_BUS_TYPE_STRING: + /* To make things easy we'll serialize a NULL string + * into the empty string */ + p = strempty(p); - if (stored) - *stored = (const uint8_t*) a + 1; - } else if (type == SD_BUS_TYPE_UNIX_FD) { - *(uint32_t*) a = fdi; + /* Fall through... */ + case SD_BUS_TYPE_OBJECT_PATH: - if (stored) - *stored = a; + if (!p) + return -EINVAL; - m->n_fds ++; + align = 4; + sz = 4 + strlen(p) + 1; + break; - } else { - memcpy(a, p, sz); + case SD_BUS_TYPE_SIGNATURE: - if (stored) - *stored = a; + p = strempty(p); + + align = 1; + sz = 1 + strlen(p) + 1; + break; + + case SD_BUS_TYPE_BOOLEAN: + + u32 = p && *(int*) p; + 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) c->index++; + fd = -1; return 0; - -fail: - if (fd >= 0) - close_nointr_nofail(fd); - - return r; } -int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p) { +_public_ int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p) { return message_append_basic(m, type, p, NULL); } -int sd_bus_message_append_string_space(sd_bus_message *m, size_t size, char **s) { +_public_ int sd_bus_message_append_string_space( + sd_bus_message *m, + size_t size, + char **s) { + struct bus_container *c; void *a; - if (!m) - return -EINVAL; - if (!s) - return -EINVAL; - if (m->sealed) - return -EPERM; - if (m->poisoned) - return -ESTALE; + assert_return(m, -EINVAL); + assert_return(s, -EINVAL); + assert_return(!m->sealed, -EPERM); + assert_return(!m->poisoned, -ESTALE); c = message_get_container(m); @@ -1590,12 +1467,20 @@ int sd_bus_message_append_string_space(sd_bus_message *m, size_t size, char **s) } } - 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; @@ -1605,30 +1490,61 @@ int sd_bus_message_append_string_space(sd_bus_message *m, size_t size, char **s) return 0; } +_public_ int sd_bus_message_append_string_iovec( + sd_bus_message *m, + const struct iovec *iov, + unsigned n) { + + size_t size; + unsigned i; + char *p; + int r; + + 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) { + 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 */ @@ -1657,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; } @@ -1686,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); @@ -1717,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 */ - *(uint8_t*) a = l; - memcpy((uint8_t*) a + 1, contents, l + 1); + 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++; @@ -1734,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; @@ -1771,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; @@ -1784,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; @@ -1807,22 +1784,35 @@ 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; } -int sd_bus_message_open_container( +_public_ int sd_bus_message_open_container( sd_bus_message *m, char type, const char *contents) { @@ -1830,17 +1820,14 @@ 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; - if (!m) - return -EINVAL; - if (m->sealed) - return -EPERM; - if (!contents) - return -EINVAL; - if (m->poisoned) - return -ESTALE; + 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)); @@ -1865,13 +1852,13 @@ 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; @@ -1887,32 +1874,232 @@ 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 = 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; + + 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); + } + } + + } 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; } -int sd_bus_message_close_container(sd_bus_message *m) { +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 = 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"); + + j++; + } + } + + return 0; +} + +_public_ int sd_bus_message_close_container(sd_bus_message *m) { struct bus_container *c; + int r; - if (!m) - return -EINVAL; - if (m->sealed) - return -EPERM; - if (m->n_containers <= 0) - return -EINVAL; - if (m->poisoned) - return -ESTALE; + 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; - 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 { @@ -2148,21 +2335,17 @@ int bus_message_append_ap( return r; } - return 0; + return 1; } -int sd_bus_message_append(sd_bus_message *m, const char *types, ...) { - va_list ap; - int r; - - if (!m) - return -EINVAL; - if (m->sealed) - return -EPERM; - if (m->poisoned) - return -ESTALE; - if (!types) - return 0; +_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); @@ -2171,21 +2354,21 @@ int sd_bus_message_append(sd_bus_message *m, const char *types, ...) { return r; } -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; - if (!m) - return -EINVAL; - if (m->sealed) - return -EPERM; - if (!bus_type_is_trivial(type)) - return -EINVAL; - if (!ptr && size > 0) - return -EINVAL; - if (m->poisoned) - return -ESTALE; + 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); align = bus_type_get_alignment(type); sz = bus_type_get_size(type); @@ -2200,7 +2383,7 @@ int sd_bus_message_append_array_space(sd_bus_message *m, char type, size_t size, if (r < 0) return r; - a = message_extend_body(m, align, size); + a = message_extend_body(m, align, size, false); if (!a) return -ENOMEM; @@ -2212,12 +2395,18 @@ int sd_bus_message_append_array_space(sd_bus_message *m, char type, size_t size, return 0; } -int sd_bus_message_append_array(sd_bus_message *m, char type, const void *ptr, size_t size) { +_public_ int sd_bus_message_append_array(sd_bus_message *m, + char type, + const void *ptr, + size_t size) { int r; void *p; - if (!ptr && size > 0) - return -EINVAL; + 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) @@ -2229,7 +2418,45 @@ int sd_bus_message_append_array(sd_bus_message *m, char type, const void *ptr, s return 0; } -int sd_bus_message_append_array_memfd(sd_bus_message *m, char type, sd_memfd *memfd) { +_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; @@ -2276,7 +2503,7 @@ int sd_bus_message_append_array_memfd(sd_bus_message *m, char type, sd_memfd *me if (r < 0) return r; - a = message_extend_body(m, align, 0); + a = message_extend_body(m, align, 0, false); if (!a) return -ENOMEM; @@ -2295,7 +2522,7 @@ int sd_bus_message_append_array_memfd(sd_bus_message *m, char type, sd_memfd *me return sd_bus_message_close_container(m); } -int sd_bus_message_append_string_memfd(sd_bus_message *m, sd_memfd *memfd) { +_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; @@ -2347,11 +2574,13 @@ int sd_bus_message_append_string_memfd(sd_bus_message *m, sd_memfd *memfd) { } } - 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) @@ -2362,8 +2591,16 @@ int sd_bus_message_append_string_memfd(sd_bus_message *m, sd_memfd *memfd) { 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++; @@ -2371,7 +2608,7 @@ int sd_bus_message_append_string_memfd(sd_bus_message *m, sd_memfd *memfd) { return 0; } -int sd_bus_message_append_strv(sd_bus_message *m, char **l) { +_public_ int sd_bus_message_append_strv(sd_bus_message *m, char **l) { char **i; int r; @@ -2477,6 +2714,15 @@ static int buffer_peek(const void *p, uint32_t sz, size_t *rindex, size_t align, 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; @@ -2489,6 +2735,22 @@ static bool message_end_of_array(sd_bus_message *m, size_t index) { 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; @@ -2626,25 +2888,22 @@ static bool validate_object_path(const char *s, size_t l) { return true; } -int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) { +_public_ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) { struct bus_container *c; - int r; void *q; + int r; - if (!m) - return -EINVAL; - if (!m->sealed) - return -EPERM; - if (!bus_type_is_basic(type)) - return -EINVAL; - if (!p) - return -EINVAL; + assert_return(m, -EINVAL); + assert_return(m->sealed, -EPERM); + assert_return(bus_type_is_basic(type), -EINVAL); - 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); if (c->signature[c->index] != type) return -ENXIO; @@ -2676,7 +2935,9 @@ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) { } m->rindex = rindex; - *(const char**) p = q; + if (p) + *(const char**) p = q; + break; } @@ -2700,7 +2961,9 @@ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) { return -EBADMSG; m->rindex = rindex; - *(const char**) p = q; + + if (p) + *(const char**) p = q; break; } @@ -2720,27 +2983,32 @@ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) { switch (type) { case SD_BUS_TYPE_BYTE: - *(uint8_t*) p = *(uint8_t*) q; + if (p) + *(uint8_t*) p = *(uint8_t*) q; break; case SD_BUS_TYPE_BOOLEAN: - *(int*) p = !!*(uint32_t*) q; + if (p) + *(int*) p = !!*(uint32_t*) q; break; case SD_BUS_TYPE_INT16: case SD_BUS_TYPE_UINT16: - *(uint16_t*) p = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q); + if (p) + *(uint16_t*) p = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q); break; case SD_BUS_TYPE_INT32: case SD_BUS_TYPE_UINT32: - *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q); + 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: - *(uint64_t*) p = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q); + if (p) + *(uint64_t*) p = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q); break; case SD_BUS_TYPE_UNIX_FD: { @@ -2750,7 +3018,8 @@ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) { if (j >= m->n_fds) return -EBADMSG; - *(int*) p = m->fds[j]; + if (p) + *(int*) p = m->fds[j]; break; } @@ -2950,19 +3219,37 @@ 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; 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 @@ -2988,11 +3275,14 @@ 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; @@ -3028,15 +3318,12 @@ int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *con 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; - 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) { @@ -3048,7 +3335,7 @@ int sd_bus_message_exit_container(sd_bus_message *m) { } else { if (c->signature && c->signature[c->index] != 0) - return -EINVAL; + return -EBUSY; } free(c->signature); @@ -3079,23 +3366,21 @@ static void message_quit_container(sd_bus_message *m) { c->index = c->saved_index; } -int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents) { +_public_ int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents) { struct bus_container *c; int r; - if (!m) - return -EINVAL; - if (!m->sealed) - return -EPERM; - - c = message_get_container(m); + assert_return(m, -EINVAL); + assert_return(m->sealed, -EPERM); - if (!c->signature || c->signature[c->index] == 0) + 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; @@ -3195,19 +3480,17 @@ 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) { message_reset_containers(m); @@ -3224,6 +3507,7 @@ int sd_bus_message_rewind(sd_bus_message *m, int complete) { return !isempty(c->signature); } + static int message_read_ap( sd_bus_message *m, const char *types, @@ -3232,11 +3516,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 @@ -3246,12 +3531,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) @@ -3295,8 +3582,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; } @@ -3316,8 +3607,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) { @@ -3346,8 +3641,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) @@ -3376,8 +3675,11 @@ static int message_read_ap( 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 (r == 0) { + if (n_loop <= 1) + return 0; return -ENXIO; + } } if (n_array == (unsigned) -1) { @@ -3404,16 +3706,13 @@ static int message_read_ap( return 1; } -int sd_bus_message_read(sd_bus_message *m, const char *types, ...) { +_public_ int sd_bus_message_read(sd_bus_message *m, const char *types, ...) { va_list ap; int r; - if (!m) - return -EINVAL; - if (!m->sealed) - return -EPERM; - if (!types) - return -EINVAL; + assert_return(m, -EINVAL); + assert_return(m->sealed, -EPERM); + assert_return(types, -EINVAL); va_start(ap, types); r = message_read_ap(m, types, ap); @@ -3422,25 +3721,164 @@ int sd_bus_message_read(sd_bus_message *m, const char *types, ...) { return r; } -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; +_public_ int sd_bus_message_skip(sd_bus_message *m, const char *types) { int r; - if (!m) - return -EINVAL; - if (!m->sealed) - return -EPERM; - if (!bus_type_is_trivial(type)) - return -EINVAL; - if (!ptr) - return -EINVAL; - if (!size) + 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; - if (BUS_MESSAGE_NEED_BSWAP(m)) - return -ENOTSUP; + } +} + +_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); align = bus_type_get_alignment(type); if (align < 0) @@ -3453,12 +3891,18 @@ int sd_bus_message_read_array(sd_bus_message *m, char type, const void **ptr, si c = message_get_container(m); sz = BUS_MESSAGE_BSWAP32(m, *c->array_size); - r = message_peek_body(m, &m->rindex, align, sz, &p); - if (r < 0) - goto fail; - if (r == 0) { - r = -EBADMSG; - goto fail; + 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; + if (r == 0) { + r = -EBADMSG; + goto fail; + } } r = sd_bus_message_exit_container(m); @@ -3735,10 +4179,10 @@ int bus_message_parse_fields(sd_bus_message *m) { return r; switch (*header) { - case _SD_BUS_MESSAGE_HEADER_INVALID: + case _BUS_MESSAGE_HEADER_INVALID: return -EBADMSG; - case SD_BUS_MESSAGE_HEADER_PATH: + case BUS_MESSAGE_HEADER_PATH: if (m->path) return -EBADMSG; @@ -3749,7 +4193,7 @@ int bus_message_parse_fields(sd_bus_message *m) { r = message_peek_field_string(m, object_path_is_valid, &ri, &m->path); break; - case SD_BUS_MESSAGE_HEADER_INTERFACE: + case BUS_MESSAGE_HEADER_INTERFACE: if (m->interface) return -EBADMSG; @@ -3760,7 +4204,7 @@ int bus_message_parse_fields(sd_bus_message *m) { r = message_peek_field_string(m, interface_name_is_valid, &ri, &m->interface); break; - case SD_BUS_MESSAGE_HEADER_MEMBER: + case BUS_MESSAGE_HEADER_MEMBER: if (m->member) return -EBADMSG; @@ -3771,7 +4215,7 @@ int bus_message_parse_fields(sd_bus_message *m) { r = message_peek_field_string(m, member_name_is_valid, &ri, &m->member); break; - case SD_BUS_MESSAGE_HEADER_ERROR_NAME: + case BUS_MESSAGE_HEADER_ERROR_NAME: if (m->error.name) return -EBADMSG; @@ -3780,9 +4224,12 @@ int bus_message_parse_fields(sd_bus_message *m) { return -EBADMSG; r = message_peek_field_string(m, error_name_is_valid, &ri, &m->error.name); + if (r >= 0) + m->error._need_free = -1; + break; - case SD_BUS_MESSAGE_HEADER_DESTINATION: + case BUS_MESSAGE_HEADER_DESTINATION: if (m->destination) return -EBADMSG; @@ -3793,7 +4240,7 @@ int bus_message_parse_fields(sd_bus_message *m) { r = message_peek_field_string(m, service_name_is_valid, &ri, &m->destination); break; - case SD_BUS_MESSAGE_HEADER_SENDER: + case BUS_MESSAGE_HEADER_SENDER: if (m->sender) return -EBADMSG; @@ -3802,10 +4249,16 @@ int bus_message_parse_fields(sd_bus_message *m) { return -EBADMSG; r = message_peek_field_string(m, service_name_is_valid, &ri, &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; + m->creds.mask |= SD_BUS_CREDS_UNIQUE_NAME & m->bus->creds_mask; + } + break; - case SD_BUS_MESSAGE_HEADER_SIGNATURE: { + case BUS_MESSAGE_HEADER_SIGNATURE: { const char *s; char *c; @@ -3828,7 +4281,7 @@ int bus_message_parse_fields(sd_bus_message *m) { break; } - case SD_BUS_MESSAGE_HEADER_REPLY_SERIAL: + case BUS_MESSAGE_HEADER_REPLY_SERIAL: if (m->reply_serial != 0) return -EBADMSG; @@ -3844,7 +4297,7 @@ int bus_message_parse_fields(sd_bus_message *m) { break; - case SD_BUS_MESSAGE_HEADER_UNIX_FDS: + case BUS_MESSAGE_HEADER_UNIX_FDS: if (unix_fds != 0) return -EBADMSG; @@ -3876,25 +4329,25 @@ int bus_message_parse_fields(sd_bus_message *m) { switch (m->header->type) { - case SD_BUS_MESSAGE_TYPE_SIGNAL: + case SD_BUS_MESSAGE_SIGNAL: if (!m->path || !m->interface || !m->member) return -EBADMSG; break; - case SD_BUS_MESSAGE_TYPE_METHOD_CALL: + case SD_BUS_MESSAGE_METHOD_CALL: if (!m->path || !m->member) return -EBADMSG; break; - case SD_BUS_MESSAGE_TYPE_METHOD_RETURN: + case SD_BUS_MESSAGE_METHOD_RETURN: if (m->reply_serial == 0) return -EBADMSG; break; - case SD_BUS_MESSAGE_TYPE_METHOD_ERROR: + case SD_BUS_MESSAGE_METHOD_ERROR: if (m->reply_serial == 0 || !m->error.name) return -EBADMSG; @@ -3902,12 +4355,58 @@ int bus_message_parse_fields(sd_bus_message *m) { } /* 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) + if (m->header->type == SD_BUS_MESSAGE_METHOD_ERROR) sd_bus_message_read(m, "s", &m->error.message); 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 = 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"); + } + + return 0; +} + int bus_message_seal(sd_bus_message *m, uint64_t serial) { struct bus_body_part *part; size_t l, a; @@ -3925,19 +4424,35 @@ int bus_message_seal(sd_bus_message *m, uint64_t serial) { 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, SD_BUS_MESSAGE_HEADER_SIGNATURE, m->root_container.signature, NULL); + 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, SD_BUS_MESSAGE_HEADER_UNIX_FDS, m->n_fds); + 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; + /* 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 @@ -3966,277 +4481,13 @@ int bus_message_seal(sd_bus_message *m, uint64_t serial) { return 0; } -int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) { - if (!m) - return -EINVAL; - if (!destination) - return -EINVAL; - if (m->sealed) - return -EPERM; - if (m->destination) - return -EEXIST; - - return message_append_field_string(m, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &m->destination); -} - -int bus_message_dump(sd_bus_message *m) { - const char *u = NULL, *uu = NULL, *s = NULL; - char **cmdline = NULL; - unsigned level = 1; - int r; - uid_t owner, audit_loginuid; - uint32_t audit_sessionid; - - assert(m); - - printf("Message %p\n" - "\tn_ref=%u\n" - "\tendian=%c\n" - "\ttype=%i\n" - "\tflags=%u\n" - "\tversion=%u\n" - "\tserial=%u\n" - "\tfields_size=%u\n" - "\tbody_size=%u\n" - "\tpath=%s\n" - "\tinterface=%s\n" - "\tmember=%s\n" - "\tdestination=%s\n" - "\tsender=%s\n" - "\tsignature=%s\n" - "\treply_serial=%u\n" - "\terror.name=%s\n" - "\terror.message=%s\n" - "\tsealed=%s\n" - "\tn_body_parts=%u\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), - m->n_body_parts); - - if (m->pid != 0) - printf("\tpid=%lu\n", (unsigned long) m->pid); - if (m->tid != 0) - printf("\ttid=%lu\n", (unsigned long) m->tid); - if (m->uid_valid) - printf("\tuid=%lu\n", (unsigned long) m->uid); - if (m->gid_valid) - printf("\tgid=%lu\n", (unsigned long) m->gid); - if (m->pid_starttime != 0) - printf("\tpid_starttime=%llu\n", (unsigned long long) m->pid_starttime); - if (m->monotonic != 0) - printf("\tmonotonic=%llu\n", (unsigned long long) m->monotonic); - if (m->realtime != 0) - printf("\trealtime=%llu\n", (unsigned long long) m->realtime); - if (m->exe) - printf("\texe=[%s]\n", m->exe); - if (m->comm) - printf("\tcomm=[%s]\n", m->comm); - if (m->tid_comm) - printf("\ttid_comm=[%s]\n", m->tid_comm); - if (m->label) - printf("\tlabel=[%s]\n", m->label); - if (m->cgroup) - printf("\tcgroup=[%s]\n", m->cgroup); - - sd_bus_message_get_unit(m, &u); - if (u) - printf("\tunit=[%s]\n", u); - sd_bus_message_get_user_unit(m, &uu); - if (uu) - printf("\tuser_unit=[%s]\n", uu); - sd_bus_message_get_session(m, &s); - if (s) - printf("\tsession=[%s]\n", s); - if (sd_bus_message_get_owner_uid(m, &owner) >= 0) - printf("\towner_uid=%lu\n", (unsigned long) owner); - if (sd_bus_message_get_audit_loginuid(m, &audit_loginuid) >= 0) - printf("\taudit_loginuid=%lu\n", (unsigned long) audit_loginuid); - if (sd_bus_message_get_audit_sessionid(m, &audit_sessionid) >= 0) - printf("\taudit_sessionid=%lu\n", (unsigned long) audit_sessionid); - - printf("\tCAP_KILL=%i\n", sd_bus_message_has_effective_cap(m, 5)); - - if (sd_bus_message_get_cmdline(m, &cmdline) >= 0) { - char **c; - - fputs("\tcmdline=[", stdout); - STRV_FOREACH(c, cmdline) { - if (c != cmdline) - putchar(' '); - - fputs(*c, stdout); - } - - fputs("]\n", stdout); - } - - r = sd_bus_message_rewind(m, true); - if (r < 0) { - log_error("Failed to rewind: %s", strerror(-r)); - return r; - } - - printf("BEGIN_MESSAGE \"%s\" {\n", strempty(m->root_container.signature)); - - for(;;) { - _cleanup_free_ char *prefix = NULL; - const char *contents = NULL; - char type; - union { - uint8_t u8; - uint16_t u16; - int16_t s16; - uint32_t u32; - int32_t s32; - uint64_t u64; - int64_t s64; - double d64; - const char *string; - int i; - } basic; - - r = sd_bus_message_peek_type(m, &type, &contents); - if (r < 0) { - log_error("Failed to peek type: %s", strerror(-r)); - return r; - } - if (r == 0) { - if (level <= 1) - break; - - r = sd_bus_message_exit_container(m); - if (r < 0) { - log_error("Failed to exit container: %s", strerror(-r)); - return r; - } - - level--; - - prefix = strrep("\t", level); - if (!prefix) - return log_oom(); - - if (type == SD_BUS_TYPE_ARRAY) - printf("%s} END_ARRAY \n", prefix); - else if (type == SD_BUS_TYPE_VARIANT) - printf("%s} END_VARIANT\n", prefix); - else if (type == SD_BUS_TYPE_STRUCT) - printf("%s} END_STRUCT\n", prefix); - else if (type == SD_BUS_TYPE_DICT_ENTRY) - printf("%s} END_DICT_ENTRY\n", prefix); - - continue; - } - - prefix = strrep("\t", level); - if (!prefix) - return log_oom(); - - if (bus_type_is_container(type) > 0) { - r = sd_bus_message_enter_container(m, type, contents); - if (r < 0) { - log_error("Failed to enter container: %s", strerror(-r)); - return r; - } - - if (type == SD_BUS_TYPE_ARRAY) - printf("%sBEGIN_ARRAY \"%s\" {\n", prefix, contents); - else if (type == SD_BUS_TYPE_VARIANT) - printf("%sBEGIN_VARIANT \"%s\" {\n", prefix, contents); - else if (type == SD_BUS_TYPE_STRUCT) - printf("%sBEGIN_STRUCT \"%s\" {\n", prefix, contents); - else if (type == SD_BUS_TYPE_DICT_ENTRY) - printf("%sBEGIN_DICT_ENTRY \"%s\" {\n", prefix, contents); - - level ++; - - continue; - } - - r = sd_bus_message_read_basic(m, type, &basic); - if (r < 0) { - log_error("Failed to get basic: %s", strerror(-r)); - return r; - } - - switch (type) { - - case SD_BUS_TYPE_BYTE: - printf("%sBYTE: %u\n", prefix, basic.u8); - break; - - case SD_BUS_TYPE_BOOLEAN: - printf("%sBOOLEAN: %s\n", prefix, yes_no(basic.i)); - break; - - case SD_BUS_TYPE_INT16: - printf("%sINT16: %i\n", prefix, basic.s16); - break; - - case SD_BUS_TYPE_UINT16: - printf("%sUINT16: %u\n", prefix, basic.u16); - break; - - case SD_BUS_TYPE_INT32: - printf("%sINT32: %i\n", prefix, basic.s32); - break; - - case SD_BUS_TYPE_UINT32: - printf("%sUINT32: %u\n", prefix, basic.u32); - break; - - case SD_BUS_TYPE_INT64: - printf("%sINT64: %lli\n", prefix, (long long) basic.s64); - break; - - case SD_BUS_TYPE_UINT64: - printf("%sUINT64: %llu\n", prefix, (unsigned long long) basic.u64); - break; - - case SD_BUS_TYPE_DOUBLE: - printf("%sDOUBLE: %g\n", prefix, basic.d64); - break; - - case SD_BUS_TYPE_STRING: - printf("%sSTRING: \"%s\"\n", prefix, basic.string); - break; - - case SD_BUS_TYPE_OBJECT_PATH: - printf("%sOBJECT_PATH: \"%s\"\n", prefix, basic.string); - break; - - case SD_BUS_TYPE_SIGNATURE: - printf("%sSIGNATURE: \"%s\"\n", prefix, basic.string); - break; - - case SD_BUS_TYPE_UNIX_FD: - printf("%sUNIX_FD: %i\n", prefix, basic.i); - break; - - default: - assert_not_reached("Unknown basic type."); - } - } +_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); - printf("} END_MESSAGE\n"); - return 0; + 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) { @@ -4274,7 +4525,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 (;;) { @@ -4295,7 +4546,25 @@ 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) { @@ -4339,7 +4608,7 @@ bool bus_header_is_complete(struct bus_header *h, size_t size) { return false; full = sizeof(struct bus_header) + - (h->endian == SD_BUS_NATIVE_ENDIAN ? h->fields_size : bswap_32(h->fields_size)); + (h->endian == BUS_NATIVE_ENDIAN ? h->fields_size : bswap_32(h->fields_size)); return size >= full; } @@ -4350,10 +4619,10 @@ int bus_header_message_size(struct bus_header *h, size_t *sum) { assert(h); assert(sum); - if (h->endian == SD_BUS_NATIVE_ENDIAN) { + if (h->endian == BUS_NATIVE_ENDIAN) { fs = h->fields_size; bs = h->body_size; - } else if (h->endian == SD_BUS_REVERSE_ENDIAN) { + } else if (h->endian == BUS_REVERSE_ENDIAN) { fs = bswap_32(h->fields_size); bs = bswap_32(h->body_size); } else @@ -4363,24 +4632,130 @@ int bus_header_message_size(struct bus_header *h, size_t *sum) { return 0; } -int bus_message_to_errno(sd_bus_message *m) { - assert(m); +_public_ int sd_bus_message_get_errno(sd_bus_message *m) { + 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; - return bus_error_to_errno(&m->error); + return sd_bus_error_get_errno(&m->error); } -int sd_bus_message_get_signature(sd_bus_message *m, int complete, const char **signature) { +_public_ const char* sd_bus_message_get_signature(sd_bus_message *m, int complete) { struct bus_container *c; - if (!m) - return -EINVAL; - if (!signature) - return -EINVAL; + assert_return(m, NULL); c = complete ? &m->root_container : message_get_container(m); - *signature = c->signature ?: ""; - return 0; + return 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 m->bus; }