1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #ifdef HAVE_VALGRIND_MEMCHECK_H
23 #include <valgrind/memcheck.h>
30 #include <sys/prctl.h>
34 #include "memfd-util.h"
35 #include "cgroup-util.h"
38 #include "bus-internal.h"
39 #include "bus-message.h"
40 #include "bus-kernel.h"
41 #include "bus-bloom.h"
43 #include "bus-label.h"
45 #define UNIQUE_NAME_MAX (3+DECIMAL_STR_MAX(uint64_t))
47 int bus_kernel_parse_unique_name(const char *s, uint64_t *id) {
53 if (!startswith(s, ":1."))
56 r = safe_atou64(s + 3, id);
63 static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) {
69 /* Note that p can be NULL, which encodes a region full of
70 * zeroes, which is useful to optimize certain padding
73 (*d)->size = offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec);
74 (*d)->type = KDBUS_ITEM_PAYLOAD_VEC;
75 (*d)->vec.address = PTR_TO_UINT64(p);
78 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
81 static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t sz) {
87 (*d)->size = offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd);
88 (*d)->type = KDBUS_ITEM_PAYLOAD_MEMFD;
89 (*d)->memfd.fd = memfd;
90 (*d)->memfd.size = sz;
92 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
95 static void append_destination(struct kdbus_item **d, const char *s, size_t length) {
101 (*d)->size = offsetof(struct kdbus_item, str) + length + 1;
102 (*d)->type = KDBUS_ITEM_DST_NAME;
103 memcpy((*d)->str, s, length + 1);
105 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
108 static struct kdbus_bloom_filter *append_bloom(struct kdbus_item **d, size_t length) {
109 struct kdbus_item *i;
115 i->size = offsetof(struct kdbus_item, bloom_filter) +
116 offsetof(struct kdbus_bloom_filter, data) +
118 i->type = KDBUS_ITEM_BLOOM_FILTER;
120 *d = (struct kdbus_item *) ((uint8_t*) i + i->size);
122 return &i->bloom_filter;
125 static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) {
131 (*d)->size = offsetof(struct kdbus_item, fds) + sizeof(int) * n_fds;
132 (*d)->type = KDBUS_ITEM_FDS;
133 memcpy((*d)->fds, fds, sizeof(int) * n_fds);
135 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
138 static void add_bloom_arg(void *data, size_t size, unsigned n_hash, unsigned i, const char *t) {
139 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
147 e = stpcpy(buf, "arg");
149 *(e++) = '0' + (char) i;
151 *(e++) = '0' + (char) (i / 10);
152 *(e++) = '0' + (char) (i % 10);
156 bloom_add_pair(data, size, n_hash, buf, t);
158 strcpy(e, "-dot-prefix");
159 bloom_add_prefixes(data, size, n_hash, buf, t, '.');
160 strcpy(e, "-slash-prefix");
161 bloom_add_prefixes(data, size, n_hash, buf, t, '/');
164 static int bus_message_setup_bloom(sd_bus_message *m, struct kdbus_bloom_filter *bloom) {
173 memzero(data, m->bus->bloom_size);
174 bloom->generation = 0;
176 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "message-type", bus_message_type_to_string(m->header->type));
179 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "interface", m->interface);
181 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "member", m->member);
183 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path", m->path);
184 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path);
185 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path, '/');
188 r = sd_bus_message_rewind(m, true);
192 for (i = 0; i < 64; i++) {
193 const char *t, *contents;
196 r = sd_bus_message_peek_type(m, &type, &contents);
200 if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE)) {
202 /* The bloom filter includes simple strings of any kind */
203 r = sd_bus_message_read_basic(m, type, &t);
207 add_bloom_arg(data, m->bus->bloom_size, m->bus->bloom_n_hash, i, t);
208 } if (type == SD_BUS_TYPE_ARRAY && STR_IN_SET(contents, "s", "o", "g")) {
210 /* As well as array of simple strings of any kinds */
211 r = sd_bus_message_enter_container(m, type, contents);
215 while ((r = sd_bus_message_read_basic(m, contents[0], &t)) > 0)
216 add_bloom_arg(data, m->bus->bloom_size, m->bus->bloom_n_hash, i, t);
220 r = sd_bus_message_exit_container(m);
225 /* Stop adding to bloom filter as soon as we
226 * run into the first argument we cannot add
234 static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
235 struct bus_body_part *part;
236 struct kdbus_item *d;
237 const char *destination;
248 /* We put this together only once, if this message is reused
249 * we reuse the earlier-built version */
253 destination = m->destination ?: m->destination_ptr;
256 r = bus_kernel_parse_unique_name(destination, &unique);
264 sz = offsetof(struct kdbus_msg, items);
266 assert_cc(ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec)) ==
267 ALIGN8(offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd)));
269 /* Add in fixed header, fields header and payload */
270 sz += (1 + m->n_body_parts) *
271 ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec));
273 /* Add space for bloom filter */
274 sz += ALIGN8(offsetof(struct kdbus_item, bloom_filter) +
275 offsetof(struct kdbus_bloom_filter, data) +
278 /* Add in well-known destination header */
280 dl = strlen(destination);
281 sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1);
284 /* Add space for unix fds */
286 sz += ALIGN8(offsetof(struct kdbus_item, fds) + sizeof(int)*m->n_fds);
288 m->kdbus = memalign(8, sz);
294 m->free_kdbus = true;
295 memzero(m->kdbus, sz);
298 ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) |
299 ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0);
302 /* verify_destination_id will usually be 0, which makes the kernel driver only look
303 * at the provided well-known name. Otherwise, the kernel will make sure the provided
304 * destination id matches the owner of the provided weel-known-name, and fail if they
305 * differ. Currently, this is only needed for bus-proxyd. */
306 m->kdbus->dst_id = m->verify_destination_id;
308 m->kdbus->dst_id = destination ? unique : KDBUS_DST_ID_BROADCAST;
310 m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
311 m->kdbus->cookie = (uint64_t) m->header->serial;
312 m->kdbus->priority = m->priority;
314 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
315 m->kdbus->cookie_reply = m->reply_cookie;
319 assert_se(clock_gettime(CLOCK_MONOTONIC_COARSE, &now) == 0);
320 m->kdbus->timeout_ns = now.tv_sec * NSEC_PER_SEC + now.tv_nsec +
321 m->timeout * NSEC_PER_USEC;
327 append_destination(&d, destination, dl);
329 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
331 MESSAGE_FOREACH_PART(part, i, m) {
333 /* If this is padding then simply send a
334 * vector with a NULL data pointer which the
335 * kernel will just pass through. This is the
336 * most efficient way to encode zeroes */
338 append_payload_vec(&d, NULL, part->size);
342 if (part->memfd >= 0 && part->sealed && destination) {
343 /* Try to send a memfd, if the part is
344 * sealed and this is not a broadcast. Since we can only */
346 append_payload_memfd(&d, part->memfd, part->size);
350 /* Otherwise, let's send a vector to the actual data.
351 * For that, we need to map it first. */
352 r = bus_body_part_map(part);
356 append_payload_vec(&d, part->data, part->size);
359 if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
360 struct kdbus_bloom_filter *bloom;
362 bloom = append_bloom(&d, m->bus->bloom_size);
363 r = bus_message_setup_bloom(m, bloom);
369 append_fds(&d, m->fds, m->n_fds);
371 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
372 assert(m->kdbus->size <= sz);
381 static void bus_message_set_sender_driver(sd_bus *bus, sd_bus_message *m) {
385 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
386 m->creds.well_known_names_driver = true;
387 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
390 static void unset_memfds(struct sd_bus_message *m) {
391 struct bus_body_part *part;
396 /* Make sure the memfds are not freed twice */
397 MESSAGE_FOREACH_PART(part, i, m)
398 if (part->memfd >= 0)
402 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
403 sd_bus_message *m = NULL;
404 struct kdbus_item *d;
406 _cleanup_free_ int *fds = NULL;
407 struct bus_header *h = NULL;
408 size_t total, n_bytes = 0, idx = 0;
409 const char *destination = NULL, *seclabel = NULL;
414 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
416 KDBUS_ITEM_FOREACH(d, k, items) {
419 l = d->size - offsetof(struct kdbus_item, data);
423 case KDBUS_ITEM_PAYLOAD_OFF:
425 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
427 if (!bus_header_is_complete(h, d->vec.size))
431 n_bytes += d->vec.size;
434 case KDBUS_ITEM_PAYLOAD_MEMFD:
438 n_bytes += d->memfd.size;
441 case KDBUS_ITEM_FDS: {
446 f = realloc(fds, sizeof(int) * (n_fds + j));
451 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
456 case KDBUS_ITEM_SECLABEL:
465 r = bus_header_message_size(h, &total);
469 if (n_bytes != total)
472 /* on kdbus we only speak native endian gvariant, never dbus1
473 * marshalling or reverse endian */
474 if (h->version != 2 ||
475 h->endian != BUS_NATIVE_ENDIAN)
478 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
482 /* The well-known names list is different from the other
483 credentials. If we asked for it, but nothing is there, this
484 means that the list of well-known names is simply empty, not
485 that we lack any data */
487 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
489 KDBUS_ITEM_FOREACH(d, k, items) {
492 l = d->size - offsetof(struct kdbus_item, data);
496 case KDBUS_ITEM_PAYLOAD_OFF: {
499 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
501 if (idx + d->vec.size > begin_body) {
502 struct bus_body_part *part;
504 /* Contains body material */
506 part = message_append_part(m);
512 /* A -1 offset is NUL padding. */
513 part->is_zero = d->vec.offset == ~0ULL;
515 if (idx >= begin_body) {
517 part->data = (uint8_t *)k + d->vec.offset;
518 part->size = d->vec.size;
521 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
522 part->size = d->vec.size - (begin_body - idx);
532 case KDBUS_ITEM_PAYLOAD_MEMFD: {
533 struct bus_body_part *part;
535 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
540 part = message_append_part(m);
546 part->memfd = d->memfd.fd;
547 part->size = d->memfd.size;
550 idx += d->memfd.size;
554 case KDBUS_ITEM_PIDS:
556 /* The PID starttime/TID might be missing,
557 * when the data is faked by some data bus
558 * proxy and it lacks that information about
559 * the real client since SO_PEERCRED is used
562 if (d->pids.pid > 0) {
563 m->creds.pid = (pid_t) d->pids.pid;
564 m->creds.mask |= SD_BUS_CREDS_PID & bus->creds_mask;
567 if (d->pids.starttime > 0) {
568 m->creds.pid_starttime = d->pids.starttime / NSEC_PER_USEC;
569 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
572 if (d->pids.tid > 0) {
573 m->creds.tid = (pid_t) d->pids.tid;
574 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
579 case KDBUS_ITEM_CREDS:
581 /* EUID/SUID/FSUID/EGID/SGID/FSGID might be missing too (see above). */
583 if ((uid_t) d->creds.uid != (uid_t) -1) {
584 m->creds.uid = (uid_t) d->creds.uid;
585 m->creds.mask |= SD_BUS_CREDS_UID & bus->creds_mask;
588 if ((uid_t) d->creds.euid != (uid_t) -1) {
589 m->creds.euid = (uid_t) d->creds.euid;
590 m->creds.mask |= SD_BUS_CREDS_EUID & bus->creds_mask;
593 if ((uid_t) d->creds.suid != (uid_t) -1) {
594 m->creds.suid = (uid_t) d->creds.suid;
595 m->creds.mask |= SD_BUS_CREDS_SUID & bus->creds_mask;
598 if ((uid_t) d->creds.fsuid != (uid_t) -1) {
599 m->creds.fsuid = (uid_t) d->creds.fsuid;
600 m->creds.mask |= SD_BUS_CREDS_FSUID & bus->creds_mask;
603 if ((gid_t) d->creds.gid != (gid_t) -1) {
604 m->creds.gid = (gid_t) d->creds.gid;
605 m->creds.mask |= SD_BUS_CREDS_GID & bus->creds_mask;
608 if ((gid_t) d->creds.egid != (gid_t) -1) {
609 m->creds.egid = (gid_t) d->creds.egid;
610 m->creds.mask |= SD_BUS_CREDS_EGID & bus->creds_mask;
613 if ((gid_t) d->creds.sgid != (gid_t) -1) {
614 m->creds.sgid = (gid_t) d->creds.sgid;
615 m->creds.mask |= SD_BUS_CREDS_SGID & bus->creds_mask;
618 if ((gid_t) d->creds.fsgid != (gid_t) -1) {
619 m->creds.fsgid = (gid_t) d->creds.fsgid;
620 m->creds.mask |= SD_BUS_CREDS_FSGID & bus->creds_mask;
625 case KDBUS_ITEM_TIMESTAMP:
627 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
628 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
629 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
630 m->seqnum = d->timestamp.seqnum;
635 case KDBUS_ITEM_PID_COMM:
636 m->creds.comm = d->str;
637 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
640 case KDBUS_ITEM_TID_COMM:
641 m->creds.tid_comm = d->str;
642 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
646 m->creds.exe = d->str;
647 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
650 case KDBUS_ITEM_CMDLINE:
651 m->creds.cmdline = d->str;
652 m->creds.cmdline_size = l;
653 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
656 case KDBUS_ITEM_CGROUP:
657 m->creds.cgroup = d->str;
658 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;
660 r = bus_get_root_path(bus);
664 m->creds.cgroup_root = bus->cgroup_root;
668 case KDBUS_ITEM_AUDIT:
669 if ((uint32_t) d->audit.sessionid != (uint32_t) -1) {
670 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
671 m->creds.mask |= SD_BUS_CREDS_AUDIT_SESSION_ID & bus->creds_mask;
674 if ((uid_t) d->audit.loginuid != (uid_t) -1) {
675 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
676 m->creds.mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID & bus->creds_mask;
680 case KDBUS_ITEM_CAPS:
681 m->creds.capability = (uint8_t *) d->caps.caps;
682 m->creds.capability_size = d->size - offsetof(struct kdbus_item, caps.caps);
683 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;
686 case KDBUS_ITEM_DST_NAME:
687 if (!service_name_is_valid(d->str)) {
692 destination = d->str;
695 case KDBUS_ITEM_OWNED_NAME:
696 if (!service_name_is_valid(d->name.name)) {
701 if (bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) {
705 /* We just extend the array here, but
706 * do not allocate the strings inside
707 * of it, instead we just point to our
708 * buffer directly. */
709 n = strv_length(m->creds.well_known_names);
710 wkn = realloc(m->creds.well_known_names, (n + 2) * sizeof(char*));
716 wkn[n] = d->name.name;
718 m->creds.well_known_names = wkn;
720 m->creds.mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES;
724 case KDBUS_ITEM_CONN_DESCRIPTION:
725 m->creds.description = d->str;
726 m->creds.mask |= SD_BUS_CREDS_DESCRIPTION & bus->creds_mask;
729 case KDBUS_ITEM_AUXGROUPS:
731 if (bus->creds_mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS) {
732 assert_cc(sizeof(gid_t) == sizeof(uint32_t));
734 m->creds.n_supplementary_gids = (d->size - offsetof(struct kdbus_item, data32)) / sizeof(uint32_t);
735 m->creds.supplementary_gids = (gid_t*) d->data32;
736 m->creds.mask |= SD_BUS_CREDS_SUPPLEMENTARY_GIDS;
742 case KDBUS_ITEM_SECLABEL:
746 log_debug("Got unknown field from kernel %llu", d->type);
750 /* If we requested the list of well-known names to be appended
751 * and the sender had none no item for it will be
752 * attached. However, this does *not* mean that we the kernel
753 * didn't want to provide this information to us. Hence, let's
754 * explicitly mark this information as available if it was
756 m->creds.mask |= bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES;
758 r = bus_message_parse_fields(m);
762 /* Refuse messages if kdbus and dbus1 cookie doesn't match up */
763 if ((uint64_t) m->header->serial != k->cookie) {
768 /* Refuse messages where the reply flag doesn't match up */
769 if (!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) != !!(k->flags & KDBUS_MSG_FLAGS_EXPECT_REPLY)) {
774 /* Refuse reply messages where the reply cookie doesn't match up */
775 if ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) && m->reply_cookie != k->cookie_reply) {
780 /* Refuse messages where the autostart flag doesn't match up */
781 if (!(m->header->flags & BUS_MESSAGE_NO_AUTO_START) != !(k->flags & KDBUS_MSG_FLAGS_NO_AUTO_START)) {
786 /* Override information from the user header with data from the kernel */
787 if (k->src_id == KDBUS_SRC_ID_KERNEL)
788 bus_message_set_sender_driver(bus, m);
790 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
791 m->sender = m->creds.unique_name = m->sender_buffer;
795 m->destination = destination;
796 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
797 m->destination = NULL;
798 else if (k->dst_id == KDBUS_DST_ID_NAME)
799 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
801 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
802 m->destination = m->destination_buffer;
805 /* We take possession of the kmsg struct now */
807 m->release_kdbus = true;
811 bus->rqueue[bus->rqueue_size++] = m;
817 sd_bus_message_unref(m);
822 int bus_kernel_take_fd(sd_bus *b) {
823 struct kdbus_cmd_hello *hello;
824 struct kdbus_item *item;
825 _cleanup_free_ char *g = NULL;
827 size_t l = 0, m = 0, sz;
837 if (b->description) {
838 g = bus_label_escape(b->description);
846 /* If no name is explicitly set, we'll include a hint
847 * indicating the library implementation, a hint which
848 * kind of bus this is and the thread name */
850 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
853 name = b->is_system ? "sd-system" :
854 b->is_user ? "sd-user" : "sd";
856 _cleanup_free_ char *e = NULL;
858 e = bus_label_escape(pr);
862 g = strappend(b->is_system ? "sd-system-" :
863 b->is_user ? "sd-user-" : "sd-",
871 b->description = bus_label_unescape(name);
878 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
879 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
881 if (b->fake_creds_valid)
882 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
884 if (b->fake_pids_valid)
885 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
888 l = strlen(b->fake_label);
889 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
892 hello = alloca0_align(sz, 8);
894 hello->flags = b->hello_flags;
895 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
896 hello->attach_flags_recv = b->attach_flags;
897 hello->pool_size = KDBUS_POOL_SIZE;
901 item->size = offsetof(struct kdbus_item, str) + m + 1;
902 item->type = KDBUS_ITEM_CONN_DESCRIPTION;
903 memcpy(item->str, name, m + 1);
904 item = KDBUS_ITEM_NEXT(item);
906 if (b->fake_creds_valid) {
907 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
908 item->type = KDBUS_ITEM_CREDS;
909 item->creds = b->fake_creds;
911 item = KDBUS_ITEM_NEXT(item);
914 if (b->fake_pids_valid) {
915 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
916 item->type = KDBUS_ITEM_PIDS;
917 item->pids = b->fake_pids;
919 item = KDBUS_ITEM_NEXT(item);
923 item->size = offsetof(struct kdbus_item, str) + l + 1;
924 item->type = KDBUS_ITEM_SECLABEL;
925 memcpy(item->str, b->fake_label, l+1);
928 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
932 if (!b->kdbus_buffer) {
933 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
934 if (b->kdbus_buffer == MAP_FAILED) {
935 b->kdbus_buffer = NULL;
940 /* The higher 32bit of the bus_flags fields are considered
941 * 'incompatible flags'. Refuse them all for now. */
942 if (hello->bus_flags > 0xFFFFFFFFULL)
945 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
948 b->bloom_size = (size_t) hello->bloom.size;
949 b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
951 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
954 b->unique_id = hello->id;
957 b->bus_client = true;
958 b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
959 b->message_version = 2;
960 b->message_endian = BUS_NATIVE_ENDIAN;
962 /* the kernel told us the UUID of the underlying bus */
963 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
965 return bus_start_running(b);
968 int bus_kernel_connect(sd_bus *b) {
970 assert(b->input_fd < 0);
971 assert(b->output_fd < 0);
977 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
981 b->output_fd = b->input_fd;
983 return bus_kernel_take_fd(b);
986 int bus_kernel_cmd_free(sd_bus *bus, uint64_t offset) {
987 struct kdbus_cmd_free cmd = {
994 assert(bus->is_kernel);
996 r = ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
1003 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
1004 struct kdbus_item *d;
1009 KDBUS_ITEM_FOREACH(d, k, items) {
1010 if (d->type == KDBUS_ITEM_FDS)
1011 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
1012 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
1013 safe_close(d->memfd.fd);
1016 bus_kernel_cmd_free(bus, (uint8_t*) k - (uint8_t*) bus->kdbus_buffer);
1019 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
1024 assert(bus->state == BUS_RUNNING);
1026 /* If we can't deliver, we want room for the error message */
1027 r = bus_rqueue_make_room(bus);
1031 r = bus_message_setup_kmsg(bus, m);
1035 /* If this is a synchronous method call, then let's tell the
1036 * kernel, so that it can pass CPU time/scheduling to the
1037 * destination for the time, if it wants to. If we
1038 * synchronously wait for the result anyway, we won't need CPU
1041 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
1043 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
1045 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1046 sd_bus_message *reply;
1048 if (errno == EAGAIN || errno == EINTR)
1050 else if (errno == ENXIO || errno == ESRCH) {
1052 /* ENXIO: unique name not known
1053 * ESRCH: well-known name not known */
1055 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1056 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
1058 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
1062 } else if (errno == EADDRNOTAVAIL) {
1064 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
1066 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1067 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
1069 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
1075 r = bus_message_new_synthetic_error(
1077 BUS_MESSAGE_COOKIE(m),
1084 r = bus_seal_synthetic_message(bus, reply);
1088 bus->rqueue[bus->rqueue_size++] = reply;
1090 } else if (hint_sync_call) {
1091 struct kdbus_msg *k;
1093 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
1096 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1098 r = bus_kernel_make_message(bus, k);
1100 close_kdbus_msg(bus, k);
1102 /* Anybody can send us invalid messages, let's just drop them. */
1103 if (r == -EBADMSG || r == -EPROTOTYPE)
1104 log_debug_errno(r, "Ignoring invalid message: %m");
1109 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1110 close_kdbus_msg(bus, k);
1117 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
1118 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1123 r = sd_bus_message_new_signal(
1126 "/org/freedesktop/DBus",
1127 "org.freedesktop.DBus",
1128 "NameOwnerChanged");
1132 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1136 bus_message_set_sender_driver(bus, m);
1138 r = bus_seal_synthetic_message(bus, m);
1142 bus->rqueue[bus->rqueue_size++] = m;
1148 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1149 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1155 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1158 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1160 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1162 if (isempty(old_owner))
1167 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1169 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
1172 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1173 char owner[UNIQUE_NAME_MAX];
1179 sprintf(owner, ":1.%llu", d->id_change.id);
1181 return push_name_owner_changed(
1183 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1184 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
1187 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1188 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1195 r = bus_message_new_synthetic_error(
1198 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1199 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1200 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1205 bus_message_set_sender_driver(bus, m);
1207 r = bus_seal_synthetic_message(bus, m);
1211 bus->rqueue[bus->rqueue_size++] = m;
1217 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1218 struct kdbus_item *d, *found = NULL;
1220 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1221 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1222 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1223 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1225 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1226 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1228 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1229 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1234 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1236 KDBUS_ITEM_FOREACH(d, k, items) {
1237 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1242 log_debug("Got unknown field from kernel %llu", d->type);
1246 log_debug("Didn't find a kernel message to translate.");
1250 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1253 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1254 struct kdbus_cmd_recv recv = {};
1255 struct kdbus_msg *k;
1260 r = bus_rqueue_make_room(bus);
1264 if (hint_priority) {
1265 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1266 recv.priority = priority;
1269 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1271 if (errno == EAGAIN)
1274 if (errno == EOVERFLOW) {
1275 log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1282 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1283 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1284 r = bus_kernel_make_message(bus, k);
1286 /* Anybody can send us invalid messages, let's just drop them. */
1287 if (r == -EBADMSG || r == -EPROTOTYPE) {
1288 log_debug_errno(r, "Ignoring invalid message: %m");
1292 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1293 r = bus_kernel_translate_message(bus, k);
1295 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1300 close_kdbus_msg(bus, k);
1302 return r < 0 ? r : 1;
1305 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1306 struct memfd_cache *c;
1313 if (!bus || !bus->is_kernel)
1316 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1318 if (bus->n_memfd_cache <= 0) {
1321 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1323 r = memfd_new(bus->description);
1333 c = &bus->memfd_cache[--bus->n_memfd_cache];
1336 assert(c->mapped == 0 || c->address);
1338 *address = c->address;
1339 *mapped = c->mapped;
1340 *allocated = c->allocated;
1343 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1348 static void close_and_munmap(int fd, void *address, size_t size) {
1350 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1355 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1356 struct memfd_cache *c;
1357 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1360 assert(mapped == 0 || address);
1362 if (!bus || !bus->is_kernel) {
1363 close_and_munmap(fd, address, mapped);
1367 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1369 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1370 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1372 close_and_munmap(fd, address, mapped);
1376 c = &bus->memfd_cache[bus->n_memfd_cache++];
1378 c->address = address;
1380 /* If overly long, let's return a bit to the OS */
1381 if (mapped > max_mapped) {
1382 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1383 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1384 c->mapped = c->allocated = max_mapped;
1387 c->allocated = allocated;
1390 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1393 void bus_kernel_flush_memfd(sd_bus *b) {
1398 for (i = 0; i < b->n_memfd_cache; i++)
1399 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1402 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1405 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1406 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1408 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1409 f |= KDBUS_NAME_REPLACE_EXISTING;
1411 if (flags & SD_BUS_NAME_QUEUE)
1412 f |= KDBUS_NAME_QUEUE;
1417 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1420 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1421 SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1422 m |= KDBUS_ATTACH_CREDS;
1424 if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1425 m |= KDBUS_ATTACH_PIDS;
1427 if (mask & SD_BUS_CREDS_COMM)
1428 m |= KDBUS_ATTACH_PID_COMM;
1430 if (mask & SD_BUS_CREDS_TID_COMM)
1431 m |= KDBUS_ATTACH_TID_COMM;
1433 if (mask & SD_BUS_CREDS_EXE)
1434 m |= KDBUS_ATTACH_EXE;
1436 if (mask & SD_BUS_CREDS_CMDLINE)
1437 m |= KDBUS_ATTACH_CMDLINE;
1439 if (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))
1440 m |= KDBUS_ATTACH_CGROUP;
1442 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1443 m |= KDBUS_ATTACH_CAPS;
1445 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1446 m |= KDBUS_ATTACH_SECLABEL;
1448 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1449 m |= KDBUS_ATTACH_AUDIT;
1451 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1452 m |= KDBUS_ATTACH_NAMES;
1454 if (mask & SD_BUS_CREDS_DESCRIPTION)
1455 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1457 if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1458 m |= KDBUS_ATTACH_AUXGROUPS;
1463 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1464 struct kdbus_cmd_make *make;
1465 struct kdbus_item *n;
1472 fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1477 make = alloca0_align(offsetof(struct kdbus_cmd_make, items) +
1478 ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1479 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1480 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1483 make->size = offsetof(struct kdbus_cmd_make, items);
1485 /* Set the bloom parameters */
1487 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1488 sizeof(struct kdbus_bloom_parameter);
1489 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1490 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1491 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1493 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1494 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1496 make->size += ALIGN8(n->size);
1498 /* The busses we create make no restrictions on what metadata
1499 * peers can read from incoming messages. */
1500 n = KDBUS_ITEM_NEXT(n);
1501 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1502 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1503 n->data64[0] = _KDBUS_ATTACH_ANY;
1504 make->size += ALIGN8(n->size);
1506 /* Set the a good name */
1507 n = KDBUS_ITEM_NEXT(n);
1508 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1509 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1510 n->type = KDBUS_ITEM_MAKE_NAME;
1511 make->size += ALIGN8(n->size);
1513 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1515 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1523 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1535 static int bus_kernel_translate_access(BusPolicyAccess access) {
1536 assert(access >= 0);
1537 assert(access < _BUS_POLICY_ACCESS_MAX);
1541 case BUS_POLICY_ACCESS_SEE:
1542 return KDBUS_POLICY_SEE;
1544 case BUS_POLICY_ACCESS_TALK:
1545 return KDBUS_POLICY_TALK;
1547 case BUS_POLICY_ACCESS_OWN:
1548 return KDBUS_POLICY_OWN;
1551 assert_not_reached("Unknown policy access");
1555 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1561 switch (policy->type) {
1563 case BUSNAME_POLICY_TYPE_USER: {
1564 const char *user = policy->name;
1567 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1571 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1572 item->policy_access.id = uid;
1576 case BUSNAME_POLICY_TYPE_GROUP: {
1577 const char *group = policy->name;
1580 r = get_group_creds(&group, &gid);
1584 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1585 item->policy_access.id = gid;
1590 assert_not_reached("Unknown policy type");
1593 item->policy_access.access = bus_kernel_translate_access(policy->access);
1598 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1605 len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1612 p = newa(char, len);
1614 sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1616 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1630 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1631 _cleanup_free_ char *path = NULL;
1632 struct kdbus_cmd_make *make;
1633 struct kdbus_item *n;
1637 fd = bus_kernel_open_bus_fd(bus_name, &path);
1641 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) +
1642 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1644 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1645 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1648 sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1649 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1650 n->type = KDBUS_ITEM_MAKE_NAME;
1651 make->size += ALIGN8(n->size);
1654 if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1662 p = strjoin(dirname(path), "/", name, NULL);
1674 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
1676 struct kdbus_cmd_update *update;
1677 struct kdbus_item *n;
1678 BusEndpointPolicy *po;
1683 size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
1685 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1686 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
1687 size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1690 update = alloca0_align(size, 8);
1691 update->size = size;
1695 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1696 n->type = KDBUS_ITEM_NAME;
1697 n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1;
1698 strcpy(n->str, po->name);
1699 n = KDBUS_ITEM_NEXT(n);
1701 n->type = KDBUS_ITEM_POLICY_ACCESS;
1702 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1704 n->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1705 n->policy_access.access = bus_kernel_translate_access(po->access);
1706 n->policy_access.id = uid;
1708 n = KDBUS_ITEM_NEXT(n);
1711 r = ioctl(fd, KDBUS_CMD_ENDPOINT_UPDATE, update);
1718 int bus_kernel_make_starter(
1723 BusNamePolicy *policy,
1724 BusPolicyAccess world_policy) {
1726 struct kdbus_cmd_hello *hello;
1727 struct kdbus_item *n;
1728 size_t policy_cnt = 0;
1736 LIST_FOREACH(policy, po, policy)
1739 if (world_policy >= 0)
1742 size = offsetof(struct kdbus_cmd_hello, items) +
1743 ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1744 policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1746 hello = alloca0_align(size, 8);
1749 strcpy(n->str, name);
1750 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1751 n->type = KDBUS_ITEM_NAME;
1752 n = KDBUS_ITEM_NEXT(n);
1754 LIST_FOREACH(policy, po, policy) {
1755 n->type = KDBUS_ITEM_POLICY_ACCESS;
1756 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1758 r = bus_kernel_translate_policy(po, n);
1762 n = KDBUS_ITEM_NEXT(n);
1765 if (world_policy >= 0) {
1766 n->type = KDBUS_ITEM_POLICY_ACCESS;
1767 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1768 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1769 n->policy_access.access = bus_kernel_translate_access(world_policy);
1774 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1775 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1776 hello->pool_size = KDBUS_POOL_SIZE;
1777 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
1778 hello->attach_flags_recv = _KDBUS_ATTACH_ANY;
1780 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1783 /* The higher 32bit of the bus_flags fields are considered
1784 * 'incompatible flags'. Refuse them all for now. */
1785 if (hello->bus_flags > 0xFFFFFFFFULL)
1788 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
1794 int bus_kernel_try_close(sd_bus *bus) {
1796 assert(bus->is_kernel);
1798 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1804 int bus_kernel_drop_one(int fd) {
1805 struct kdbus_cmd_recv recv = {
1806 .flags = KDBUS_RECV_DROP
1811 if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0)
1817 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1818 struct kdbus_cmd_update *update;
1819 struct kdbus_item *n;
1822 assert(bus->is_kernel);
1824 update = alloca0_align(offsetof(struct kdbus_cmd_update, items) +
1825 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1829 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1830 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1831 n->data64[0] = bus->attach_flags;
1834 offsetof(struct kdbus_cmd_update, items) +
1837 if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0)
1843 int bus_kernel_fix_attach_mask(void) {
1844 _cleanup_free_ char *mask = NULL;
1845 uint64_t m = (uint64_t) -1;
1849 /* By default we don't want any kdbus metadata fields to be
1850 * suppressed, hence we reset the kernel mask for it to
1851 * (uint64_t) -1. This is overridable via a kernel command
1852 * line option, however. */
1854 r = get_proc_cmdline_key("systemd.kdbus_attach_flags_mask=", &mask);
1856 return log_warning_errno(r, "Failed to read kernel command line: %m");
1859 const char *p = mask;
1861 if (startswith(p, "0x"))
1864 if (sscanf(p, "%" PRIx64, &m) != 1)
1865 log_warning("Couldn't parse systemd.kdbus_attach_flags_mask= kernel command line parameter.");
1868 sprintf(buf, "0x%" PRIx64 "\n", m);
1869 r = write_string_file("/sys/module/kdbus/parameters/attach_flags_mask", buf);
1871 return log_full_errno(
1872 r == -EROFS ? LOG_DEBUG : LOG_WARNING, r,
1873 "Failed to write kdbus attach mask: %m");
1878 int bus_kernel_get_bus_name(sd_bus *bus, char **name) {
1879 struct kdbus_cmd_info cmd = {
1880 .size = sizeof(struct kdbus_cmd_info),
1882 struct kdbus_info *info;
1883 struct kdbus_item *item;
1889 assert(bus->is_kernel);
1891 r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
1895 info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset);
1897 KDBUS_ITEM_FOREACH(item, info, items)
1898 if (item->type == KDBUS_ITEM_MAKE_NAME) {
1899 r = free_and_strdup(&n, item->str);
1903 bus_kernel_cmd_free(bus, cmd.offset);