X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Flibsystemd-bus%2Fbus-message.c;h=5783140cf8a91db9bf2c8db17af2c38e73b8f554;hp=3a748356743f99ae63c0dc0bb4b17433061673e0;hb=47e6ce32bb5bc8353c2070b8247be82410f4d78e;hpb=9a17484d986f6cb8828afdf911db425b574c63fd diff --git a/src/libsystemd-bus/bus-message.c b/src/libsystemd-bus/bus-message.c index 3a7483567..5783140cf 100644 --- a/src/libsystemd-bus/bus-message.c +++ b/src/libsystemd-bus/bus-message.c @@ -20,9 +20,14 @@ ***/ #include +#include +#include #include "util.h" #include "utf8.h" +#include "strv.h" +#include "time-util.h" +#include "cgroup-util.h" #include "sd-bus.h" #include "bus-message.h" @@ -30,9 +35,67 @@ #include "bus-type.h" #include "bus-signature.h" -int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored); +static int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored); -static void reset_containers(sd_bus_message *m) { +static void *adjust_pointer(const void *p, void *old_base, size_t sz, void *new_base) { + + if (p == NULL) + return NULL; + + if (old_base == new_base) + return (void*) p; + + if ((uint8_t*) p < (uint8_t*) old_base) + return (void*) p; + + if ((uint8_t*) p >= (uint8_t*) old_base + sz) + return (void*) p; + + return (uint8_t*) new_base + ((uint8_t*) p - (uint8_t*) old_base); +} + +static void message_free_part(sd_bus_message *m, struct bus_body_part *part) { + assert(m); + assert(part); + + if (part->memfd >= 0) { + + if (!part->sealed) + bus_kernel_push_memfd(m->bus, part->memfd, part->data, part->mapped); + else { + if (part->size > 0) + assert_se(munmap(part->data, PAGE_ALIGN(part->size)) == 0); + + close_nointr_nofail(part->memfd); + } + + } else if (part->free_this) + free(part->data); + + if (part != &m->body) + free(part); +} + +static void message_reset_parts(sd_bus_message *m) { + struct bus_body_part *part; + + assert(m); + + part = &m->body; + while (m->n_body_parts > 0) { + struct bus_body_part *next = part->next; + message_free_part(m, part); + part = next; + m->n_body_parts--; + } + + m->body_end = NULL; + + m->cached_rindex_part = NULL; + m->cached_rindex_part_begin = 0; +} + +static void message_reset_containers(sd_bus_message *m) { unsigned i; assert(m); @@ -48,8 +111,6 @@ static void reset_containers(sd_bus_message *m) { } static void message_free(sd_bus_message *m) { - unsigned i; - assert(m); if (m->free_header) @@ -58,21 +119,40 @@ static void message_free(sd_bus_message *m) { if (m->free_fields) free(m->fields); - if (m->free_body) - free(m->body); + message_reset_parts(m); + + if (m->free_kdbus) + free(m->kdbus); + + if (m->release_kdbus) + ioctl(m->bus->input_fd, KDBUS_CMD_MSG_RELEASE, m->kdbus); + + if (m->free_fds) { + close_many(m->fds, m->n_fds); + free(m->fds); + } + + if (m->bus) + sd_bus_unref(m->bus); - for (i = 0; i < m->n_fds; i++) - close_nointr_nofail(m->fds[i]); + if (m->iovec != m->iovec_fixed) + free(m->iovec); - reset_containers(m); + 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); free(m); } static void* buffer_extend(void **p, uint32_t *sz, size_t align, size_t extend) { - size_t start, n; + size_t start, end; void *k; assert(p); @@ -80,15 +160,15 @@ static void* buffer_extend(void **p, uint32_t *sz, size_t align, size_t extend) assert(align > 0); start = ALIGN_TO((size_t) *sz, align); - n = start + extend; + end = start + extend; - if (n == *sz) + if (end == *sz) return (uint8_t*) *p + start; - if (n > (size_t) ((uint32_t) -1)) + if (end > (size_t) ((uint32_t) -1)) return NULL; - k = realloc(*p, n); + k = realloc(*p, end); if (!k) return NULL; @@ -97,40 +177,37 @@ static void* buffer_extend(void **p, uint32_t *sz, size_t align, size_t extend) memset((uint8_t*) k + *sz, 0, start - *sz); *p = k; - *sz = n; + *sz = end; return (uint8_t*) k + start; } static void *message_extend_fields(sd_bus_message *m, size_t align, size_t sz) { - void *p, *o; + void *p, *op; + size_t os; assert(m); - o = m->fields; - p = buffer_extend(&m->fields, &m->header->fields_size, align, sz); - if (!p) + if (m->poisoned) return NULL; - if (o != m->fields) { - /* Adjust quick access pointers */ - - if (m->path) - m->path = (const char*) m->fields + (m->path - (const char*) o); - if (m->interface) - m->interface = (const char*) m->fields + (m->interface - (const char*) o); - if (m->member) - m->member = (const char*) m->fields + (m->member - (const char*) o); - if (m->destination) - m->destination = (const char*) m->fields + (m->destination - (const char*) o); - if (m->sender) - m->sender = (const char*) m->fields + (m->sender - (const char*) o); - if (m->signature) - m->signature = (const char*) m->fields + (m->signature - (const char*) o); - if (m->error.name) - m->error.name = (const char*) m->fields + (m->error.name - (const char*) o); + op = m->fields; + os = m->header->fields_size; + + p = buffer_extend(&m->fields, &m->header->fields_size, align, sz); + if (!p) { + m->poisoned = true; + return NULL; } + /* Adjust quick access pointers */ + m->path = adjust_pointer(m->path, op, os, m->fields); + m->interface = adjust_pointer(m->interface, op, os, m->fields); + m->member = adjust_pointer(m->member, op, os, m->fields); + m->destination = adjust_pointer(m->destination, op, os, m->fields); + m->sender = adjust_pointer(m->sender, op, os, m->fields); + m->error.name = adjust_pointer(m->error.name, op, os, m->fields); + m->free_fields = true; return p; @@ -166,7 +243,7 @@ static int message_append_field_string( memcpy(p + 8, s, l + 1); if (ret) - *ret = (const char*) p + 8; + *ret = (char*) p + 8; return 0; } @@ -224,23 +301,140 @@ static int message_append_field_uint32(sd_bus_message *m, uint8_t h, uint32_t x) return 0; } +int bus_message_from_header( + void *buffer, + size_t length, + int *fds, + unsigned n_fds, + const struct ucred *ucred, + const char *label, + size_t extra, + sd_bus_message **ret) { + + sd_bus_message *m; + struct bus_header *h; + size_t a, label_sz; + + assert(buffer || length <= 0); + assert(fds || n_fds <= 0); + assert(ret); + + if (length < sizeof(struct bus_header)) + return -EBADMSG; + + h = buffer; + if (h->version != 1) + return -EBADMSG; + + if (h->serial == 0) + return -EBADMSG; + + if (h->type == _SD_BUS_MESSAGE_TYPE_INVALID) + return -EBADMSG; + + if (h->endian != SD_BUS_LITTLE_ENDIAN && + h->endian != SD_BUS_BIG_ENDIAN) + return -EBADMSG; + + a = ALIGN(sizeof(sd_bus_message)) + ALIGN(extra); + + if (label) { + label_sz = strlen(label); + a += label_sz + 1; + } + + m = malloc0(a); + if (!m) + return -ENOMEM; + + m->n_ref = 1; + m->sealed = true; + m->header = h; + m->fds = fds; + m->n_fds = n_fds; + + if (ucred) { + m->uid = ucred->uid; + m->pid = ucred->pid; + m->gid = ucred->gid; + m->uid_valid = m->gid_valid = true; + } + + if (label) { + m->label = (char*) m + ALIGN(sizeof(sd_bus_message)) + ALIGN(extra); + memcpy(m->label, label, label_sz + 1); + } + + *ret = m; + return 0; +} + +int bus_message_from_malloc( + void *buffer, + size_t length, + int *fds, + unsigned n_fds, + const struct ucred *ucred, + const char *label, + sd_bus_message **ret) { + + sd_bus_message *m; + int r; + + r = bus_message_from_header(buffer, length, fds, n_fds, ucred, label, 0, &m); + if (r < 0) + return r; + + if (length != BUS_MESSAGE_SIZE(m)) { + r = -EBADMSG; + goto fail; + } + + m->fields = (uint8_t*) buffer + sizeof(struct bus_header); + + 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; + + m->n_iovec = 1; + m->iovec = m->iovec_fixed; + m->iovec[0].iov_base = buffer; + m->iovec[0].iov_len = length; + + r = bus_message_parse_fields(m); + if (r < 0) + goto fail; + + /* We take possession of the memory and fds now */ + m->free_header = true; + m->free_fds = true; + + *ret = m; + return 0; + +fail: + message_free(m); + return r; +} + static sd_bus_message *message_new(sd_bus *bus, uint8_t type) { sd_bus_message *m; - m = malloc0(ALIGN(sizeof(struct sd_bus_message)) + sizeof(struct bus_header)); + m = malloc0(ALIGN(sizeof(sd_bus_message)) + sizeof(struct bus_header)); if (!m) return NULL; m->n_ref = 1; m->header = (struct bus_header*) ((uint8_t*) m + ALIGN(sizeof(struct sd_bus_message))); - -#if __BYTE_ORDER == __BIG_ENDIAN - m->header->endian = SD_BUS_BIG_ENDIAN; -#else - m->header->endian = SD_BUS_LITTLE_ENDIAN; -#endif + m->header->endian = SD_BUS_NATIVE_ENDIAN; m->header->type = type; m->header->version = bus ? bus->message_version : 1; + m->allow_fds = !bus || bus->can_fds || (bus->state != BUS_HELLO && bus->state != BUS_RUNNING); + + if (bus) + m->bus = sd_bus_ref(bus); return m; } @@ -263,11 +457,15 @@ int sd_bus_message_new_signal( return -EINVAL; if (!m) return -EINVAL; + if (bus && bus->state == BUS_UNSET) + return -ENOTCONN; t = message_new(bus, SD_BUS_MESSAGE_TYPE_SIGNAL); if (!t) return -ENOMEM; + t->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED; + r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path); if (r < 0) goto fail; @@ -303,6 +501,8 @@ int sd_bus_message_new_method_call( return -EINVAL; if (!m) return -EINVAL; + if (bus && bus->state == BUS_UNSET) + return -ENOTCONN; t = message_new(bus, SD_BUS_MESSAGE_TYPE_METHOD_CALL); if (!t) @@ -346,15 +546,20 @@ static int message_new_reply( if (!call) return -EINVAL; + if (!call->sealed) + return -EPERM; if (call->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL) return -EINVAL; if (!m) return -EINVAL; + if (bus && bus->state == BUS_UNSET) + return -ENOTCONN; t = message_new(bus, type); if (!t) return -ENOMEM; + t->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED; t->reply_serial = BUS_MESSAGE_SERIAL(call); r = message_append_field_uint32(t, SD_BUS_MESSAGE_HEADER_REPLY_SERIAL, t->reply_serial); @@ -370,6 +575,7 @@ static int message_new_reply( t->dont_send = !!(call->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED); *m = t; + return 0; fail: message_free(t); @@ -393,9 +599,7 @@ int sd_bus_message_new_method_error( sd_bus_message *t; int r; - if (!e) - return -EINVAL; - if (!e->name) + if (!sd_bus_error_is_set(e)) return -EINVAL; if (!m) return -EINVAL; @@ -533,8 +737,10 @@ const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) { 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 -ENOENT; + return -ESRCH; *uid = m->uid; return 0; @@ -543,8 +749,10 @@ int sd_bus_message_get_uid(sd_bus_message *m, uid_t *uid) { 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 -ENOENT; + return -ESRCH; *gid = m->gid; return 0; @@ -553,8 +761,10 @@ int sd_bus_message_get_gid(sd_bus_message *m, gid_t *gid) { 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 -ENOENT; + return -ESRCH; *pid = m->pid; return 0; @@ -563,13 +773,253 @@ int sd_bus_message_get_pid(sd_bus_message *m, pid_t *pid) { 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 -ENOENT; + return -ESRCH; *tid = m->tid; return 0; } +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; +} + +int sd_bus_message_get_selinux_context(sd_bus_message *m, const char **ret) { + if (!m) + return -EINVAL; + if (!m->label) + return -ESRCH; + + *ret = m->label; + 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; + + *usec = m->monotonic; + return 0; +} + +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; + + *usec = m->realtime; + 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; + + *ret = m->comm; + return 0; +} + +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; + + *ret = m->tid_comm; + 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; + + *ret = m->exe; + return 0; +} + +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; + + *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; + + if (!m->unit) { + r = cg_path_get_unit(m->cgroup, &m->unit); + if (r < 0) + return r; + } + + *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; + + if (!m->user_unit) { + r = cg_path_get_user_unit(m->cgroup, &m->user_unit); + if (r < 0) + return r; + } + + *ret = m->user_unit; + return 0; +} + +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; @@ -641,52 +1091,212 @@ static struct bus_container *message_get_container(sd_bus_message *m) { return m->containers + m->n_containers - 1; } -static void *message_extend_body(sd_bus_message *m, size_t align, size_t sz) { - void *p, *o; - size_t added; - struct bus_container *c; +struct bus_body_part *message_append_part(sd_bus_message *m) { + struct bus_body_part *part; assert(m); - assert(align > 0); - o = m->body; - added = m->header->body_size; - - p = buffer_extend(&m->body, &m->header->body_size, align, sz); - if (!p) + if (m->poisoned) return NULL; - added = m->header->body_size - added; + if (m->n_body_parts <= 0) { + part = &m->body; + zero(*part); + } else { + assert(m->body_end); - for (c = m->containers; c < m->containers + m->n_containers; c++) - if (c->array_size) { - c->array_size = (uint32_t*) ((uint8_t*) m->body + ((uint8_t*) c->array_size - (uint8_t*) o)); - *c->array_size += added; + part = new0(struct bus_body_part, 1); + if (!part) { + m->poisoned = true; + return NULL; } - if (o != m->body) { - if (m->error.message) - m->error.message = (const char*) m->body + (m->error.message - (const char*) o); + m->body_end->next = part; } - m->free_body = true; + part->memfd = -1; + m->body_end = part; + m->n_body_parts ++; - return p; + return part; } -int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored) { - struct bus_container *c; - size_t sz, align; +static void part_zero(struct bus_body_part *part, size_t sz) { + assert(part); + assert(sz > 0); + assert(sz < 8); + + part->data = NULL; + part->size = sz; +} + +static int part_make_space( + struct sd_bus_message *m, + struct bus_body_part *part, + size_t sz, + void **q) { + + void *n; + int r; + + assert(m); + assert(part); + assert(!part->sealed); + + if (m->poisoned) + return -ENOMEM; + + if (!part->data && part->memfd < 0) + part->memfd = bus_kernel_pop_memfd(m->bus, &part->data, &part->mapped); + + if (part->memfd >= 0) { + uint64_t u = sz; + + r = ioctl(part->memfd, KDBUS_CMD_MEMFD_SIZE_SET, &u); + if (r < 0) { + m->poisoned = true; + return -errno; + } + + if (sz > part->mapped) { + size_t psz = PAGE_ALIGN(sz); + + if (part->mapped <= 0) + n = mmap(NULL, psz, PROT_READ|PROT_WRITE, MAP_SHARED, part->memfd, 0); + else + n = mremap(part->data, part->mapped, psz, MREMAP_MAYMOVE); + + if (n == MAP_FAILED) { + m->poisoned = true; + return -errno; + } + + part->mapped = psz; + part->data = n; + } + } else { + n = realloc(part->data, sz); + if (!n) { + m->poisoned = true; + return -ENOMEM; + } + + part->data = n; + part->free_this = true; + } + + if (q) + *q = part->data ? (uint8_t*) part->data + part->size : NULL; + + part->size = sz; + return 0; +} + +static void *message_extend_body(sd_bus_message *m, size_t align, size_t sz) { + struct bus_container *c; + struct bus_body_part *part = NULL; + size_t start_body, end_body, padding, start_part, end_part, added; + bool add_new_part; + void *p; + int r; + + assert(m); + assert(align > 0); + assert(!m->sealed); + + if (m->poisoned) + return NULL; + + start_body = ALIGN_TO((size_t) m->header->body_size, align); + end_body = start_body + sz; + + padding = start_body - m->header->body_size; + added = padding + sz; + + /* Check for 32bit overflows */ + if (end_body > (size_t) ((uint32_t) -1)) { + m->poisoned = true; + return NULL; + } + + add_new_part = + m->n_body_parts <= 0 || + m->body_end->sealed || + padding != ALIGN_TO(m->body_end->size, align) - m->body_end->size; + + if (add_new_part) { + if (padding > 0) { + part = message_append_part(m); + if (!part) + return NULL; + + part_zero(part, padding); + } + + part = message_append_part(m); + if (!part) + return NULL; + + r = part_make_space(m, part, sz, &p); + if (r < 0) + return NULL; + } else { + void *op; + size_t os; + + part = m->body_end; + op = part->data; + os = part->size; + + start_part = ALIGN_TO(part->size, align); + end_part = start_part + sz; + + r = part_make_space(m, part, end_part, &p); + if (r < 0) + return NULL; + + if (padding > 0) { + memset(p, 0, padding); + p = (uint8_t*) p + padding; + } + + /* Readjust pointers */ + for (c = m->containers; c < m->containers + m->n_containers; c++) + c->array_size = adjust_pointer(c->array_size, op, os, part->data); + + m->error.message = (const char*) adjust_pointer(m->error.message, op, os, part->data); + } + + /* Update counters */ + for (c = m->containers; c < m->containers + m->n_containers; c++) + if (c->array_size) + *c->array_size += added; + + m->header->body_size = end_body; + + return p; +} + +int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored) { + struct bus_container *c; + ssize_t align, sz; uint32_t k; void *a; char *e = NULL; + int fd = -1; + uint32_t fdi = 0; + int r; if (!m) return -EINVAL; + if (!p) + return -EINVAL; if (m->sealed) return -EPERM; if (!bus_type_is_basic(type)) return -EINVAL; + if (m->poisoned) + return -ESTALE; c = message_get_container(m); @@ -701,19 +1311,23 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void return -ENXIO; e = strextend(&c->signature, CHAR_TO_STR(type), NULL); - if (!e) + if (!e) { + m->poisoned = true; return -ENOMEM; + } } switch (type) { case SD_BUS_TYPE_STRING: case SD_BUS_TYPE_OBJECT_PATH: + align = 4; sz = 4 + strlen(p) + 1; break; case SD_BUS_TYPE_SIGNATURE: + align = 1; sz = 1 + strlen(p) + 1; break; @@ -727,6 +1341,42 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void p = &k; break; + case SD_BUS_TYPE_UNIX_FD: { + int z, *f; + + if (!m->allow_fds) { + r = -ENOTSUP; + goto fail; + } + + align = sz = 4; + + z = *(int*) p; + if (z < 0) { + r = -EINVAL; + goto fail; + } + + fd = fcntl(z, F_DUPFD_CLOEXEC, 3); + if (fd < 0) { + r = -errno; + goto fail; + } + + f = realloc(m->fds, sizeof(int) * (m->n_fds + 1)); + if (!f) { + m->poisoned = true; + r = -ENOMEM; + goto fail; + } + + fdi = m->n_fds; + f[fdi] = fd; + m->fds = f; + m->free_fds = true; + break; + } + default: align = bus_type_get_alignment(type); sz = bus_type_get_size(type); @@ -738,11 +1388,8 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void a = message_extend_body(m, align, sz); if (!a) { - /* Truncate extended signature again */ - if (e) - c->signature[c->index] = 0; - - return -ENOMEM; + r = -ENOMEM; + goto fail; } if (type == SD_BUS_TYPE_STRING || type == SD_BUS_TYPE_OBJECT_PATH) { @@ -758,6 +1405,13 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void if (stored) *stored = (const uint8_t*) a + 1; + } else if (type == SD_BUS_TYPE_UNIX_FD) { + *(uint32_t*) a = fdi; + + if (stored) + *stored = a; + + m->n_fds ++; } else { memcpy(a, p, sz); @@ -770,12 +1424,67 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void c->index++; 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) { return message_append_basic(m, type, p, NULL); } +int sd_bus_message_append_string_space(sd_bus_message *m, size_t size, char **s) { + struct bus_container *c; + char *e; + void *a; + + if (!m) + return -EINVAL; + if (!s) + return -EINVAL; + if (m->sealed) + return -EPERM; + if (m->poisoned) + return -ESTALE; + + c = message_get_container(m); + + if (c->signature && c->signature[c->index]) { + /* Container signature is already set */ + + if (c->signature[c->index] != SD_BUS_TYPE_STRING) + return -ENXIO; + } else { + /* Maybe we can append to the signature? But only if this is the top-level container*/ + if (c->enclosing != 0) + return -ENXIO; + + e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRING), NULL); + if (!e) { + m->poisoned = true; + return -ENOMEM; + } + } + + + a = message_extend_body(m, 4, 4 + size + 1); + if (!a) + return -ENOMEM; + + *(uint32_t*) a = size; + *s = (char*) a + 4; + + (*s)[size] = 0; + + if (c->enclosing != SD_BUS_TYPE_ARRAY) + c->index++; + + return 0; +} + static int bus_message_open_array( sd_bus_message *m, struct bus_container *c, @@ -784,9 +1493,10 @@ static int bus_message_open_array( unsigned nindex; char *e = NULL; - void *a, *b; + void *a, *op; int alignment; - size_t saved; + size_t os; + struct bus_body_part *o; assert(m); assert(c); @@ -818,39 +1528,34 @@ static int bus_message_open_array( /* Extend the existing signature */ e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_ARRAY), contents, NULL); - if (!e) + if (!e) { + m->poisoned = true; return -ENOMEM; + } nindex = e - c->signature; } - saved = m->header->body_size; a = message_extend_body(m, 4, 4); - if (!a) { - /* Truncate extended signature again */ - if (e) - c->signature[c->index] = 0; - + if (!a) return -ENOMEM; - } - b = m->body; - if (!message_extend_body(m, alignment, 0)) { - /* Add alignment between size and first element */ - if (e) - c->signature[c->index] = 0; + o = m->body_end; + op = m->body_end->data; + os = m->body_end->size; - m->header->body_size = saved; + /* Add alignment between size and first element */ + if (!message_extend_body(m, alignment, 0)) return -ENOMEM; - } if (c->enclosing != SD_BUS_TYPE_ARRAY) c->index = nindex; - /* m->body might have changed so let's readjust a */ - a = (uint8_t*) m->body + ((uint8_t*) a - (uint8_t*) b); - *(uint32_t*) a = 0; + /* 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; } @@ -884,19 +1589,16 @@ static int bus_message_open_variant( return -ENXIO; e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_VARIANT), NULL); - if (!e) + if (!e) { + m->poisoned = true; return -ENOMEM; + } } l = strlen(contents); a = message_extend_body(m, 1, 1 + l + 1); - if (!a) { - /* Truncate extended signature again */ - if (e) - c->signature[c->index] = 0; - + if (!a) return -ENOMEM; - } *(uint8_t*) a = l; memcpy((uint8_t*) a + 1, contents, l + 1); @@ -938,19 +1640,17 @@ static int bus_message_open_struct( return -ENXIO; e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_BEGIN), contents, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_END), NULL); - if (!e) + if (!e) { + m->poisoned = true; return -ENOMEM; + } nindex = e - c->signature; } /* Align contents to 8 byte boundary */ - if (!message_extend_body(m, 8, 0)) { - if (e) - c->signature[c->index] = 0; - + if (!message_extend_body(m, 8, 0)) return -ENOMEM; - } if (c->enclosing != SD_BUS_TYPE_ARRAY) c->index = nindex; @@ -1007,6 +1707,7 @@ int sd_bus_message_open_container( struct bus_container *c, *w; uint32_t *array_size = NULL; char *signature; + size_t before; int r; if (!m) @@ -1015,18 +1716,30 @@ int sd_bus_message_open_container( return -EPERM; if (!contents) return -EINVAL; + if (m->poisoned) + return -ESTALE; /* Make sure we have space for one more container */ w = realloc(m->containers, sizeof(struct bus_container) * (m->n_containers + 1)); - if (!w) + if (!w) { + m->poisoned = true; return -ENOMEM; + } + m->containers = w; c = message_get_container(m); signature = strdup(contents); - if (!signature) + if (!signature) { + m->poisoned = true; return -ENOMEM; + } + + /* Save old index in the parent container, in case we have to + * abort this container */ + c->saved_index = c->index; + before = m->header->body_size; if (type == SD_BUS_TYPE_ARRAY) r = bus_message_open_array(m, c, contents, &array_size); @@ -1050,7 +1763,8 @@ int sd_bus_message_open_container( w->signature = signature; w->index = 0; w->array_size = array_size; - w->begin = 0; + w->before = before; + w->begin = m->rindex; return 0; } @@ -1064,6 +1778,8 @@ int sd_bus_message_close_container(sd_bus_message *m) { return -EPERM; if (m->n_containers <= 0) return -EINVAL; + if (m->poisoned) + return -ESTALE; c = message_get_container(m); if (c->enclosing != SD_BUS_TYPE_ARRAY) @@ -1076,18 +1792,88 @@ int sd_bus_message_close_container(sd_bus_message *m) { return 0; } -static int message_append_ap( +typedef struct { + const char *types; + unsigned n_struct; + unsigned n_array; +} TypeStack; + +static int type_stack_push(TypeStack *stack, unsigned max, unsigned *i, const char *types, unsigned n_struct, unsigned n_array) { + assert(stack); + assert(max > 0); + + if (*i >= max) + return -EINVAL; + + stack[*i].types = types; + stack[*i].n_struct = n_struct; + stack[*i].n_array = n_array; + (*i)++; + + return 0; +} + +static int type_stack_pop(TypeStack *stack, unsigned max, unsigned *i, const char **types, unsigned *n_struct, unsigned *n_array) { + assert(stack); + assert(max > 0); + assert(types); + assert(n_struct); + assert(n_array); + + if (*i <= 0) + return 0; + + (*i)--; + *types = stack[*i].types; + *n_struct = stack[*i].n_struct; + *n_array = stack[*i].n_array; + + return 1; +} + +int bus_message_append_ap( sd_bus_message *m, const char *types, va_list ap) { - const char *t; + unsigned n_array, n_struct; + TypeStack stack[BUS_CONTAINER_DEPTH]; + unsigned stack_ptr = 0; int r; assert(m); - assert(types); - for (t = types; *t; t++) { + if (!types) + return 0; + + n_array = (unsigned) -1; + n_struct = strlen(types); + + for (;;) { + const char *t; + + if (n_array == 0 || (n_array == (unsigned) -1 && n_struct == 0)) { + r = type_stack_pop(stack, ELEMENTSOF(stack), &stack_ptr, &types, &n_struct, &n_array); + if (r < 0) + return r; + if (r == 0) + break; + + r = sd_bus_message_close_container(m); + if (r < 0) + return r; + + continue; + } + + t = types; + if (n_array != (unsigned) -1) + n_array --; + else { + types ++; + n_struct--; + } + switch (*t) { case SD_BUS_TYPE_BYTE: { @@ -1149,27 +1935,28 @@ static int message_append_ap( return r; { - unsigned i, n; char s[k + 1]; - memcpy(s, t + 1, k); s[k] = 0; - t += k; r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, s); if (r < 0) return r; + } - n = va_arg(ap, unsigned); - for (i = 0; i < n; i++) { - r = message_append_ap(m, s, ap); - if (r < 0) - return r; - } - - r = sd_bus_message_close_container(m); + if (n_array == (unsigned) -1) { + types += k; + n_struct -= k; } + r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array); + if (r < 0) + return r; + + types = t + 1; + n_struct = k; + n_array = va_arg(ap, unsigned); + break; } @@ -1184,11 +1971,14 @@ static int message_append_ap( if (r < 0) return r; - r = message_append_ap(m, s, ap); + r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array); if (r < 0) return r; - r = sd_bus_message_close_container(m); + types = s; + n_struct = strlen(s); + n_array = (unsigned) -1; + break; } @@ -1209,15 +1999,20 @@ static int message_append_ap( r = sd_bus_message_open_container(m, *t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s); if (r < 0) return r; + } - t += k - 1; + if (n_array == (unsigned) -1) { + types += k - 1; + n_struct -= k - 1; + } - r = message_append_ap(m, s, ap); - if (r < 0) - return r; + r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array); + if (r < 0) + return r; - r = sd_bus_message_close_container(m); - } + types = t + 1; + n_struct = k - 2; + n_array = (unsigned) -1; break; } @@ -1241,26 +2036,86 @@ int sd_bus_message_append(sd_bus_message *m, const char *types, ...) { return -EINVAL; if (m->sealed) return -EPERM; + if (m->poisoned) + return -ESTALE; if (!types) - return -EINVAL; + return 0; va_start(ap, types); - r = message_append_ap(m, types, ap); + r = bus_message_append_ap(m, types, ap); va_end(ap); return r; } +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; + + align = bus_type_get_alignment(type); + sz = bus_type_get_size(type); + + assert_se(align > 0); + assert_se(sz > 0); + + if (size % sz != 0) + return -EINVAL; + + r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type)); + if (r < 0) + return r; + + a = message_extend_body(m, align, size); + if (!a) + return -ENOMEM; + + r = sd_bus_message_close_container(m); + if (r < 0) + return r; + + *ptr = a; + return 0; +} + +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; + + r = sd_bus_message_append_array_space(m, type, size, &p); + if (r < 0) + return r; + + if (size > 0) + memcpy(p, ptr, size); + + return 0; +} + static int buffer_peek(const void *p, uint32_t sz, size_t *rindex, size_t align, size_t nbytes, void **r) { - size_t k, start, n; + size_t k, start, end; assert(rindex); assert(align > 0); start = ALIGN_TO((size_t) *rindex, align); - n = start + nbytes; + end = start + nbytes; - if (n > sz) + if (end > sz) return -EBADMSG; /* Verify that padding is 0 */ @@ -1271,7 +2126,7 @@ static int buffer_peek(const void *p, uint32_t sz, size_t *rindex, size_t align, if (r) *r = (uint8_t*) p + start; - *rindex = n; + *rindex = end; return 1; } @@ -1288,19 +2143,88 @@ static bool message_end_of_array(sd_bus_message *m, size_t index) { return index >= c->begin + BUS_MESSAGE_BSWAP32(m, *c->array_size); } -static int message_peek_body(sd_bus_message *m, size_t *rindex, size_t align, size_t nbytes, void **ret) { +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; assert(m); - assert(rindex); - assert(align > 0); + + if (m->cached_rindex_part && index >= m->cached_rindex_part_begin) { + part = m->cached_rindex_part; + begin = m->cached_rindex_part_begin; + } else { + part = &m->body; + begin = 0; + } + + while (part) { + if (index < begin) + return NULL; + + if (index + sz <= begin + part->size) { + if (p) + *p = part->data ? (uint8_t*) part->data + index - begin : NULL; + + m->cached_rindex_part = part; + m->cached_rindex_part_begin = begin; + + return part; + } + + part = part->next; + } + + return NULL; +} + +static int message_peek_body( + sd_bus_message *m, + size_t *rindex, + size_t align, + size_t nbytes, + void **ret) { + + size_t k, start, end, padding; + struct bus_body_part *part; + uint8_t *q; + + assert(m); + assert(rindex); + assert(align > 0); if (message_end_of_array(m, *rindex)) return 0; - return buffer_peek(m->body, BUS_MESSAGE_BODY_SIZE(m), rindex, align, nbytes, ret); + start = ALIGN_TO((size_t) *rindex, align); + padding = start - *rindex; + end = start + nbytes; + + if (end > BUS_MESSAGE_BODY_SIZE(m)) + return -EBADMSG; + + part = find_part(m, *rindex, padding, (void**) &q); + if (!part) + return -EBADMSG; + + if (q) { + /* Verify padding */ + for (k = 0; k < padding; k++) + if (q[k] != 0) + return -EBADMSG; + } + + part = find_part(m, start, nbytes, (void**) &q); + if (!part || !q) + return -EBADMSG; + + *rindex = end; + + if (ret) + *ret = q; + + return 1; } -static bool validate_string(const char *s, size_t l) { - assert(s); +static bool validate_nul(const char *s, size_t l) { /* Check for NUL chars in the string */ if (memchr(s, 0, l)) @@ -1310,6 +2234,14 @@ static bool validate_string(const char *s, size_t l) { if (s[l] != 0) return false; + return true; +} + +static bool validate_string(const char *s, size_t l) { + + if (!validate_nul(s, l)) + return false; + /* Check if valid UTF8 */ if (!utf8_is_valid(s)) return false; @@ -1318,12 +2250,8 @@ static bool validate_string(const char *s, size_t l) { } static bool validate_signature(const char *s, size_t l) { - /* Check for NUL chars in the signature */ - if (memchr(s, 0, l)) - return false; - /* Check for NUL termination */ - if (s[l] != 0) + if (!validate_nul(s, l)) return false; /* Check if valid signature */ @@ -1333,6 +2261,17 @@ static bool validate_signature(const char *s, size_t l) { return true; } +static bool validate_object_path(const char *s, size_t l) { + + if (!validate_nul(s, l)) + return false; + + if (!object_path_is_valid(s)) + return false; + + return true; +} + int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) { struct bus_container *c; int r; @@ -1344,6 +2283,8 @@ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) { return -EPERM; if (!bus_type_is_basic(type)) return -EINVAL; + if (!p) + return -EINVAL; c = message_get_container(m); @@ -1372,8 +2313,13 @@ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) { if (r == 0) return -EBADMSG; - if (!validate_string(q, l)) - return -EBADMSG; + if (type == SD_BUS_TYPE_OBJECT_PATH) { + if (!validate_object_path(q, l)) + return -EBADMSG; + } else { + if (!validate_string(q, l)) + return -EBADMSG; + } m->rindex = rindex; *(const char**) p = q; @@ -1405,12 +2351,15 @@ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) { } default: { - size_t sz, align; + ssize_t sz, align; + size_t rindex; align = bus_type_get_alignment(type); sz = bus_type_get_size(type); + assert(align > 0 && sz > 0); - r = message_peek_body(m, &m->rindex, align, sz, &q); + rindex = m->rindex; + r = message_peek_body(m, &rindex, align, sz, &q); if (r <= 0) return r; @@ -1440,10 +2389,23 @@ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *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; + + *(int*) p = m->fds[j]; + break; + } + default: assert_not_reached("Unknown basic type..."); } + m->rindex = rindex; + break; } } @@ -1490,8 +2452,8 @@ static int bus_message_enter_array( if (r <= 0) return r; - if (BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q) > 67108864) - return -E2BIG; + 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) @@ -1638,6 +2600,7 @@ int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *con struct bus_container *c, *w; uint32_t *array_size = NULL; char *signature; + size_t before; int r; if (!m) @@ -1647,6 +2610,25 @@ int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *con if (!contents) return -EINVAL; + /* + * We enforce a global limit on container depth, that is much + * higher than the 32 structs and 32 arrays the specification + * mandates. This is simpler to implement for us, and we need + * this only to ensure our container array doesn't grow + * without bounds. We are happy to return any data from a + * message as long as the data itself is valid, even if the + * overall message might be not. + * + * Note that the message signature is validated when + * parsing the headers, and that validation does check the + * 32/32 limit. + * + * Note that the specification defines no limits on the depth + * of stacked variants, but we do. + */ + if (m->n_containers >= BUS_CONTAINER_DEPTH) + return -EBADMSG; + w = realloc(m->containers, sizeof(struct bus_container) * (m->n_containers + 1)); if (!w) return -ENOMEM; @@ -1661,6 +2643,9 @@ int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *con if (!signature) return -ENOMEM; + c->saved_index = c->index; + before = m->rindex; + if (type == SD_BUS_TYPE_ARRAY) r = bus_message_enter_array(m, c, contents, &array_size); else if (type == SD_BUS_TYPE_VARIANT) @@ -1683,6 +2668,7 @@ int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *con w->signature = signature; w->index = 0; w->array_size = array_size; + w->before = before; w->begin = m->rindex; return 1; @@ -1717,6 +2703,28 @@ int sd_bus_message_exit_container(sd_bus_message *m) { return 1; } +static void message_quit_container(sd_bus_message *m) { + struct bus_container *c; + + assert(m); + assert(m->sealed); + assert(m->n_containers > 0); + + c = message_get_container(m); + + /* Undo seeks */ + assert(m->rindex >= c->before); + m->rindex = c->before; + + /* Free container */ + free(c->signature); + m->n_containers--; + + /* Correct index of new top-level container */ + c = message_get_container(m); + c->index = c->saved_index; +} + int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents) { struct bus_container *c; int r; @@ -1752,6 +2760,8 @@ int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **content if (r < 0) return r; + assert(l >= 1); + sig = strndup(c->signature + c->index + 1, l); if (!sig) return -ENOMEM; @@ -1837,7 +2847,7 @@ eof: return 0; } -int sd_bus_message_rewind(sd_bus_message *m, bool complete) { +int sd_bus_message_rewind(sd_bus_message *m, int complete) { struct bus_container *c; if (!m) @@ -1846,7 +2856,7 @@ int sd_bus_message_rewind(sd_bus_message *m, bool complete) { return -EPERM; if (complete) { - reset_containers(m); + message_reset_containers(m); m->rindex = 0; m->root_container.index = 0; @@ -1860,15 +2870,56 @@ int sd_bus_message_rewind(sd_bus_message *m, bool complete) { return !isempty(c->signature); } +static int message_read_ap( + sd_bus_message *m, + const char *types, + va_list ap) { -static int message_read_ap(sd_bus_message *m, const char *types, va_list ap) { - const char *t; + unsigned n_array, n_struct; + TypeStack stack[BUS_CONTAINER_DEPTH]; + unsigned stack_ptr = 0; int r; assert(m); - assert(types); - for (t = types; *t; t++) { + if (!types) + return 0; + + /* Ideally, we'd just call ourselves recursively on every + * complex type. However, the state of a va_list that is + * passed to a function is undefined after that function + * returns. This means we need to docode the va_list linearly + * in a single stackframe. We hence implement our own + * home-grown stack in an array. */ + + n_array = (unsigned) -1; + n_struct = strlen(types); + + for (;;) { + const char *t; + + if (n_array == 0 || (n_array == (unsigned) -1 && n_struct == 0)) { + r = type_stack_pop(stack, ELEMENTSOF(stack), &stack_ptr, &types, &n_struct, &n_array); + if (r < 0) + return r; + if (r == 0) + break; + + r = sd_bus_message_exit_container(m); + if (r < 0) + return r; + + continue; + } + + t = types; + if (n_array != (unsigned) -1) + n_array --; + else { + types ++; + n_struct--; + } + switch (*t) { case SD_BUS_TYPE_BYTE: @@ -1882,11 +2933,17 @@ static int message_read_ap(sd_bus_message *m, const char *types, va_list ap) { 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_SIGNATURE: + case SD_BUS_TYPE_UNIX_FD: { void *p; p = va_arg(ap, void*); r = sd_bus_message_read_basic(m, *t, p); + if (r < 0) + return r; + if (r == 0) + return -ENXIO; + break; } @@ -1898,29 +2955,30 @@ static int message_read_ap(sd_bus_message *m, const char *types, va_list ap) { return r; { - unsigned i, n; char s[k + 1]; - memcpy(s, t + 1, k); s[k] = 0; - t += k; r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, s); if (r < 0) return r; if (r == 0) return -ENXIO; + } - n = va_arg(ap, unsigned); - for (i = 0; i < n; i++) { - r = message_read_ap(m, s, ap); - if (r < 0) - return r; - } - - r = sd_bus_message_exit_container(m); + if (n_array == (unsigned) -1) { + types += k; + n_struct -= k; } + r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array); + if (r < 0) + return r; + + types = t + 1; + n_struct = k; + n_array = va_arg(ap, unsigned); + break; } @@ -1937,13 +2995,14 @@ static int message_read_ap(sd_bus_message *m, const char *types, va_list ap) { if (r == 0) return -ENXIO; - r = message_read_ap(m, s, ap); + r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array); if (r < 0) return r; - if (r == 0) - return -ENXIO; - r = sd_bus_message_exit_container(m); + types = s; + n_struct = strlen(s); + n_array = (unsigned) -1; + break; } @@ -1965,29 +3024,27 @@ static int message_read_ap(sd_bus_message *m, const char *types, va_list ap) { return r; if (r == 0) return -ENXIO; + } - t += k - 1; + if (n_array == (unsigned) -1) { + types += k - 1; + n_struct -= k - 1; + } - r = message_read_ap(m, s, ap); - if (r < 0) - return r; - if (r == 0) - return -ENXIO; + r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array); + if (r < 0) + return r; - r = sd_bus_message_exit_container(m); - } + types = t + 1; + n_struct = k - 2; + n_array = (unsigned) -1; break; } default: - r = -EINVAL; + return -EINVAL; } - - if (r < 0) - return r; - if (r == 0) - return -ENXIO; } return 1; @@ -2011,51 +3068,496 @@ int sd_bus_message_read(sd_bus_message *m, const char *types, ...) { return r; } -int bus_message_parse(sd_bus_message *m) { +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; + + if (!m) + return -EINVAL; + if (!m->sealed) + return -EPERM; + if (!bus_type_is_trivial(type)) + return -EINVAL; + if (!ptr) + return -EINVAL; + if (!size) + return -EINVAL; + if (BUS_MESSAGE_NEED_BSWAP(m)) + return -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); + + 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); + if (r < 0) + goto fail; + + *ptr = (const void*) p; + *size = sz; + + return 1; + +fail: + message_quit_container(m); + return r; +} + +static int message_peek_fields( + sd_bus_message *m, + size_t *rindex, + size_t align, + size_t nbytes, + void **ret) { + assert(m); + assert(rindex); + assert(align > 0); + + return buffer_peek(m->fields, BUS_MESSAGE_FIELDS_SIZE(m), rindex, align, nbytes, ret); +} - if (m->header->version != 1) - return -EIO; +static int message_peek_field_uint32( + sd_bus_message *m, + size_t *ri, + uint32_t *ret) { - if (m->header->endian != SD_BUS_BIG_ENDIAN && - m->header->endian != SD_BUS_LITTLE_ENDIAN) - return -EIO; + int r; + void *q; + + assert(m); + assert(ri); + + r = message_peek_fields(m, ri, 4, 4, &q); + if (r < 0) + return r; + + if (ret) + *ret = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q); return 0; } -static void setup_iovec(sd_bus_message *m) { +static int message_peek_field_string( + sd_bus_message *m, + bool (*validate)(const char *p), + size_t *ri, + const char **ret) { + + uint32_t l; + int r; + void *q; + assert(m); - assert(m->sealed); + assert(ri); + + r = message_peek_field_uint32(m, ri, &l); + if (r < 0) + return r; - m->n_iovec = 0; + r = message_peek_fields(m, ri, 1, l+1, &q); + if (r < 0) + return r; - m->iovec[m->n_iovec].iov_base = m->header; - m->iovec[m->n_iovec].iov_len = sizeof(*m->header); - m->n_iovec++; + if (validate) { + if (!validate_nul(q, l)) + return -EBADMSG; - if (m->fields) { - m->iovec[m->n_iovec].iov_base = m->fields; - m->iovec[m->n_iovec].iov_len = m->header->fields_size; - m->n_iovec++; + if (!validate(q)) + return -EBADMSG; + } else { + if (!validate_string(q, l)) + return -EBADMSG; + } + + if (ret) + *ret = q; + + return 0; +} + +static int message_peek_field_signature( + sd_bus_message *m, + size_t *ri, + const char **ret) { + + size_t l; + int r; + void *q; + + assert(m); + assert(ri); + + r = message_peek_fields(m, ri, 1, 1, &q); + if (r < 0) + return r; + + l = *(uint8_t*) q; + r = message_peek_fields(m, ri, 1, l+1, &q); + if (r < 0) + return r; + + if (!validate_signature(q, l)) + return -EBADMSG; + + if (ret) + *ret = q; + + return 0; +} + +static int message_skip_fields( + sd_bus_message *m, + size_t *ri, + uint32_t array_size, + const char **signature) { + + size_t original_index; + int r; + + assert(m); + assert(ri); + assert(signature); + + original_index = *ri; + + for (;;) { + char t; + size_t l; + + if (array_size != (uint32_t) -1 && + array_size <= *ri - original_index) + return 0; + + t = **signature; + if (!t) + return 0; + + if (t == SD_BUS_TYPE_STRING) { + + r = message_peek_field_string(m, NULL, ri, NULL); + if (r < 0) + return r; + + (*signature)++; + + } else if (t == SD_BUS_TYPE_OBJECT_PATH) { + + r = message_peek_field_string(m, object_path_is_valid, ri, NULL); + if (r < 0) + return r; + + (*signature)++; + + } else if (t == SD_BUS_TYPE_SIGNATURE) { + + r = message_peek_field_signature(m, ri, NULL); + if (r < 0) + return r; + + (*signature)++; + + } else if (bus_type_is_basic(t)) { + ssize_t align, k; + + align = bus_type_get_alignment(t); + k = bus_type_get_size(t); + assert(align > 0 && k > 0); + + r = message_peek_fields(m, ri, align, k, NULL); + if (r < 0) + return r; + + (*signature)++; + + } else if (t == SD_BUS_TYPE_ARRAY) { + + r = signature_element_length(*signature+1, &l); + if (r < 0) + return r; + + assert(l >= 1); + { + char sig[l-1], *s; + uint32_t nas; + int alignment; + + strncpy(sig, *signature + 1, l-1); + s = sig; + + alignment = bus_type_get_alignment(sig[0]); + if (alignment < 0) + return alignment; + + r = message_peek_field_uint32(m, ri, &nas); + if (r < 0) + return r; + if (nas > BUS_ARRAY_MAX_SIZE) + return -EBADMSG; + + r = message_peek_fields(m, ri, alignment, 0, NULL); + if (r < 0) + return r; + + r = message_skip_fields(m, ri, nas, (const char**) &s); + if (r < 0) + return r; + } + + (*signature) += 1 + l; + + } else if (t == SD_BUS_TYPE_VARIANT) { + const char *s; + + r = message_peek_field_signature(m, ri, &s); + if (r < 0) + return r; + + r = message_skip_fields(m, ri, (uint32_t) -1, (const char**) &s); + if (r < 0) + return r; + + (*signature)++; + + } else if (t == SD_BUS_TYPE_STRUCT || + t == SD_BUS_TYPE_DICT_ENTRY) { + + r = signature_element_length(*signature, &l); + if (r < 0) + return r; + + assert(l >= 2); + { + char sig[l-1], *s; + strncpy(sig, *signature + 1, l-1); + s = sig; + + r = message_skip_fields(m, ri, (uint32_t) -1, (const char**) &s); + if (r < 0) + return r; + } + + *signature += l; + } else + return -EINVAL; + } +} + +int bus_message_parse_fields(sd_bus_message *m) { + size_t ri; + int r; + uint32_t unix_fds = 0; + + assert(m); + + for (ri = 0; ri < BUS_MESSAGE_FIELDS_SIZE(m); ) { + const char *signature; + uint8_t *header; + + r = message_peek_fields(m, &ri, 8, 1, (void**) &header); + if (r < 0) + return r; + + r = message_peek_field_signature(m, &ri, &signature); + if (r < 0) + return r; + + switch (*header) { + case _SD_BUS_MESSAGE_HEADER_INVALID: + return -EBADMSG; + + case SD_BUS_MESSAGE_HEADER_PATH: + + if (m->path) + return -EBADMSG; + + if (!streq(signature, "o")) + return -EBADMSG; + + r = message_peek_field_string(m, object_path_is_valid, &ri, &m->path); + break; + + case SD_BUS_MESSAGE_HEADER_INTERFACE: + + if (m->interface) + return -EBADMSG; + + if (!streq(signature, "s")) + return -EBADMSG; + + r = message_peek_field_string(m, interface_name_is_valid, &ri, &m->interface); + break; + + case SD_BUS_MESSAGE_HEADER_MEMBER: + + if (m->member) + return -EBADMSG; + + if (!streq(signature, "s")) + return -EBADMSG; + + r = message_peek_field_string(m, member_name_is_valid, &ri, &m->member); + break; + + case SD_BUS_MESSAGE_HEADER_ERROR_NAME: + + if (m->error.name) + return -EBADMSG; + + if (!streq(signature, "s")) + return -EBADMSG; + + r = message_peek_field_string(m, error_name_is_valid, &ri, &m->error.name); + break; + + case SD_BUS_MESSAGE_HEADER_DESTINATION: + + if (m->destination) + return -EBADMSG; + + if (!streq(signature, "s")) + return -EBADMSG; + + r = message_peek_field_string(m, service_name_is_valid, &ri, &m->destination); + break; + + case SD_BUS_MESSAGE_HEADER_SENDER: + + if (m->sender) + return -EBADMSG; + + if (!streq(signature, "s")) + return -EBADMSG; - if (m->header->fields_size % 8 != 0) { - static const uint8_t padding[7] = { 0, 0, 0, 0, 0, 0, 0 }; + r = message_peek_field_string(m, service_name_is_valid, &ri, &m->sender); + break; + + + case SD_BUS_MESSAGE_HEADER_SIGNATURE: { + const char *s; + char *c; + + if (m->root_container.signature) + return -EBADMSG; + + if (!streq(signature, "g")) + return -EBADMSG; - m->iovec[m->n_iovec].iov_base = (void*) padding; - m->iovec[m->n_iovec].iov_len = 8 - m->header->fields_size % 8; - m->n_iovec++; + r = message_peek_field_signature(m, &ri, &s); + if (r < 0) + return r; + + c = strdup(s); + if (!c) + return -ENOMEM; + + free(m->root_container.signature); + m->root_container.signature = c; + break; + } + + case SD_BUS_MESSAGE_HEADER_REPLY_SERIAL: + if (m->reply_serial != 0) + return -EBADMSG; + + if (!streq(signature, "u")) + return -EBADMSG; + + r = message_peek_field_uint32(m, &ri, &m->reply_serial); + if (r < 0) + return r; + + if (m->reply_serial == 0) + return -EBADMSG; + + break; + + case SD_BUS_MESSAGE_HEADER_UNIX_FDS: + if (unix_fds != 0) + return -EBADMSG; + + if (!streq(signature, "u")) + return -EBADMSG; + + r = message_peek_field_uint32(m, &ri, &unix_fds); + if (r < 0) + return -EBADMSG; + + if (unix_fds == 0) + return -EBADMSG; + + break; + + default: + r = message_skip_fields(m, &ri, (uint32_t) -1, (const char **) &signature); } + + if (r < 0) + return r; } - if (m->body) { - m->iovec[m->n_iovec].iov_base = m->body; - m->iovec[m->n_iovec].iov_len = m->header->body_size; - m->n_iovec++; + if (m->n_fds != unix_fds) + return -EBADMSG; + + if (isempty(m->root_container.signature) != (BUS_MESSAGE_BODY_SIZE(m) == 0)) + return -EBADMSG; + + switch (m->header->type) { + + case SD_BUS_MESSAGE_TYPE_SIGNAL: + if (!m->path || !m->interface || !m->member) + return -EBADMSG; + break; + + case SD_BUS_MESSAGE_TYPE_METHOD_CALL: + + if (!m->path || !m->member) + return -EBADMSG; + + break; + + case SD_BUS_MESSAGE_TYPE_METHOD_RETURN: + + if (m->reply_serial == 0) + return -EBADMSG; + break; + + case SD_BUS_MESSAGE_TYPE_METHOD_ERROR: + + if (m->reply_serial == 0 || !m->error.name) + return -EBADMSG; + break; } + + /* Try to read the error message, but if we can't it's a non-issue */ + if (m->header->type == SD_BUS_MESSAGE_TYPE_METHOD_ERROR) + sd_bus_message_read(m, "s", &m->error.message); + + return 0; } int bus_message_seal(sd_bus_message *m, uint64_t serial) { + struct bus_body_part *part; + size_t l, a; + unsigned i; int r; assert(m); @@ -2068,7 +3570,7 @@ int bus_message_seal(sd_bus_message *m, uint64_t serial) { /* If there's a non-trivial signature set, then add it in here */ if (!isempty(m->root_container.signature)) { - r = message_append_field_signature(m, SD_BUS_MESSAGE_HEADER_SIGNATURE, m->root_container.signature, &m->signature); + r = message_append_field_signature(m, SD_BUS_MESSAGE_HEADER_SIGNATURE, m->root_container.signature, NULL); if (r < 0) return r; } @@ -2079,11 +3581,29 @@ int bus_message_seal(sd_bus_message *m, uint64_t serial) { return r; } + l = BUS_MESSAGE_FIELDS_SIZE(m); + a = ALIGN8(l) - l; + + if (a > 0) { + /* Add padding at the end, since we know the body + * needs to start at an 8 byte alignment. */ + void *p; + + p = message_extend_fields(m, 1, a); + if (!p) + return -ENOMEM; + + memset(p, 0, a); + m->header->fields_size -= a; + } + + for (i = 0, part = &m->body; i < m->n_body_parts; i++, part = part->next) + if (part->memfd >= 0 && part->sealed) + ioctl(part->memfd, KDBUS_CMD_MEMFD_SEAL_SET, 1); + m->header->serial = serial; m->sealed = true; - setup_iovec(m); - return 0; } @@ -2101,8 +3621,12 @@ int sd_bus_message_set_destination(sd_bus_message *m, const char *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); @@ -2139,19 +3663,76 @@ int bus_message_dump(sd_bus_message *m) { strna(m->member), strna(m->destination), strna(m->sender), - strna(m->signature), + strna(m->root_container.signature), m->reply_serial, strna(m->error.name), strna(m->error.message), yes_no(m->sealed)); + 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->signature)); + printf("BEGIN_MESSAGE \"%s\" {\n", strempty(m->root_container.signature)); for(;;) { _cleanup_free_ char *prefix = NULL; @@ -2299,25 +3880,117 @@ int bus_message_dump(sd_bus_message *m) { int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz) { size_t total; - unsigned i; void *p, *e; + unsigned i; + struct bus_body_part *part; assert(m); assert(buffer); assert(sz); - for (i = 0, total = 0; i < m->n_iovec; i++) - total += m->iovec[i].iov_len; + total = BUS_MESSAGE_SIZE(m); p = malloc(total); if (!p) return -ENOMEM; - for (i = 0, e = p; i < m->n_iovec; i++) - e = mempcpy(e, m->iovec[i].iov_base, m->iovec[i].iov_len); + e = mempcpy(p, m->header, sizeof(*m->header)); + + if (m->fields) { + e = mempcpy(e, m->fields, m->header->fields_size); + + if (m->header->fields_size % 8 != 0) + e = mempset(e, 0, 8 - (m->header->fields_size % 8)); + } + + for (i = 0, part = &m->body; i < m->n_body_parts; i++, part = part->next) + e = mempcpy(e, part->data, part->size); + + assert(total == (size_t) ((uint8_t*) e - (uint8_t*) p)); *buffer = p; *sz = total; return 0; } + +int bus_message_read_strv_extend(sd_bus_message *m, char ***l) { + int r; + + assert(m); + assert(l); + + r = sd_bus_message_enter_container(m, 'a', "s"); + if (r < 0) + return r; + + for (;;) { + const char *s; + + r = sd_bus_message_read_basic(m, 's', &s); + if (r < 0) + return r; + if (r == 0) + break; + + r = strv_extend(l, s); + if (r < 0) + return r; + } + + r = sd_bus_message_exit_container(m); + if (r < 0) + return r; + + return 0; +} + +const char* bus_message_get_arg(sd_bus_message *m, unsigned i) { + int r; + const char *t = NULL; + unsigned j; + + assert(m); + + r = sd_bus_message_rewind(m, true); + if (r < 0) + return NULL; + + for (j = 0; j <= i; j++) { + char type; + + r = sd_bus_message_peek_type(m, &type, NULL); + if (r < 0) + return NULL; + + if (type != SD_BUS_TYPE_STRING && + type != SD_BUS_TYPE_OBJECT_PATH && + type != SD_BUS_TYPE_SIGNATURE) + return NULL; + + r = sd_bus_message_read_basic(m, type, &t); + if (r < 0) + return NULL; + } + + return t; +} + +int bus_header_size(struct bus_header *h, size_t *sum) { + size_t fs, bs; + + assert(h); + assert(sum); + + if (h->endian == SD_BUS_NATIVE_ENDIAN) { + fs = h->fields_size; + bs = h->body_size; + } else if (h->endian == SD_BUS_REVERSE_ENDIAN) { + fs = bswap_32(h->fields_size); + bs = bswap_32(h->body_size); + } else + return -EBADMSG; + + *sum = sizeof(struct bus_header) + ALIGN8(fs) + bs; + return 0; +}