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 "capability.h"
36 #include "cgroup-util.h"
39 #include "bus-internal.h"
40 #include "bus-message.h"
41 #include "bus-kernel.h"
42 #include "bus-bloom.h"
44 #include "bus-label.h"
46 #define UNIQUE_NAME_MAX (3+DECIMAL_STR_MAX(uint64_t))
48 int bus_kernel_parse_unique_name(const char *s, uint64_t *id) {
54 if (!startswith(s, ":1."))
57 r = safe_atou64(s + 3, id);
64 static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) {
70 /* Note that p can be NULL, which encodes a region full of
71 * zeroes, which is useful to optimize certain padding
74 (*d)->size = offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec);
75 (*d)->type = KDBUS_ITEM_PAYLOAD_VEC;
76 (*d)->vec.address = PTR_TO_UINT64(p);
79 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
82 static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t start, size_t sz) {
88 (*d)->size = offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd);
89 (*d)->type = KDBUS_ITEM_PAYLOAD_MEMFD;
90 (*d)->memfd.fd = memfd;
91 (*d)->memfd.start = start;
92 (*d)->memfd.size = sz;
94 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
97 static void append_destination(struct kdbus_item **d, const char *s, size_t length) {
103 (*d)->size = offsetof(struct kdbus_item, str) + length + 1;
104 (*d)->type = KDBUS_ITEM_DST_NAME;
105 memcpy((*d)->str, s, length + 1);
107 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
110 static struct kdbus_bloom_filter *append_bloom(struct kdbus_item **d, size_t length) {
111 struct kdbus_item *i;
117 i->size = offsetof(struct kdbus_item, bloom_filter) +
118 offsetof(struct kdbus_bloom_filter, data) +
120 i->type = KDBUS_ITEM_BLOOM_FILTER;
122 *d = (struct kdbus_item *) ((uint8_t*) i + i->size);
124 return &i->bloom_filter;
127 static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) {
133 (*d)->size = offsetof(struct kdbus_item, fds) + sizeof(int) * n_fds;
134 (*d)->type = KDBUS_ITEM_FDS;
135 memcpy((*d)->fds, fds, sizeof(int) * n_fds);
137 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
140 static void add_bloom_arg(void *data, size_t size, unsigned n_hash, unsigned i, const char *t) {
141 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
149 e = stpcpy(buf, "arg");
151 *(e++) = '0' + (char) i;
153 *(e++) = '0' + (char) (i / 10);
154 *(e++) = '0' + (char) (i % 10);
158 bloom_add_pair(data, size, n_hash, buf, t);
160 strcpy(e, "-dot-prefix");
161 bloom_add_prefixes(data, size, n_hash, buf, t, '.');
162 strcpy(e, "-slash-prefix");
163 bloom_add_prefixes(data, size, n_hash, buf, t, '/');
166 static int bus_message_setup_bloom(sd_bus_message *m, struct kdbus_bloom_filter *bloom) {
175 memzero(data, m->bus->bloom_size);
176 bloom->generation = 0;
178 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "message-type", bus_message_type_to_string(m->header->type));
181 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "interface", m->interface);
183 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "member", m->member);
185 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path", m->path);
186 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path);
187 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path, '/');
190 r = sd_bus_message_rewind(m, true);
194 for (i = 0; i < 64; i++) {
195 const char *t, *contents;
198 r = sd_bus_message_peek_type(m, &type, &contents);
202 if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE)) {
204 /* The bloom filter includes simple strings of any kind */
205 r = sd_bus_message_read_basic(m, type, &t);
209 add_bloom_arg(data, m->bus->bloom_size, m->bus->bloom_n_hash, i, t);
210 } if (type == SD_BUS_TYPE_ARRAY && STR_IN_SET(contents, "s", "o", "g")) {
212 /* As well as array of simple strings of any kinds */
213 r = sd_bus_message_enter_container(m, type, contents);
217 while ((r = sd_bus_message_read_basic(m, contents[0], &t)) > 0)
218 add_bloom_arg(data, m->bus->bloom_size, m->bus->bloom_n_hash, i, t);
222 r = sd_bus_message_exit_container(m);
227 /* Stop adding to bloom filter as soon as we
228 * run into the first argument we cannot add
236 static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
237 struct bus_body_part *part;
238 struct kdbus_item *d;
239 const char *destination;
250 /* We put this together only once, if this message is reused
251 * we reuse the earlier-built version */
255 destination = m->destination ?: m->destination_ptr;
258 r = bus_kernel_parse_unique_name(destination, &unique);
266 sz = offsetof(struct kdbus_msg, items);
268 /* Add in fixed header, fields header and payload */
269 sz += (1 + m->n_body_parts) * ALIGN8(offsetof(struct kdbus_item, vec) +
270 MAX(sizeof(struct kdbus_vec),
271 sizeof(struct kdbus_memfd)));
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_EXPECT_REPLY) |
299 ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_NO_AUTO_START : 0) |
300 ((m->header->type == SD_BUS_MESSAGE_SIGNAL) ? KDBUS_MSG_SIGNAL : 0);
303 /* verify_destination_id will usually be 0, which makes the kernel driver only look
304 * at the provided well-known name. Otherwise, the kernel will make sure the provided
305 * destination id matches the owner of the provided weel-known-name, and fail if they
306 * differ. Currently, this is only needed for bus-proxyd. */
307 m->kdbus->dst_id = m->verify_destination_id;
309 m->kdbus->dst_id = destination ? unique : KDBUS_DST_ID_BROADCAST;
311 m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
312 m->kdbus->cookie = (uint64_t) m->header->serial;
313 m->kdbus->priority = m->priority;
315 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
316 m->kdbus->cookie_reply = m->reply_cookie;
320 assert_se(clock_gettime(CLOCK_MONOTONIC_COARSE, &now) == 0);
321 m->kdbus->timeout_ns = now.tv_sec * NSEC_PER_SEC + now.tv_nsec +
322 m->timeout * NSEC_PER_USEC;
328 append_destination(&d, destination, dl);
330 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
332 MESSAGE_FOREACH_PART(part, i, m) {
334 /* If this is padding then simply send a
335 * vector with a NULL data pointer which the
336 * kernel will just pass through. This is the
337 * most efficient way to encode zeroes */
339 append_payload_vec(&d, NULL, part->size);
343 if (part->memfd >= 0 && part->sealed && destination) {
344 /* Try to send a memfd, if the part is
345 * sealed and this is not a broadcast. Since we can only */
347 append_payload_memfd(&d, part->memfd, part->memfd_offset, part->size);
351 /* Otherwise, let's send a vector to the actual data.
352 * For that, we need to map it first. */
353 r = bus_body_part_map(part);
357 append_payload_vec(&d, part->data, part->size);
360 if (m->header->type == SD_BUS_MESSAGE_SIGNAL) {
361 struct kdbus_bloom_filter *bloom;
363 bloom = append_bloom(&d, m->bus->bloom_size);
364 r = bus_message_setup_bloom(m, bloom);
370 append_fds(&d, m->fds, m->n_fds);
372 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
373 assert(m->kdbus->size <= sz);
382 static void unset_memfds(struct sd_bus_message *m) {
383 struct bus_body_part *part;
388 /* Make sure the memfds are not freed twice */
389 MESSAGE_FOREACH_PART(part, i, m)
390 if (part->memfd >= 0)
394 static void message_set_timestamp(sd_bus *bus, sd_bus_message *m, const struct kdbus_timestamp *ts) {
401 if (!(bus->attach_flags & KDBUS_ATTACH_TIMESTAMP))
404 m->realtime = ts->realtime_ns / NSEC_PER_USEC;
405 m->monotonic = ts->monotonic_ns / NSEC_PER_USEC;
406 m->seqnum = ts->seqnum;
409 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
410 sd_bus_message *m = NULL;
411 struct kdbus_item *d;
413 _cleanup_free_ int *fds = NULL;
414 struct bus_header *h = NULL;
415 size_t total, n_bytes = 0, idx = 0;
416 const char *destination = NULL, *seclabel = NULL;
421 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
423 KDBUS_ITEM_FOREACH(d, k, items) {
426 l = d->size - offsetof(struct kdbus_item, data);
430 case KDBUS_ITEM_PAYLOAD_OFF:
432 h = (struct bus_header *)((uint8_t *)bus->kdbus_buffer + d->vec.offset);
434 if (!bus_header_is_complete(h, d->vec.size))
438 n_bytes += d->vec.size;
441 case KDBUS_ITEM_PAYLOAD_MEMFD:
445 n_bytes += d->memfd.size;
448 case KDBUS_ITEM_FDS: {
453 f = realloc(fds, sizeof(int) * (n_fds + j));
458 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
463 case KDBUS_ITEM_SECLABEL:
472 r = bus_header_message_size(h, &total);
476 if (n_bytes != total)
479 /* on kdbus we only speak native endian gvariant, never dbus1
480 * marshalling or reverse endian */
481 if (h->version != 2 ||
482 h->endian != BUS_NATIVE_ENDIAN)
485 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
489 /* The well-known names list is different from the other
490 credentials. If we asked for it, but nothing is there, this
491 means that the list of well-known names is simply empty, not
492 that we lack any data */
494 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
496 KDBUS_ITEM_FOREACH(d, k, items) {
499 l = d->size - offsetof(struct kdbus_item, data);
503 case KDBUS_ITEM_PAYLOAD_OFF: {
506 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
508 if (idx + d->vec.size > begin_body) {
509 struct bus_body_part *part;
511 /* Contains body material */
513 part = message_append_part(m);
519 /* A -1 offset is NUL padding. */
520 part->is_zero = d->vec.offset == ~0ULL;
522 if (idx >= begin_body) {
524 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset;
525 part->size = d->vec.size;
528 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset + (begin_body - idx);
529 part->size = d->vec.size - (begin_body - idx);
539 case KDBUS_ITEM_PAYLOAD_MEMFD: {
540 struct bus_body_part *part;
542 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
547 part = message_append_part(m);
553 part->memfd = d->memfd.fd;
554 part->memfd_offset = d->memfd.start;
555 part->size = d->memfd.size;
558 idx += d->memfd.size;
562 case KDBUS_ITEM_PIDS:
564 /* The PID/TID might be missing, when the data
565 * is faked by some data bus proxy and it
566 * lacks that information about the real
567 * client since SO_PEERCRED is used for
570 if (d->pids.pid > 0) {
571 m->creds.pid = (pid_t) d->pids.pid;
572 m->creds.mask |= SD_BUS_CREDS_PID & bus->creds_mask;
575 if (d->pids.tid > 0) {
576 m->creds.tid = (pid_t) d->pids.tid;
577 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
582 case KDBUS_ITEM_CREDS:
584 /* EUID/SUID/FSUID/EGID/SGID/FSGID might be missing too (see above). */
586 if ((uid_t) d->creds.uid != UID_INVALID) {
587 m->creds.uid = (uid_t) d->creds.uid;
588 m->creds.mask |= SD_BUS_CREDS_UID & bus->creds_mask;
591 if ((uid_t) d->creds.euid != UID_INVALID) {
592 m->creds.euid = (uid_t) d->creds.euid;
593 m->creds.mask |= SD_BUS_CREDS_EUID & bus->creds_mask;
596 if ((uid_t) d->creds.suid != UID_INVALID) {
597 m->creds.suid = (uid_t) d->creds.suid;
598 m->creds.mask |= SD_BUS_CREDS_SUID & bus->creds_mask;
601 if ((uid_t) d->creds.fsuid != UID_INVALID) {
602 m->creds.fsuid = (uid_t) d->creds.fsuid;
603 m->creds.mask |= SD_BUS_CREDS_FSUID & bus->creds_mask;
606 if ((gid_t) d->creds.gid != GID_INVALID) {
607 m->creds.gid = (gid_t) d->creds.gid;
608 m->creds.mask |= SD_BUS_CREDS_GID & bus->creds_mask;
611 if ((gid_t) d->creds.egid != GID_INVALID) {
612 m->creds.egid = (gid_t) d->creds.egid;
613 m->creds.mask |= SD_BUS_CREDS_EGID & bus->creds_mask;
616 if ((gid_t) d->creds.sgid != GID_INVALID) {
617 m->creds.sgid = (gid_t) d->creds.sgid;
618 m->creds.mask |= SD_BUS_CREDS_SGID & bus->creds_mask;
621 if ((gid_t) d->creds.fsgid != GID_INVALID) {
622 m->creds.fsgid = (gid_t) d->creds.fsgid;
623 m->creds.mask |= SD_BUS_CREDS_FSGID & bus->creds_mask;
628 case KDBUS_ITEM_TIMESTAMP:
629 message_set_timestamp(bus, m, &d->timestamp);
632 case KDBUS_ITEM_PID_COMM:
633 m->creds.comm = d->str;
634 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
637 case KDBUS_ITEM_TID_COMM:
638 m->creds.tid_comm = d->str;
639 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
643 m->creds.exe = d->str;
644 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
647 case KDBUS_ITEM_CMDLINE:
648 m->creds.cmdline = d->str;
649 m->creds.cmdline_size = l;
650 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
653 case KDBUS_ITEM_CGROUP:
654 m->creds.cgroup = d->str;
655 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;
657 r = bus_get_root_path(bus);
661 m->creds.cgroup_root = bus->cgroup_root;
665 case KDBUS_ITEM_AUDIT:
666 if ((uint32_t) d->audit.sessionid != (uint32_t) -1) {
667 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
668 m->creds.mask |= SD_BUS_CREDS_AUDIT_SESSION_ID & bus->creds_mask;
671 if ((uid_t) d->audit.loginuid != UID_INVALID) {
672 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
673 m->creds.mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID & bus->creds_mask;
677 case KDBUS_ITEM_CAPS:
678 if (d->caps.last_cap != cap_last_cap() ||
679 d->size - offsetof(struct kdbus_item, caps.caps) < DIV_ROUND_UP(d->caps.last_cap, 32U) * 4 * 4) {
684 m->creds.capability = d->caps.caps;
685 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;
688 case KDBUS_ITEM_DST_NAME:
689 if (!service_name_is_valid(d->str)) {
694 destination = d->str;
697 case KDBUS_ITEM_OWNED_NAME:
698 if (!service_name_is_valid(d->name.name)) {
703 if (bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) {
707 /* We just extend the array here, but
708 * do not allocate the strings inside
709 * of it, instead we just point to our
710 * buffer directly. */
711 n = strv_length(m->creds.well_known_names);
712 wkn = realloc(m->creds.well_known_names, (n + 2) * sizeof(char*));
718 wkn[n] = d->name.name;
720 m->creds.well_known_names = wkn;
722 m->creds.mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES;
726 case KDBUS_ITEM_CONN_DESCRIPTION:
727 m->creds.description = d->str;
728 m->creds.mask |= SD_BUS_CREDS_DESCRIPTION & bus->creds_mask;
731 case KDBUS_ITEM_AUXGROUPS:
733 if (bus->creds_mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS) {
734 assert_cc(sizeof(gid_t) == sizeof(uint32_t));
736 m->creds.n_supplementary_gids = (d->size - offsetof(struct kdbus_item, data32)) / sizeof(uint32_t);
737 m->creds.supplementary_gids = (gid_t*) d->data32;
738 m->creds.mask |= SD_BUS_CREDS_SUPPLEMENTARY_GIDS;
744 case KDBUS_ITEM_SECLABEL:
748 log_debug("Got unknown field from kernel %llu", d->type);
752 /* If we requested the list of well-known names to be appended
753 * and the sender had none no item for it will be
754 * attached. However, this does *not* mean that the kernel
755 * didn't want to provide this information to us. Hence, let's
756 * explicitly mark this information as available if it was
758 m->creds.mask |= bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES;
760 r = bus_message_parse_fields(m);
764 /* Refuse messages if kdbus and dbus1 cookie doesn't match up */
765 if ((uint64_t) m->header->serial != k->cookie) {
770 /* Refuse messages where the reply flag doesn't match up */
771 if (!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) != !!(k->flags & KDBUS_MSG_EXPECT_REPLY)) {
776 /* Refuse reply messages where the reply cookie doesn't match up */
777 if ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) && m->reply_cookie != k->cookie_reply) {
782 /* Refuse messages where the autostart flag doesn't match up */
783 if (!(m->header->flags & BUS_MESSAGE_NO_AUTO_START) != !(k->flags & KDBUS_MSG_NO_AUTO_START)) {
788 /* Override information from the user header with data from the kernel */
789 if (k->src_id == KDBUS_SRC_ID_KERNEL)
790 bus_message_set_sender_driver(bus, m);
792 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
793 m->sender = m->creds.unique_name = m->sender_buffer;
797 m->destination = destination;
798 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
799 m->destination = NULL;
800 else if (k->dst_id == KDBUS_DST_ID_NAME)
801 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
803 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
804 m->destination = m->destination_buffer;
807 /* We take possession of the kmsg struct now */
809 m->release_kdbus = true;
813 bus->rqueue[bus->rqueue_size++] = m;
819 sd_bus_message_unref(m);
824 int bus_kernel_take_fd(sd_bus *b) {
825 struct kdbus_bloom_parameter *bloom = NULL;
826 struct kdbus_cmd_hello *hello;
827 struct kdbus_item_list *items;
828 struct kdbus_item *item;
829 _cleanup_free_ char *g = NULL;
831 size_t l = 0, m = 0, sz;
841 if (b->description) {
842 g = bus_label_escape(b->description);
850 /* If no name is explicitly set, we'll include a hint
851 * indicating the library implementation, a hint which
852 * kind of bus this is and the thread name */
854 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
857 name = b->is_system ? "sd-system" :
858 b->is_user ? "sd-user" : "sd";
860 _cleanup_free_ char *e = NULL;
862 e = bus_label_escape(pr);
866 g = strappend(b->is_system ? "sd-system-" :
867 b->is_user ? "sd-user-" : "sd-",
875 b->description = bus_label_unescape(name);
882 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
883 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
885 if (b->fake_creds_valid)
886 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
888 if (b->fake_pids_valid)
889 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
892 l = strlen(b->fake_label);
893 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
896 hello = alloca0_align(sz, 8);
898 hello->flags = b->hello_flags;
899 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
900 hello->attach_flags_recv = b->attach_flags;
901 hello->pool_size = KDBUS_POOL_SIZE;
905 item->size = offsetof(struct kdbus_item, str) + m + 1;
906 item->type = KDBUS_ITEM_CONN_DESCRIPTION;
907 memcpy(item->str, name, m + 1);
908 item = KDBUS_ITEM_NEXT(item);
910 if (b->fake_creds_valid) {
911 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
912 item->type = KDBUS_ITEM_CREDS;
913 item->creds = b->fake_creds;
915 item = KDBUS_ITEM_NEXT(item);
918 if (b->fake_pids_valid) {
919 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
920 item->type = KDBUS_ITEM_PIDS;
921 item->pids = b->fake_pids;
923 item = KDBUS_ITEM_NEXT(item);
927 item->size = offsetof(struct kdbus_item, str) + l + 1;
928 item->type = KDBUS_ITEM_SECLABEL;
929 memcpy(item->str, b->fake_label, l+1);
932 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
936 if (!b->kdbus_buffer) {
937 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
938 if (b->kdbus_buffer == MAP_FAILED) {
939 b->kdbus_buffer = NULL;
945 /* The higher 32bit of the bus_flags fields are considered
946 * 'incompatible flags'. Refuse them all for now. */
947 if (hello->bus_flags > 0xFFFFFFFFULL) {
952 /* extract bloom parameters from items */
953 items = (void*)((uint8_t*)b->kdbus_buffer + hello->offset);
954 KDBUS_ITEM_FOREACH(item, items, items) {
955 switch (item->type) {
956 case KDBUS_ITEM_BLOOM_PARAMETER:
957 bloom = &item->bloom_parameter;
962 if (!bloom || !bloom_validate_parameters((size_t) bloom->size, (unsigned) bloom->n_hash)) {
967 b->bloom_size = (size_t) bloom->size;
968 b->bloom_n_hash = (unsigned) bloom->n_hash;
970 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0) {
975 b->unique_id = hello->id;
978 b->bus_client = true;
979 b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
980 b->message_version = 2;
981 b->message_endian = BUS_NATIVE_ENDIAN;
983 /* the kernel told us the UUID of the underlying bus */
984 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
986 /* free returned items */
987 (void) bus_kernel_cmd_free(b, hello->offset);
988 return bus_start_running(b);
991 (void) bus_kernel_cmd_free(b, hello->offset);
995 int bus_kernel_connect(sd_bus *b) {
997 assert(b->input_fd < 0);
998 assert(b->output_fd < 0);
1004 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
1005 if (b->input_fd < 0)
1008 b->output_fd = b->input_fd;
1010 return bus_kernel_take_fd(b);
1013 int bus_kernel_cmd_free(sd_bus *bus, uint64_t offset) {
1014 struct kdbus_cmd_free cmd = {
1015 .size = sizeof(cmd),
1021 assert(bus->is_kernel);
1023 r = ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
1030 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
1031 struct kdbus_item *d;
1036 KDBUS_ITEM_FOREACH(d, k, items) {
1037 if (d->type == KDBUS_ITEM_FDS)
1038 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
1039 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
1040 safe_close(d->memfd.fd);
1043 bus_kernel_cmd_free(bus, (uint8_t*) k - (uint8_t*) bus->kdbus_buffer);
1046 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
1047 struct kdbus_cmd_send cmd = { };
1052 assert(bus->state == BUS_RUNNING);
1054 /* If we can't deliver, we want room for the error message */
1055 r = bus_rqueue_make_room(bus);
1059 r = bus_message_setup_kmsg(bus, m);
1063 cmd.size = sizeof(cmd);
1064 cmd.msg_address = (uintptr_t)m->kdbus;
1066 /* If this is a synchronous method call, then let's tell the
1067 * kernel, so that it can pass CPU time/scheduling to the
1068 * destination for the time, if it wants to. If we
1069 * synchronously wait for the result anyway, we won't need CPU
1071 if (hint_sync_call) {
1072 m->kdbus->flags |= KDBUS_MSG_EXPECT_REPLY;
1073 cmd.flags |= KDBUS_SEND_SYNC_REPLY;
1076 r = ioctl(bus->output_fd, KDBUS_CMD_SEND, &cmd);
1078 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1079 sd_bus_message *reply;
1081 if (errno == EAGAIN || errno == EINTR)
1083 else if (errno == ENXIO || errno == ESRCH) {
1085 /* ENXIO: unique name not known
1086 * ESRCH: well-known name not known */
1088 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1089 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
1091 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
1095 } else if (errno == EADDRNOTAVAIL) {
1097 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
1099 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1100 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
1102 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
1108 r = bus_message_new_synthetic_error(
1110 BUS_MESSAGE_COOKIE(m),
1117 r = bus_seal_synthetic_message(bus, reply);
1121 bus->rqueue[bus->rqueue_size++] = reply;
1123 } else if (hint_sync_call) {
1124 struct kdbus_msg *k;
1126 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + cmd.reply.offset);
1129 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1131 r = bus_kernel_make_message(bus, k);
1133 close_kdbus_msg(bus, k);
1135 /* Anybody can send us invalid messages, let's just drop them. */
1136 if (r == -EBADMSG || r == -EPROTOTYPE)
1137 log_debug_errno(r, "Ignoring invalid message: %m");
1142 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1143 close_kdbus_msg(bus, k);
1150 static int push_name_owner_changed(
1153 const char *old_owner,
1154 const char *new_owner,
1155 const struct kdbus_timestamp *ts) {
1157 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1162 r = sd_bus_message_new_signal(
1165 "/org/freedesktop/DBus",
1166 "org.freedesktop.DBus",
1167 "NameOwnerChanged");
1171 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1175 bus_message_set_sender_driver(bus, m);
1176 message_set_timestamp(bus, m, ts);
1178 r = bus_seal_synthetic_message(bus, m);
1182 bus->rqueue[bus->rqueue_size++] = m;
1188 static int translate_name_change(
1190 const struct kdbus_msg *k,
1191 const struct kdbus_item *d,
1192 const struct kdbus_timestamp *ts) {
1194 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1200 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1203 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1205 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1207 if (isempty(old_owner))
1212 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1214 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner, ts);
1217 static int translate_id_change(
1219 const struct kdbus_msg *k,
1220 const struct kdbus_item *d,
1221 const struct kdbus_timestamp *ts) {
1223 char owner[UNIQUE_NAME_MAX];
1229 sprintf(owner, ":1.%llu", d->id_change.id);
1231 return push_name_owner_changed(
1233 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1234 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL,
1238 static int translate_reply(
1240 const struct kdbus_msg *k,
1241 const struct kdbus_item *d,
1242 const struct kdbus_timestamp *ts) {
1244 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1251 r = bus_message_new_synthetic_error(
1254 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1255 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1256 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1261 message_set_timestamp(bus, m, ts);
1263 r = bus_seal_synthetic_message(bus, m);
1267 bus->rqueue[bus->rqueue_size++] = m;
1273 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1274 static int (* const translate[])(sd_bus *bus, const struct kdbus_msg *k, const struct kdbus_item *d, const struct kdbus_timestamp *ts) = {
1275 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1276 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1277 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1279 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1280 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1282 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1283 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1286 struct kdbus_item *d, *found = NULL;
1287 struct kdbus_timestamp *ts = NULL;
1291 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1293 KDBUS_ITEM_FOREACH(d, k, items) {
1294 if (d->type == KDBUS_ITEM_TIMESTAMP)
1297 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1302 log_debug("Got unknown field from kernel %llu", d->type);
1306 log_debug("Didn't find a kernel message to translate.");
1310 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found, ts);
1313 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1314 struct kdbus_cmd_recv recv = { .size = sizeof(recv) };
1315 struct kdbus_msg *k;
1320 r = bus_rqueue_make_room(bus);
1324 if (hint_priority) {
1325 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1326 recv.priority = priority;
1329 r = ioctl(bus->input_fd, KDBUS_CMD_RECV, &recv);
1331 if (errno == EAGAIN)
1334 if (errno == EOVERFLOW) {
1335 log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1342 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.msg.offset);
1343 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1344 r = bus_kernel_make_message(bus, k);
1346 /* Anybody can send us invalid messages, let's just drop them. */
1347 if (r == -EBADMSG || r == -EPROTOTYPE) {
1348 log_debug_errno(r, "Ignoring invalid message: %m");
1352 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1353 r = bus_kernel_translate_message(bus, k);
1355 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1360 close_kdbus_msg(bus, k);
1362 return r < 0 ? r : 1;
1365 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1366 struct memfd_cache *c;
1373 if (!bus || !bus->is_kernel)
1376 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1378 if (bus->n_memfd_cache <= 0) {
1381 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1383 r = memfd_new(bus->description);
1393 c = &bus->memfd_cache[--bus->n_memfd_cache];
1396 assert(c->mapped == 0 || c->address);
1398 *address = c->address;
1399 *mapped = c->mapped;
1400 *allocated = c->allocated;
1403 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1408 static void close_and_munmap(int fd, void *address, size_t size) {
1410 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1415 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1416 struct memfd_cache *c;
1417 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1420 assert(mapped == 0 || address);
1422 if (!bus || !bus->is_kernel) {
1423 close_and_munmap(fd, address, mapped);
1427 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1429 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1430 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1432 close_and_munmap(fd, address, mapped);
1436 c = &bus->memfd_cache[bus->n_memfd_cache++];
1438 c->address = address;
1440 /* If overly long, let's return a bit to the OS */
1441 if (mapped > max_mapped) {
1442 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1443 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1444 c->mapped = c->allocated = max_mapped;
1447 c->allocated = allocated;
1450 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1453 void bus_kernel_flush_memfd(sd_bus *b) {
1458 for (i = 0; i < b->n_memfd_cache; i++)
1459 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1462 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1465 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1466 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1468 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1469 f |= KDBUS_NAME_REPLACE_EXISTING;
1471 if (flags & SD_BUS_NAME_QUEUE)
1472 f |= KDBUS_NAME_QUEUE;
1477 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1480 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1481 SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1482 m |= KDBUS_ATTACH_CREDS;
1484 if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_TID))
1485 m |= KDBUS_ATTACH_PIDS;
1487 if (mask & SD_BUS_CREDS_COMM)
1488 m |= KDBUS_ATTACH_PID_COMM;
1490 if (mask & SD_BUS_CREDS_TID_COMM)
1491 m |= KDBUS_ATTACH_TID_COMM;
1493 if (mask & SD_BUS_CREDS_EXE)
1494 m |= KDBUS_ATTACH_EXE;
1496 if (mask & SD_BUS_CREDS_CMDLINE)
1497 m |= KDBUS_ATTACH_CMDLINE;
1499 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))
1500 m |= KDBUS_ATTACH_CGROUP;
1502 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1503 m |= KDBUS_ATTACH_CAPS;
1505 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1506 m |= KDBUS_ATTACH_SECLABEL;
1508 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1509 m |= KDBUS_ATTACH_AUDIT;
1511 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1512 m |= KDBUS_ATTACH_NAMES;
1514 if (mask & SD_BUS_CREDS_DESCRIPTION)
1515 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1517 if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1518 m |= KDBUS_ATTACH_AUXGROUPS;
1523 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1524 struct kdbus_cmd_make *make;
1525 struct kdbus_item *n;
1532 fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1537 make = alloca0_align(offsetof(struct kdbus_cmd_make, items) +
1538 ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1539 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1540 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1541 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1544 make->size = offsetof(struct kdbus_cmd_make, items);
1546 /* Set the bloom parameters */
1548 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1549 sizeof(struct kdbus_bloom_parameter);
1550 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1551 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1552 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1554 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1555 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1557 make->size += ALIGN8(n->size);
1559 /* The busses we create make no restrictions on what metadata
1560 * peers can read from incoming messages. */
1561 n = KDBUS_ITEM_NEXT(n);
1562 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1563 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1564 n->data64[0] = _KDBUS_ATTACH_ANY;
1565 make->size += ALIGN8(n->size);
1567 /* Provide all metadata via bus-owner queries */
1568 n = KDBUS_ITEM_NEXT(n);
1569 n->type = KDBUS_ITEM_ATTACH_FLAGS_SEND;
1570 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1571 n->data64[0] = _KDBUS_ATTACH_ANY;
1572 make->size += ALIGN8(n->size);
1574 /* Set the a good name */
1575 n = KDBUS_ITEM_NEXT(n);
1576 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1577 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1578 n->type = KDBUS_ITEM_MAKE_NAME;
1579 make->size += ALIGN8(n->size);
1581 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1583 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1591 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1603 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1610 len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1617 p = newa(char, len);
1619 sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1621 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1635 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1636 _cleanup_free_ char *path = NULL;
1637 struct kdbus_cmd_make *make;
1638 struct kdbus_item *n;
1642 fd = bus_kernel_open_bus_fd(bus_name, &path);
1646 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) +
1647 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1649 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1650 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1653 sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1654 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1655 n->type = KDBUS_ITEM_MAKE_NAME;
1656 make->size += ALIGN8(n->size);
1659 if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1667 p = strjoin(dirname(path), "/", name, NULL);
1679 int bus_kernel_try_close(sd_bus *bus) {
1681 assert(bus->is_kernel);
1683 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1689 int bus_kernel_drop_one(int fd) {
1690 struct kdbus_cmd_recv recv = {
1691 .size = sizeof(recv),
1692 .flags = KDBUS_RECV_DROP,
1697 if (ioctl(fd, KDBUS_CMD_RECV, &recv) < 0)
1703 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1704 struct kdbus_cmd_update *update;
1705 struct kdbus_item *n;
1708 assert(bus->is_kernel);
1710 update = alloca0_align(offsetof(struct kdbus_cmd_update, items) +
1711 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1715 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1716 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1717 n->data64[0] = bus->attach_flags;
1720 offsetof(struct kdbus_cmd_update, items) +
1723 if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0)
1729 int bus_kernel_fix_attach_mask(void) {
1730 _cleanup_free_ char *mask = NULL;
1731 uint64_t m = (uint64_t) -1;
1735 /* By default we don't want any kdbus metadata fields to be
1736 * suppressed, hence we reset the kernel mask for it to
1737 * (uint64_t) -1. If the module argument was overwritten by
1738 * the kernel cmdline, we leave it as is. */
1740 r = get_proc_cmdline_key("kdbus.attach_flags_mask=", &mask);
1742 return log_warning_errno(r, "Failed to read kernel command line: %m");
1745 sprintf(buf, "0x%" PRIx64 "\n", m);
1746 r = write_string_file("/sys/module/kdbus/parameters/attach_flags_mask", buf);
1748 return log_full_errno(IN_SET(r, -ENOENT, -EROFS) ? LOG_DEBUG : LOG_WARNING, r,
1749 "Failed to write kdbus attach mask: %m");
1755 int bus_kernel_get_bus_name(sd_bus *bus, char **name) {
1756 struct kdbus_cmd_info cmd = {
1757 .size = sizeof(struct kdbus_cmd_info),
1759 struct kdbus_info *info;
1760 struct kdbus_item *item;
1766 assert(bus->is_kernel);
1768 r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
1772 info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset);
1774 KDBUS_ITEM_FOREACH(item, info, items)
1775 if (item->type == KDBUS_ITEM_MAKE_NAME) {
1776 r = free_and_strdup(&n, item->str);
1780 bus_kernel_cmd_free(bus, cmd.offset);