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=79d29dc119798b0da25e319fdf65a9dd3d207dae;hp=f49fb5b3944bf9faae6f9d42803fa829ecb78f2b;hb=705a415f684f8e9ee19983e5859de00bbb1477cb;hpb=a4152e3fe28b53b8919cc404dd7eca7ead1bf9bd diff --git a/src/libsystemd/sd-bus/bus-kernel.c b/src/libsystemd/sd-bus/bus-kernel.c index f49fb5b39..79d29dc11 100644 --- a/src/libsystemd/sd-bus/bus-kernel.c +++ b/src/libsystemd/sd-bus/bus-kernel.c @@ -25,11 +25,13 @@ #include #include +#include #include #include #include "util.h" #include "strv.h" +#include "memfd-util.h" #include "bus-internal.h" #include "bus-message.h" @@ -202,6 +204,7 @@ static int bus_message_setup_bloom(sd_bus_message *m, struct kdbus_bloom_filter static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) { struct bus_body_part *part; struct kdbus_item *d; + const char *destination; bool well_known; uint64_t unique; size_t sz, dl; @@ -217,8 +220,10 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) { if (m->kdbus) return 0; - if (m->destination) { - r = bus_kernel_parse_unique_name(m->destination, &unique); + destination = m->destination ?: m->destination_ptr; + + if (destination) { + r = bus_kernel_parse_unique_name(destination, &unique); if (r < 0) return r; @@ -242,7 +247,7 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) { /* Add in well-known destination header */ if (well_known) { - dl = strlen(m->destination); + dl = strlen(destination); sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1); } @@ -262,22 +267,35 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) { 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->kdbus->dst_id = - well_known ? 0 : - m->destination ? unique : KDBUS_DST_ID_BROADCAST; + + if (well_known) { + /* verify_destination_id will usually be 0, which makes the kernel driver only look + * at the provided well-known name. Otherwise, the kernel will make sure the provided + * destination id matches the owner of the provided weel-known-name, and fail if they + * differ. Currently, this is only needed for bus-proxyd. */ + m->kdbus->dst_id = m->verify_destination_id; + } else { + m->kdbus->dst_id = destination ? unique : KDBUS_DST_ID_BROADCAST; + } + m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS; m->kdbus->cookie = (uint64_t) m->header->serial; m->kdbus->priority = m->priority; - if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) + if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) { m->kdbus->cookie_reply = m->reply_cookie; - else - m->kdbus->timeout_ns = m->timeout * NSEC_PER_USEC; + } else { + struct timespec now; + + assert_se(clock_gettime(CLOCK_MONOTONIC_COARSE, &now) == 0); + m->kdbus->timeout_ns = now.tv_sec * NSEC_PER_SEC + now.tv_nsec + + m->timeout * NSEC_PER_USEC; + } d = m->kdbus->items; if (well_known) - append_destination(&d, m->destination, dl); + append_destination(&d, destination, dl); append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m)); @@ -292,7 +310,7 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) { continue; } - if (part->memfd >= 0 && part->sealed && m->destination) { + if (part->memfd >= 0 && part->sealed && destination) { /* Try to send a memfd, if the part is * sealed and this is not a broadcast. Since we can only */ @@ -331,6 +349,18 @@ fail: return r; } +static void unset_memfds(struct sd_bus_message *m) { + struct bus_body_part *part; + unsigned i; + + assert(m); + + /* Make sure the memfds are not freed twice */ + MESSAGE_FOREACH_PART(part, i, m) + if (part->memfd >= 0) + part->memfd = -1; +} + static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { sd_bus_message *m = NULL; struct kdbus_item *d; @@ -483,28 +513,75 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { break; } - case KDBUS_ITEM_CREDS: - /* UID/GID/PID are always valid */ - m->creds.uid = (uid_t) d->creds.uid; - m->creds.gid = (gid_t) d->creds.gid; - m->creds.pid = (pid_t) d->creds.pid; - m->creds.mask |= (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID) & bus->creds_mask; - - /* The PID starttime/TID might be missing - * however, 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->creds.starttime > 0) { - m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC; + 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. */ + + 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->creds.tid > 0) { - m->creds.tid = (pid_t) d->creds.tid; + if (d->pids.tid > 0) { + m->creds.tid = (pid_t) d->pids.tid; m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask; } + + break; + + case KDBUS_ITEM_CREDS: + + /* EUID/SUID/FSUID/EGID/SGID/FSGID might be missing too (see above). */ + + if ((uid_t) d->creds.uid != (uid_t) -1) { + 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) { + 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) { + 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) { + 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) { + 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) { + 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) { + 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) { + m->creds.fsgid = (gid_t) d->creds.fsgid; + m->creds.mask |= SD_BUS_CREDS_FSGID & bus->creds_mask; + } + break; case KDBUS_ITEM_TIMESTAMP: @@ -542,11 +619,9 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { m->creds.cgroup = d->str; m->creds.mask |= (SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID) & bus->creds_mask; - if (!bus->cgroup_root) { - r = cg_get_root_path(&bus->cgroup_root); - if (r < 0) - goto fail; - } + r = bus_get_root_path(bus); + if (r < 0) + goto fail; m->creds.cgroup_root = bus->cgroup_root; @@ -559,8 +634,8 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { break; case KDBUS_ITEM_CAPS: - m->creds.capability = d->data; - m->creds.capability_size = l; + m->creds.capability = (uint8_t *) d->caps.caps; + m->creds.capability_size = d->size - offsetof(struct kdbus_item, 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; @@ -571,7 +646,7 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { destination = d->str; break; - case KDBUS_ITEM_NAME: + case KDBUS_ITEM_OWNED_NAME: if (!service_name_is_valid(d->name.name)) return -EBADMSG; @@ -580,9 +655,9 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { goto fail; break; - case KDBUS_ITEM_CONN_NAME: - m->creds.conn_name = d->str; - m->creds.mask |= SD_BUS_CREDS_CONNECTION_NAME & bus->creds_mask; + case KDBUS_ITEM_CONN_DESCRIPTION: + m->creds.description = d->str; + m->creds.mask |= SD_BUS_CREDS_DESCRIPTION & bus->creds_mask; break; case KDBUS_ITEM_FDS: @@ -628,17 +703,8 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) { return 1; fail: - if (m) { - struct bus_body_part *part; - unsigned i; - - /* Make sure the memfds are not freed twice */ - MESSAGE_FOREACH_PART(part, i, m) - if (part->memfd >= 0) - part->memfd = -1; - - sd_bus_message_unref(m); - } + unset_memfds(m); + sd_bus_message_unref(m); return r; } @@ -658,8 +724,8 @@ int bus_kernel_take_fd(sd_bus *b) { b->use_memfd = 1; - if (b->connection_name) { - g = bus_label_escape(b->connection_name); + if (b->description) { + g = bus_label_escape(b->description); if (!g) return -ENOMEM; @@ -692,8 +758,8 @@ int bus_kernel_take_fd(sd_bus *b) { name = g; } - b->connection_name = bus_label_unescape(name); - if (!b->connection_name) + b->description = bus_label_unescape(name); + if (!b->description) return -ENOMEM; } @@ -705,21 +771,25 @@ int bus_kernel_take_fd(sd_bus *b) { if (b->fake_creds_valid) sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds)); + if (b->fake_pids_valid) + sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids)); + if (b->fake_label) { l = strlen(b->fake_label); sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1); } - hello = alloca0(sz); + hello = alloca0_align(sz, 8); hello->size = sz; - hello->conn_flags = b->hello_flags; - hello->attach_flags = b->attach_flags; + hello->flags = b->hello_flags; + hello->attach_flags_send = _KDBUS_ATTACH_ANY; + hello->attach_flags_recv = b->attach_flags; hello->pool_size = KDBUS_POOL_SIZE; item = hello->items; item->size = offsetof(struct kdbus_item, str) + m + 1; - item->type = KDBUS_ITEM_CONN_NAME; + item->type = KDBUS_ITEM_CONN_DESCRIPTION; memcpy(item->str, name, m + 1); item = KDBUS_ITEM_NEXT(item); @@ -731,6 +801,14 @@ int bus_kernel_take_fd(sd_bus *b) { item = KDBUS_ITEM_NEXT(item); } + if (b->fake_pids_valid) { + item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids); + item->type = KDBUS_ITEM_PIDS; + item->pids = b->fake_pids; + + item = KDBUS_ITEM_NEXT(item); + } + if (b->fake_label) { item->size = offsetof(struct kdbus_item, str) + l + 1; item->type = KDBUS_ITEM_SECLABEL; @@ -749,10 +827,9 @@ int bus_kernel_take_fd(sd_bus *b) { } } - /* The higher 32bit of both flags fields are considered + /* The higher 32bit of the bus_flags fields are considered * 'incompatible flags'. Refuse them all for now. */ - if (hello->bus_flags > 0xFFFFFFFFULL || - hello->conn_flags > 0xFFFFFFFFULL) + if (hello->bus_flags > 0xFFFFFFFFULL) return -ENOTSUP; if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash)) @@ -768,7 +845,7 @@ int bus_kernel_take_fd(sd_bus *b) { b->is_kernel = true; b->bus_client = true; - b->can_fds = !!(hello->conn_flags & KDBUS_HELLO_ACCEPT_FD); + b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD); b->message_version = 2; b->message_endian = BUS_NATIVE_ENDIAN; @@ -797,14 +874,14 @@ int bus_kernel_connect(sd_bus *b) { } static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) { - uint64_t off; + struct kdbus_cmd_free cmd; struct kdbus_item *d; assert(bus); assert(k); - off = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer; - ioctl(bus->input_fd, KDBUS_CMD_FREE, &off); + cmd.flags = 0; + cmd.offset = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer; KDBUS_ITEM_FOREACH(d, k, items) { @@ -813,6 +890,8 @@ static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) { else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD) safe_close(d->memfd.fd); } + + (void) ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd); } int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) { @@ -951,19 +1030,19 @@ static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_ assert(k); assert(d); - if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) + if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) old_owner[0] = 0; else - sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old.id); + sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id); - if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) { + if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) { if (isempty(old_owner)) return 0; new_owner[0] = 0; } else - sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new.id); + 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); } @@ -1110,40 +1189,18 @@ int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *al assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0); if (bus->n_memfd_cache <= 0) { - _cleanup_free_ char *g = NULL; - struct kdbus_cmd_memfd_make *cmd; - struct kdbus_item *item; - size_t l, sz; int r; assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0); - assert(bus->connection_name); - - g = bus_label_escape(bus->connection_name); - if (!g) - return -ENOMEM; - - l = strlen(g); - sz = ALIGN8(offsetof(struct kdbus_cmd_memfd_make, items)) + - ALIGN8(offsetof(struct kdbus_item, str)) + - l + 1; - cmd = alloca0(sz); - cmd->size = sz; - - item = cmd->items; - item->size = ALIGN8(offsetof(struct kdbus_item, str)) + l + 1; - item->type = KDBUS_ITEM_MEMFD_NAME; - memcpy(item->str, g, l + 1); - - r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, cmd); + r = memfd_new(bus->description); if (r < 0) - return -errno; + return r; *address = NULL; *mapped = 0; *allocated = 0; - return cmd->fd; + return r; } c = &bus->memfd_cache[--bus->n_memfd_cache]; @@ -1195,7 +1252,7 @@ void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, si /* If overly long, let's return a bit to the OS */ if (mapped > max_mapped) { - assert_se(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &max_mapped) >= 0); + assert_se(memfd_set_size(fd, max_mapped) >= 0); assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0); c->mapped = c->allocated = max_mapped; } else { @@ -1238,11 +1295,18 @@ int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) { assert(kdbus_mask); - if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID)) + if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID| + 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_COMM|SD_BUS_CREDS_TID_COMM)) - m |= KDBUS_ATTACH_COMM; + if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID)) + m |= KDBUS_ATTACH_PIDS; + + if (mask & SD_BUS_CREDS_COMM) + m |= KDBUS_ATTACH_PID_COMM; + + if (mask & SD_BUS_CREDS_TID_COMM) + m |= KDBUS_ATTACH_TID_COMM; if (mask & SD_BUS_CREDS_EXE) m |= KDBUS_ATTACH_EXE; @@ -1265,8 +1329,8 @@ int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) { if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) m |= KDBUS_ATTACH_NAMES; - if (mask & SD_BUS_CREDS_CONNECTION_NAME) - m |= KDBUS_ATTACH_CONN_NAME; + if (mask & SD_BUS_CREDS_DESCRIPTION) + m |= KDBUS_ATTACH_CONN_DESCRIPTION; *kdbus_mask = m; return 0; @@ -1280,14 +1344,15 @@ int bus_kernel_create_bus(const char *name, bool world, char **s) { assert(name); assert(s); - fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC); + fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC); if (fd < 0) return -errno; - make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) + - offsetof(struct kdbus_item, data64) + sizeof(uint64_t) + - offsetof(struct kdbus_item, str) + - DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1)); + make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items) + + offsetof(struct kdbus_item, data64) + sizeof(uint64_t) + + offsetof(struct kdbus_item, str) + + DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1), + 8); make->size = offsetof(struct kdbus_cmd_make, items); @@ -1317,17 +1382,10 @@ int bus_kernel_create_bus(const char *name, bool world, char **s) { return -errno; } - /* The higher 32bit of the flags field are considered - * 'incompatible flags'. Refuse them all for now. */ - if (make->flags > 0xFFFFFFFFULL) { - safe_close(fd); - return -ENOTSUP; - } - if (s) { char *p; - p = strjoin("/dev/kdbus/", n->str, "/bus", NULL); + p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL); if (!p) { safe_close(fd); return -ENOMEM; @@ -1339,19 +1397,19 @@ int bus_kernel_create_bus(const char *name, bool world, char **s) { return fd; } -static int bus_kernel_translate_access(BusNamePolicyAccess access) { +static int bus_kernel_translate_access(BusPolicyAccess access) { assert(access >= 0); - assert(access < _BUSNAME_POLICY_ACCESS_MAX); + assert(access < _BUS_POLICY_ACCESS_MAX); switch (access) { - case BUSNAME_POLICY_ACCESS_SEE: + case BUS_POLICY_ACCESS_SEE: return KDBUS_POLICY_SEE; - case BUSNAME_POLICY_ACCESS_TALK: + case BUS_POLICY_ACCESS_TALK: return KDBUS_POLICY_TALK; - case BUSNAME_POLICY_ACCESS_OWN: + case BUS_POLICY_ACCESS_OWN: return KDBUS_POLICY_OWN; default: @@ -1402,12 +1460,21 @@ static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus return 0; } -int bus_kernel_open_bus_fd(const char *bus) { +int bus_kernel_open_bus_fd(const char *bus, char **path) { char *p; int fd; + size_t len; - p = alloca(strlen("/dev/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1); - sprintf(p, "/dev/kdbus/" UID_FMT "-%s/bus", getuid(), bus); + len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1; + + if (path) { + p = malloc(len); + if (!p) + return -ENOMEM; + *path = p; + } else + p = alloca(len); + sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus); fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC); if (fd < 0) @@ -1416,13 +1483,101 @@ int bus_kernel_open_bus_fd(const char *bus) { return fd; } +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_item *n; + size_t size; + int fd; + + fd = bus_kernel_open_bus_fd(bus_name, &path); + if (fd < 0) + return fd; + + size = ALIGN8(offsetof(struct kdbus_cmd_make, items)); + size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(ep_name) + 1); + + make = alloca0_align(size, 8); + make->size = size; + make->flags = KDBUS_MAKE_ACCESS_WORLD; + + n = make->items; + + n->type = KDBUS_ITEM_MAKE_NAME; + n->size = offsetof(struct kdbus_item, str) + strlen(ep_name) + 1; + strcpy(n->str, ep_name); + + if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) { + safe_close(fd); + return -errno; + } + + if (ep_path) { + char *p; + + p = strjoin(dirname(path), "/", ep_name, NULL); + if (!p) { + safe_close(fd); + return -ENOMEM; + } + + *ep_path = p; + } + + 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, - BusNamePolicyAccess world_policy) { + BusPolicyAccess world_policy) { struct kdbus_cmd_hello *hello; struct kdbus_item *n; @@ -1444,7 +1599,7 @@ int bus_kernel_make_starter( 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(size); + hello = alloca0_align(size, 8); n = hello->items; strcpy(n->str, name); @@ -1471,19 +1626,19 @@ int bus_kernel_make_starter( } hello->size = size; - hello->conn_flags = + 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 = _KDBUS_ATTACH_ALL; + hello->attach_flags_send = _KDBUS_ATTACH_ANY; + hello->attach_flags_recv = _KDBUS_ATTACH_ALL; if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) return -errno; - /* The higher 32bit of both flags fields are considered + /* The higher 32bit of the bus_flags fields are considered * 'incompatible flags'. Refuse them all for now. */ - if (hello->bus_flags > 0xFFFFFFFFULL || - hello->conn_flags > 0xFFFFFFFFULL) + if (hello->bus_flags > 0xFFFFFFFFULL) return -ENOTSUP; if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash)) @@ -1492,88 +1647,6 @@ int bus_kernel_make_starter( return fd; } -int bus_kernel_create_domain(const char *name, char **s) { - struct kdbus_cmd_make *make; - struct kdbus_item *n; - int fd; - - assert(name); - assert(s); - - fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC); - if (fd < 0) - return -errno; - - make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) + - offsetof(struct kdbus_item, str) + - strlen(name) + 1)); - - n = make->items; - strcpy(n->str, name); - n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1; - n->type = KDBUS_ITEM_MAKE_NAME; - - make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size); - make->flags = KDBUS_MAKE_ACCESS_WORLD; - - if (ioctl(fd, KDBUS_CMD_DOMAIN_MAKE, make) < 0) { - safe_close(fd); - return -errno; - } - - /* The higher 32bit of the flags field are considered - * 'incompatible flags'. Refuse them all for now. */ - if (make->flags > 0xFFFFFFFFULL) { - safe_close(fd); - return -ENOTSUP; - } - - if (s) { - char *p; - - p = strappend("/dev/kdbus/domain/", name); - if (!p) { - safe_close(fd); - return -ENOMEM; - } - - *s = p; - } - - return fd; -} - -int bus_kernel_create_monitor(const char *bus) { - struct kdbus_cmd_hello *hello; - int fd; - - assert(bus); - - fd = bus_kernel_open_bus_fd(bus); - if (fd < 0) - return fd; - - hello = alloca0(sizeof(struct kdbus_cmd_hello)); - hello->size = sizeof(struct kdbus_cmd_hello); - hello->conn_flags = KDBUS_HELLO_ACTIVATOR; - hello->pool_size = KDBUS_POOL_SIZE; - - if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) { - safe_close(fd); - return -errno; - } - - /* The higher 32bit of both flags fields are considered - * 'incompatible flags'. Refuse them all for now. */ - if (hello->bus_flags > 0xFFFFFFFFULL || - hello->conn_flags > 0xFFFFFFFFULL) { - safe_close(fd); - return -ENOTSUP; - } - - return fd; -} - int bus_kernel_try_close(sd_bus *bus) { assert(bus); assert(bus->is_kernel);