X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Flibsystemd%2Fsd-bus%2Fbus-kernel.c;h=b884074d95cd85e14d742684402e1cfe9263af4b;hp=84fb4bdf2b4af185c8ab6f0de7523c96d5a6ce79;hb=eef46c372f64f40dd75415b2c504c73138719c8d;hpb=1214b53c8e463ec328021e90163279ac94dd9af8 diff --git a/src/libsystemd/sd-bus/bus-kernel.c b/src/libsystemd/sd-bus/bus-kernel.c index 84fb4bdf2..b884074d9 100644 --- a/src/libsystemd/sd-bus/bus-kernel.c +++ b/src/libsystemd/sd-bus/bus-kernel.c @@ -25,13 +25,19 @@ #include #include -#include #include #include +/* When we include libgen.h because we need dirname() we immediately + * undefine basename() since libgen.h defines it as a macro to the XDG + * version which is really broken. */ +#include +#undef basename + #include "util.h" #include "strv.h" #include "memfd-util.h" +#include "capability.h" #include "cgroup-util.h" #include "fileio.h" @@ -78,7 +84,7 @@ static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size); } -static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t sz) { +static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t start, size_t sz) { assert(d); assert(memfd >= 0); assert(sz > 0); @@ -87,6 +93,7 @@ static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t sz) { (*d)->size = offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd); (*d)->type = KDBUS_ITEM_PAYLOAD_MEMFD; (*d)->memfd.fd = memfd; + (*d)->memfd.start = start; (*d)->memfd.size = sz; *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size); @@ -135,6 +142,32 @@ static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) { *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size); } +static void add_bloom_arg(void *data, size_t size, unsigned n_hash, unsigned i, const char *t) { + char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")]; + char *e; + + assert(data); + assert(size > 0); + assert(i < 64); + assert(t); + + e = stpcpy(buf, "arg"); + if (i < 10) + *(e++) = '0' + (char) i; + else { + *(e++) = '0' + (char) (i / 10); + *(e++) = '0' + (char) (i % 10); + } + + *e = 0; + bloom_add_pair(data, size, n_hash, buf, t); + + strcpy(e, "-dot-prefix"); + bloom_add_prefixes(data, size, n_hash, buf, t, '.'); + strcpy(e, "-slash-prefix"); + bloom_add_prefixes(data, size, n_hash, buf, t, '/'); +} + static int bus_message_setup_bloom(sd_bus_message *m, struct kdbus_bloom_filter *bloom) { void *data; unsigned i; @@ -164,39 +197,42 @@ static int bus_message_setup_bloom(sd_bus_message *m, struct kdbus_bloom_filter return r; for (i = 0; i < 64; i++) { + const char *t, *contents; char type; - const char *t; - char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")]; - char *e; - r = sd_bus_message_peek_type(m, &type, NULL); + r = sd_bus_message_peek_type(m, &type, &contents); if (r < 0) return r; - if (type != SD_BUS_TYPE_STRING && - type != SD_BUS_TYPE_OBJECT_PATH && - type != SD_BUS_TYPE_SIGNATURE) - break; + if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE)) { - r = sd_bus_message_read_basic(m, type, &t); - if (r < 0) - return r; + /* The bloom filter includes simple strings of any kind */ + r = sd_bus_message_read_basic(m, type, &t); + if (r < 0) + return r; - e = stpcpy(buf, "arg"); - if (i < 10) - *(e++) = '0' + (char) i; - else { - *(e++) = '0' + (char) (i / 10); - *(e++) = '0' + (char) (i % 10); - } + add_bloom_arg(data, m->bus->bloom_size, m->bus->bloom_n_hash, i, t); + } if (type == SD_BUS_TYPE_ARRAY && STR_IN_SET(contents, "s", "o", "g")) { + + /* As well as array of simple strings of any kinds */ + r = sd_bus_message_enter_container(m, type, contents); + if (r < 0) + return r; - *e = 0; - bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t); + while ((r = sd_bus_message_read_basic(m, contents[0], &t)) > 0) + add_bloom_arg(data, m->bus->bloom_size, m->bus->bloom_n_hash, i, t); + if (r < 0) + return r; + + r = sd_bus_message_exit_container(m); + if (r < 0) + return r; - strcpy(e, "-dot-prefix"); - bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t, '.'); - strcpy(e, "-slash-prefix"); - bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t, '/'); + } else + /* Stop adding to bloom filter as soon as we + * run into the first argument we cannot add + * to it. */ + break; } return 0; @@ -234,12 +270,10 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) { sz = offsetof(struct kdbus_msg, items); - assert_cc(ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec)) == - ALIGN8(offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd))); - /* Add in fixed header, fields header and payload */ - sz += (1 + m->n_body_parts) * - ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec)); + sz += (1 + m->n_body_parts) * ALIGN8(offsetof(struct kdbus_item, vec) + + MAX(sizeof(struct kdbus_vec), + sizeof(struct kdbus_memfd))); /* Add space for bloom filter */ sz += ALIGN8(offsetof(struct kdbus_item, bloom_filter) + @@ -266,8 +300,9 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) { memzero(m->kdbus, sz); m->kdbus->flags = - ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) | - ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0); + ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_EXPECT_REPLY) | + ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_NO_AUTO_START : 0) | + ((m->header->type == SD_BUS_MESSAGE_SIGNAL) ? KDBUS_MSG_SIGNAL : 0); if (well_known) /* verify_destination_id will usually be 0, which makes the kernel driver only look @@ -314,7 +349,7 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) { /* Try to send a memfd, if the part is * sealed and this is not a broadcast. Since we can only */ - append_payload_memfd(&d, part->memfd, part->size); + append_payload_memfd(&d, part->memfd, part->memfd_offset, part->size); continue; } @@ -327,7 +362,7 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) { append_payload_vec(&d, part->data, part->size); } - if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) { + if (m->header->type == SD_BUS_MESSAGE_SIGNAL) { struct kdbus_bloom_filter *bloom; bloom = append_bloom(&d, m->bus->bloom_size); @@ -349,15 +384,6 @@ fail: return r; } -static void bus_message_set_sender_driver(sd_bus *bus, sd_bus_message *m) { - assert(bus); - assert(m); - - m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus"; - m->creds.well_known_names_driver = true; - m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask; -} - static void unset_memfds(struct sd_bus_message *m) { struct bus_body_part *part; unsigned i; @@ -370,6 +396,21 @@ static void unset_memfds(struct sd_bus_message *m) { part->memfd = -1; } +static void message_set_timestamp(sd_bus *bus, sd_bus_message *m, const struct kdbus_timestamp *ts) { + assert(bus); + assert(m); + + if (!ts) + return; + + if (!(bus->attach_flags & KDBUS_ATTACH_TIMESTAMP)) + return; + + m->realtime = ts->realtime_ns / NSEC_PER_USEC; + m->monotonic = ts->monotonic_ns / NSEC_PER_USEC; + m->seqnum = ts->seqnum; +} + static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { sd_bus_message *m = NULL; struct kdbus_item *d; @@ -393,7 +434,7 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { case KDBUS_ITEM_PAYLOAD_OFF: if (!h) { - h = (struct bus_header *)((uint8_t *)k + d->vec.offset); + h = (struct bus_header *)((uint8_t *)bus->kdbus_buffer + d->vec.offset); if (!bus_header_is_complete(h, d->vec.size)) return -EBADMSG; @@ -485,11 +526,11 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { if (idx >= begin_body) { if (!part->is_zero) - part->data = (uint8_t *)k + d->vec.offset; + part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset; part->size = d->vec.size; } else { if (!part->is_zero) - part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx); + part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset + (begin_body - idx); part->size = d->vec.size - (begin_body - idx); } @@ -515,6 +556,7 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { } part->memfd = d->memfd.fd; + part->memfd_offset = d->memfd.start; part->size = d->memfd.size; part->sealed = true; @@ -524,22 +566,17 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { case KDBUS_ITEM_PIDS: - /* The PID starttime/TID might be missing, - * when the data is faked by some data bus - * proxy and it lacks that information about - * the real client since SO_PEERCRED is used - * for that. */ + /* The PID/TID might be missing, when the data + * is faked by some data bus proxy and it + * lacks that information about the real + * client since SO_PEERCRED is used for + * that. */ if (d->pids.pid > 0) { m->creds.pid = (pid_t) d->pids.pid; m->creds.mask |= SD_BUS_CREDS_PID & bus->creds_mask; } - if (d->pids.starttime > 0) { - m->creds.pid_starttime = d->pids.starttime / NSEC_PER_USEC; - m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask; - } - if (d->pids.tid > 0) { m->creds.tid = (pid_t) d->pids.tid; m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask; @@ -551,42 +588,42 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { /* EUID/SUID/FSUID/EGID/SGID/FSGID might be missing too (see above). */ - if ((uid_t) d->creds.uid != (uid_t) -1) { + if ((uid_t) d->creds.uid != UID_INVALID) { m->creds.uid = (uid_t) d->creds.uid; m->creds.mask |= SD_BUS_CREDS_UID & bus->creds_mask; } - if ((uid_t) d->creds.euid != (uid_t) -1) { + if ((uid_t) d->creds.euid != UID_INVALID) { m->creds.euid = (uid_t) d->creds.euid; m->creds.mask |= SD_BUS_CREDS_EUID & bus->creds_mask; } - if ((uid_t) d->creds.suid != (uid_t) -1) { + if ((uid_t) d->creds.suid != UID_INVALID) { m->creds.suid = (uid_t) d->creds.suid; m->creds.mask |= SD_BUS_CREDS_SUID & bus->creds_mask; } - if ((uid_t) d->creds.fsuid != (uid_t) -1) { + if ((uid_t) d->creds.fsuid != UID_INVALID) { m->creds.fsuid = (uid_t) d->creds.fsuid; m->creds.mask |= SD_BUS_CREDS_FSUID & bus->creds_mask; } - if ((gid_t) d->creds.gid != (gid_t) -1) { + if ((gid_t) d->creds.gid != GID_INVALID) { m->creds.gid = (gid_t) d->creds.gid; m->creds.mask |= SD_BUS_CREDS_GID & bus->creds_mask; } - if ((gid_t) d->creds.egid != (gid_t) -1) { + if ((gid_t) d->creds.egid != GID_INVALID) { m->creds.egid = (gid_t) d->creds.egid; m->creds.mask |= SD_BUS_CREDS_EGID & bus->creds_mask; } - if ((gid_t) d->creds.sgid != (gid_t) -1) { + if ((gid_t) d->creds.sgid != GID_INVALID) { m->creds.sgid = (gid_t) d->creds.sgid; m->creds.mask |= SD_BUS_CREDS_SGID & bus->creds_mask; } - if ((gid_t) d->creds.fsgid != (gid_t) -1) { + if ((gid_t) d->creds.fsgid != GID_INVALID) { m->creds.fsgid = (gid_t) d->creds.fsgid; m->creds.mask |= SD_BUS_CREDS_FSGID & bus->creds_mask; } @@ -594,13 +631,7 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { break; case KDBUS_ITEM_TIMESTAMP: - - if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) { - m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC; - m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC; - m->seqnum = d->timestamp.seqnum; - } - + message_set_timestamp(bus, m, &d->timestamp); break; case KDBUS_ITEM_PID_COMM: @@ -642,15 +673,20 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { m->creds.mask |= SD_BUS_CREDS_AUDIT_SESSION_ID & bus->creds_mask; } - if ((uid_t) d->audit.loginuid != (uid_t) -1) { + if ((uid_t) d->audit.loginuid != UID_INVALID) { m->creds.audit_login_uid = (uid_t) d->audit.loginuid; m->creds.mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID & bus->creds_mask; } break; case KDBUS_ITEM_CAPS: - m->creds.capability = (uint8_t *) d->caps.caps; - m->creds.capability_size = d->size - offsetof(struct kdbus_item, caps.caps); + if (d->caps.last_cap != cap_last_cap() || + d->size - offsetof(struct kdbus_item, caps.caps) < DIV_ROUND_UP(d->caps.last_cap, 32U) * 4 * 4) { + r = -EBADMSG; + goto fail; + } + + m->creds.capability = d->caps.caps; m->creds.mask |= (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS) & bus->creds_mask; break; @@ -720,7 +756,7 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { /* If we requested the list of well-known names to be appended * and the sender had none no item for it will be - * attached. However, this does *not* mean that we the kernel + * attached. However, this does *not* mean that the kernel * didn't want to provide this information to us. Hence, let's * explicitly mark this information as available if it was * requested. */ @@ -737,7 +773,7 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { } /* Refuse messages where the reply flag doesn't match up */ - if (!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) != !!(k->flags & KDBUS_MSG_FLAGS_EXPECT_REPLY)) { + if (!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) != !!(k->flags & KDBUS_MSG_EXPECT_REPLY)) { r = -EBADMSG; goto fail; } @@ -749,7 +785,7 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { } /* Refuse messages where the autostart flag doesn't match up */ - if (!(m->header->flags & BUS_MESSAGE_NO_AUTO_START) != !(k->flags & KDBUS_MSG_FLAGS_NO_AUTO_START)) { + if (!(m->header->flags & BUS_MESSAGE_NO_AUTO_START) != !(k->flags & KDBUS_MSG_NO_AUTO_START)) { r = -EBADMSG; goto fail; } @@ -791,7 +827,9 @@ fail: } int bus_kernel_take_fd(sd_bus *b) { + struct kdbus_bloom_parameter *bloom = NULL; struct kdbus_cmd_hello *hello; + struct kdbus_item_list *items; struct kdbus_item *item; _cleanup_free_ char *g = NULL; const char *name; @@ -904,23 +942,40 @@ int bus_kernel_take_fd(sd_bus *b) { b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0); if (b->kdbus_buffer == MAP_FAILED) { b->kdbus_buffer = NULL; - return -errno; + r = -errno; + goto fail; } } /* The higher 32bit of the bus_flags fields are considered * 'incompatible flags'. Refuse them all for now. */ - if (hello->bus_flags > 0xFFFFFFFFULL) - return -ENOTSUP; + if (hello->bus_flags > 0xFFFFFFFFULL) { + r = -ENOTSUP; + goto fail; + } - if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash)) - return -ENOTSUP; + /* extract bloom parameters from items */ + items = (void*)((uint8_t*)b->kdbus_buffer + hello->offset); + KDBUS_ITEM_FOREACH(item, items, items) { + switch (item->type) { + case KDBUS_ITEM_BLOOM_PARAMETER: + bloom = &item->bloom_parameter; + break; + } + } - b->bloom_size = (size_t) hello->bloom.size; - b->bloom_n_hash = (unsigned) hello->bloom.n_hash; + if (!bloom || !bloom_validate_parameters((size_t) bloom->size, (unsigned) bloom->n_hash)) { + r = -ENOTSUP; + goto fail; + } - if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0) - return -ENOMEM; + b->bloom_size = (size_t) bloom->size; + b->bloom_n_hash = (unsigned) bloom->n_hash; + + if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0) { + r = -ENOMEM; + goto fail; + } b->unique_id = hello->id; @@ -933,7 +988,13 @@ int bus_kernel_take_fd(sd_bus *b) { /* the kernel told us the UUID of the underlying bus */ memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes)); + /* free returned items */ + (void) bus_kernel_cmd_free(b, hello->offset); return bus_start_running(b); + +fail: + (void) bus_kernel_cmd_free(b, hello->offset); + return r; } int bus_kernel_connect(sd_bus *b) { @@ -954,27 +1015,41 @@ int bus_kernel_connect(sd_bus *b) { return bus_kernel_take_fd(b); } +int bus_kernel_cmd_free(sd_bus *bus, uint64_t offset) { + struct kdbus_cmd_free cmd = { + .size = sizeof(cmd), + .offset = offset, + }; + int r; + + assert(bus); + assert(bus->is_kernel); + + r = ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd); + if (r < 0) + return -errno; + + return 0; +} + static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) { - struct kdbus_cmd_free cmd = {}; struct kdbus_item *d; assert(bus); assert(k); - cmd.offset = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer; - KDBUS_ITEM_FOREACH(d, k, items) { - if (d->type == KDBUS_ITEM_FDS) close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int)); else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD) safe_close(d->memfd.fd); } - (void) ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd); + bus_kernel_cmd_free(bus, (uint8_t*) k - (uint8_t*) bus->kdbus_buffer); } int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) { + struct kdbus_cmd_send cmd = { }; int r; assert(bus); @@ -990,15 +1065,20 @@ int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call if (r < 0) return r; + cmd.size = sizeof(cmd); + cmd.msg_address = (uintptr_t)m->kdbus; + /* If this is a synchronous method call, then let's tell the * kernel, so that it can pass CPU time/scheduling to the * destination for the time, if it wants to. If we * synchronously wait for the result anyway, we won't need CPU * anyway. */ - if (hint_sync_call) - m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY; + if (hint_sync_call) { + m->kdbus->flags |= KDBUS_MSG_EXPECT_REPLY; + cmd.flags |= KDBUS_SEND_SYNC_REPLY; + } - r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus); + r = ioctl(bus->output_fd, KDBUS_CMD_SEND, &cmd); if (r < 0) { _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL; sd_bus_message *reply; @@ -1048,7 +1128,7 @@ int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call } else if (hint_sync_call) { struct kdbus_msg *k; - k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply); + k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + cmd.reply.offset); assert(k); if (k->payload_type == KDBUS_PAYLOAD_DBUS) { @@ -1059,7 +1139,7 @@ int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call /* Anybody can send us invalid messages, let's just drop them. */ if (r == -EBADMSG || r == -EPROTOTYPE) - log_debug("Ignoring invalid message: %s", strerror(-r)); + log_debug_errno(r, "Ignoring invalid message: %m"); else return r; } @@ -1072,7 +1152,13 @@ int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call return 1; } -static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) { +static int push_name_owner_changed( + sd_bus *bus, + const char *name, + const char *old_owner, + const char *new_owner, + const struct kdbus_timestamp *ts) { + _cleanup_bus_message_unref_ sd_bus_message *m = NULL; int r; @@ -1092,6 +1178,7 @@ static int push_name_owner_changed(sd_bus *bus, const char *name, const char *ol return r; bus_message_set_sender_driver(bus, m); + message_set_timestamp(bus, m, ts); r = bus_seal_synthetic_message(bus, m); if (r < 0) @@ -1103,7 +1190,12 @@ static int push_name_owner_changed(sd_bus *bus, const char *name, const char *ol return 1; } -static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) { +static int translate_name_change( + sd_bus *bus, + const struct kdbus_msg *k, + const struct kdbus_item *d, + const struct kdbus_timestamp *ts) { + char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX]; assert(bus); @@ -1124,10 +1216,15 @@ static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_ } else sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id); - return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner); + return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner, ts); } -static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) { +static int translate_id_change( + sd_bus *bus, + const struct kdbus_msg *k, + const struct kdbus_item *d, + const struct kdbus_timestamp *ts) { + char owner[UNIQUE_NAME_MAX]; assert(bus); @@ -1139,10 +1236,16 @@ static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_it return push_name_owner_changed( bus, owner, d->type == KDBUS_ITEM_ID_ADD ? NULL : owner, - d->type == KDBUS_ITEM_ID_ADD ? owner : NULL); + d->type == KDBUS_ITEM_ID_ADD ? owner : NULL, + ts); } -static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) { +static int translate_reply( + sd_bus *bus, + const struct kdbus_msg *k, + const struct kdbus_item *d, + const struct kdbus_timestamp *ts) { + _cleanup_bus_message_unref_ sd_bus_message *m = NULL; int r; @@ -1160,7 +1263,7 @@ static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item * if (r < 0) return r; - bus_message_set_sender_driver(bus, m); + message_set_timestamp(bus, m, ts); r = bus_seal_synthetic_message(bus, m); if (r < 0) @@ -1173,9 +1276,7 @@ static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item * } static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) { - struct kdbus_item *d, *found = NULL; - - static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = { + static int (* const translate[])(sd_bus *bus, const struct kdbus_msg *k, const struct kdbus_item *d, const struct kdbus_timestamp *ts) = { [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change, [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change, [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change, @@ -1187,11 +1288,17 @@ static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) { [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply, }; + struct kdbus_item *d, *found = NULL; + struct kdbus_timestamp *ts = NULL; + assert(bus); assert(k); assert(k->payload_type == KDBUS_PAYLOAD_KERNEL); KDBUS_ITEM_FOREACH(d, k, items) { + if (d->type == KDBUS_ITEM_TIMESTAMP) + ts = &d->timestamp; + if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) { if (found) return -EBADMSG; @@ -1205,11 +1312,11 @@ static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) { return 0; } - return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found); + return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found, ts); } int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) { - struct kdbus_cmd_recv recv = {}; + struct kdbus_cmd_recv recv = { .size = sizeof(recv) }; struct kdbus_msg *k; int r; @@ -1224,7 +1331,7 @@ int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) { recv.priority = priority; } - r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv); + r = ioctl(bus->input_fd, KDBUS_CMD_RECV, &recv); if (r < 0) { if (errno == EAGAIN) return 0; @@ -1237,13 +1344,13 @@ int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) { return -errno; } - k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset); + k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.msg.offset); if (k->payload_type == KDBUS_PAYLOAD_DBUS) { r = bus_kernel_make_message(bus, k); /* Anybody can send us invalid messages, let's just drop them. */ if (r == -EBADMSG || r == -EPROTOTYPE) { - log_debug("Ignoring invalid message: %s", strerror(-r)); + log_debug_errno(r, "Ignoring invalid message: %m"); r = 0; } @@ -1379,7 +1486,7 @@ uint64_t attach_flags_to_kdbus(uint64_t mask) { SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID)) m |= KDBUS_ATTACH_CREDS; - if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID)) + if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_TID)) m |= KDBUS_ATTACH_PIDS; if (mask & SD_BUS_CREDS_COMM) @@ -1419,7 +1526,7 @@ uint64_t attach_flags_to_kdbus(uint64_t mask) { } int bus_kernel_create_bus(const char *name, bool world, char **s) { - struct kdbus_cmd_make *make; + struct kdbus_cmd *make; struct kdbus_item *n; size_t l; int fd; @@ -1432,13 +1539,14 @@ int bus_kernel_create_bus(const char *name, bool world, char **s) { return -errno; l = strlen(name); - make = alloca0_align(offsetof(struct kdbus_cmd_make, items) + + make = alloca0_align(offsetof(struct kdbus_cmd, items) + ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) + ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) + + ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) + ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1), 8); - make->size = offsetof(struct kdbus_cmd_make, items); + make->size = offsetof(struct kdbus_cmd, items); /* Set the bloom parameters */ n = make->items; @@ -1461,6 +1569,13 @@ int bus_kernel_create_bus(const char *name, bool world, char **s) { n->data64[0] = _KDBUS_ATTACH_ANY; make->size += ALIGN8(n->size); + /* Provide all metadata via bus-owner queries */ + n = KDBUS_ITEM_NEXT(n); + n->type = KDBUS_ITEM_ATTACH_FLAGS_SEND; + n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t); + n->data64[0] = _KDBUS_ATTACH_ANY; + make->size += ALIGN8(n->size); + /* Set the a good name */ n = KDBUS_ITEM_NEXT(n); sprintf(n->str, UID_FMT "-%s", getuid(), name); @@ -1490,69 +1605,6 @@ int bus_kernel_create_bus(const char *name, bool world, char **s) { return fd; } -static int bus_kernel_translate_access(BusPolicyAccess access) { - assert(access >= 0); - assert(access < _BUS_POLICY_ACCESS_MAX); - - switch (access) { - - case BUS_POLICY_ACCESS_SEE: - return KDBUS_POLICY_SEE; - - case BUS_POLICY_ACCESS_TALK: - return KDBUS_POLICY_TALK; - - case BUS_POLICY_ACCESS_OWN: - return KDBUS_POLICY_OWN; - - default: - assert_not_reached("Unknown policy access"); - } -} - -static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) { - int r; - - assert(policy); - assert(item); - - switch (policy->type) { - - case BUSNAME_POLICY_TYPE_USER: { - const char *user = policy->name; - uid_t uid; - - r = get_user_creds(&user, &uid, NULL, NULL, NULL); - if (r < 0) - return r; - - item->policy_access.type = KDBUS_POLICY_ACCESS_USER; - item->policy_access.id = uid; - break; - } - - case BUSNAME_POLICY_TYPE_GROUP: { - const char *group = policy->name; - gid_t gid; - - r = get_group_creds(&group, &gid); - if (r < 0) - return r; - - item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP; - item->policy_access.id = gid; - break; - } - - default: - assert_not_reached("Unknown policy type"); - } - - item->policy_access.access = bus_kernel_translate_access(policy->access); - - return 0; -} - int bus_kernel_open_bus_fd(const char *bus, char **path) { char *p; int fd; @@ -1587,7 +1639,7 @@ int bus_kernel_open_bus_fd(const char *bus, char **path) { int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) { _cleanup_free_ char *path = NULL; - struct kdbus_cmd_make *make; + struct kdbus_cmd *make; struct kdbus_item *n; const char *name; int fd; @@ -1596,10 +1648,10 @@ int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char * if (fd < 0) return fd; - make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) + + make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd, items)) + ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1), 8); - make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items)); + make->size = ALIGN8(offsetof(struct kdbus_cmd, items)); make->flags = KDBUS_MAKE_ACCESS_WORLD; n = make->items; @@ -1629,131 +1681,13 @@ int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char * return fd; } -int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) { - - struct kdbus_cmd_update *update; - struct kdbus_item *n; - BusEndpointPolicy *po; - Iterator i; - size_t size; - int r; - - size = ALIGN8(offsetof(struct kdbus_cmd_update, items)); - - HASHMAP_FOREACH(po, ep->policy_hash, i) { - size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1); - size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access)); - } - - update = alloca0_align(size, 8); - update->size = size; - - n = update->items; - - HASHMAP_FOREACH(po, ep->policy_hash, i) { - n->type = KDBUS_ITEM_NAME; - n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1; - strcpy(n->str, po->name); - n = KDBUS_ITEM_NEXT(n); - - n->type = KDBUS_ITEM_POLICY_ACCESS; - n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access); - - n->policy_access.type = KDBUS_POLICY_ACCESS_USER; - n->policy_access.access = bus_kernel_translate_access(po->access); - n->policy_access.id = uid; - - n = KDBUS_ITEM_NEXT(n); - } - - r = ioctl(fd, KDBUS_CMD_ENDPOINT_UPDATE, update); - if (r < 0) - return -errno; - - return 0; -} - -int bus_kernel_make_starter( - int fd, - const char *name, - bool activating, - bool accept_fd, - BusNamePolicy *policy, - BusPolicyAccess world_policy) { - - struct kdbus_cmd_hello *hello; - struct kdbus_item *n; - size_t policy_cnt = 0; - BusNamePolicy *po; - size_t size; - int r; - - assert(fd >= 0); - assert(name); - - LIST_FOREACH(policy, po, policy) - policy_cnt++; - - if (world_policy >= 0) - policy_cnt++; - - size = offsetof(struct kdbus_cmd_hello, items) + - ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) + - policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access)); - - hello = alloca0_align(size, 8); - - n = hello->items; - strcpy(n->str, name); - n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1; - n->type = KDBUS_ITEM_NAME; - n = KDBUS_ITEM_NEXT(n); - - LIST_FOREACH(policy, po, policy) { - n->type = KDBUS_ITEM_POLICY_ACCESS; - n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access); - - r = bus_kernel_translate_policy(po, n); - if (r < 0) - return r; - - n = KDBUS_ITEM_NEXT(n); - } - - if (world_policy >= 0) { - n->type = KDBUS_ITEM_POLICY_ACCESS; - n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access); - n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD; - n->policy_access.access = bus_kernel_translate_access(world_policy); - } - - hello->size = size; - hello->flags = - (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) | - (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0); - hello->pool_size = KDBUS_POOL_SIZE; - hello->attach_flags_send = _KDBUS_ATTACH_ANY; - hello->attach_flags_recv = _KDBUS_ATTACH_ANY; - - if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) - return -errno; - - /* The higher 32bit of the bus_flags fields are considered - * 'incompatible flags'. Refuse them all for now. */ - if (hello->bus_flags > 0xFFFFFFFFULL) - return -ENOTSUP; - - if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash)) - return -ENOTSUP; - - return fd; -} - int bus_kernel_try_close(sd_bus *bus) { + struct kdbus_cmd byebye = { .size = sizeof(byebye) }; + assert(bus); assert(bus->is_kernel); - if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0) + if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE, &byebye) < 0) return -errno; return 0; @@ -1761,25 +1695,26 @@ int bus_kernel_try_close(sd_bus *bus) { int bus_kernel_drop_one(int fd) { struct kdbus_cmd_recv recv = { - .flags = KDBUS_RECV_DROP + .size = sizeof(recv), + .flags = KDBUS_RECV_DROP, }; assert(fd >= 0); - if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0) + if (ioctl(fd, KDBUS_CMD_RECV, &recv) < 0) return -errno; return 0; } int bus_kernel_realize_attach_flags(sd_bus *bus) { - struct kdbus_cmd_update *update; + struct kdbus_cmd *update; struct kdbus_item *n; assert(bus); assert(bus->is_kernel); - update = alloca0_align(offsetof(struct kdbus_cmd_update, items) + + update = alloca0_align(offsetof(struct kdbus_cmd, items) + ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)), 8); @@ -1789,10 +1724,10 @@ int bus_kernel_realize_attach_flags(sd_bus *bus) { n->data64[0] = bus->attach_flags; update->size = - offsetof(struct kdbus_cmd_update, items) + + offsetof(struct kdbus_cmd, items) + ALIGN8(n->size); - if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0) + if (ioctl(bus->input_fd, KDBUS_CMD_UPDATE, update) < 0) return -errno; return 0; @@ -1806,29 +1741,56 @@ int bus_kernel_fix_attach_mask(void) { /* By default we don't want any kdbus metadata fields to be * suppressed, hence we reset the kernel mask for it to - * (uint64_t) -1. This is overridable via a kernel command - * line option, however. */ + * (uint64_t) -1. If the module argument was overwritten by + * the kernel cmdline, we leave it as is. */ - r = get_proc_cmdline_key("systemd.kdbus_attach_flags_mask=", &mask); + r = get_proc_cmdline_key("kdbus.attach_flags_mask=", &mask); if (r < 0) return log_warning_errno(r, "Failed to read kernel command line: %m"); - if (mask) { - const char *p = mask; + if (r == 0) { + sprintf(buf, "0x%" PRIx64 "\n", m); + r = write_string_file("/sys/module/kdbus/parameters/attach_flags_mask", buf); + if (r < 0) + return log_full_errno(IN_SET(r, -ENOENT, -EROFS) ? LOG_DEBUG : LOG_WARNING, r, + "Failed to write kdbus attach mask: %m"); + } - if (startswith(p, "0x")) - p += 2; + return 0; +} - if (sscanf(p, "%" PRIx64, &m) != 1) - log_warning("Couldn't parse systemd.kdbus_attach_flags_mask= kernel command line parameter."); - } +int bus_kernel_get_bus_name(sd_bus *bus, char **name) { + struct kdbus_cmd_info cmd = { + .size = sizeof(struct kdbus_cmd_info), + }; + struct kdbus_info *info; + struct kdbus_item *item; + char *n = NULL; + int r; - sprintf(buf, "0x%" PRIx64 "\n", m); - r = write_string_file("/sys/module/kdbus/parameters/attach_flags_mask", buf); + assert(bus); + assert(name); + assert(bus->is_kernel); + + r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd); if (r < 0) - return log_full_errno( - r == -EROFS ? LOG_DEBUG : LOG_WARNING, r, - "Failed to write kdbus attach mask: %m"); + return -errno; + + info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset); + + KDBUS_ITEM_FOREACH(item, info, items) + if (item->type == KDBUS_ITEM_MAKE_NAME) { + r = free_and_strdup(&n, item->str); + break; + } + + bus_kernel_cmd_free(bus, cmd.offset); + + if (r < 0) + return r; + if (!n) + return -EIO; + *name = n; return 0; }