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->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
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 bus_message_set_sender_driver(sd_bus *bus, sd_bus_message *m) {
386 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
387 m->creds.well_known_names_driver = true;
388 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
391 static void unset_memfds(struct sd_bus_message *m) {
392 struct bus_body_part *part;
397 /* Make sure the memfds are not freed twice */
398 MESSAGE_FOREACH_PART(part, i, m)
399 if (part->memfd >= 0)
403 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
404 sd_bus_message *m = NULL;
405 struct kdbus_item *d;
407 _cleanup_free_ int *fds = NULL;
408 struct bus_header *h = NULL;
409 size_t total, n_bytes = 0, idx = 0;
410 const char *destination = NULL, *seclabel = NULL;
415 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
417 KDBUS_ITEM_FOREACH(d, k, items) {
420 l = d->size - offsetof(struct kdbus_item, data);
424 case KDBUS_ITEM_PAYLOAD_OFF:
426 h = (struct bus_header *)((uint8_t *)bus->kdbus_buffer + d->vec.offset);
428 if (!bus_header_is_complete(h, d->vec.size))
432 n_bytes += d->vec.size;
435 case KDBUS_ITEM_PAYLOAD_MEMFD:
439 n_bytes += d->memfd.size;
442 case KDBUS_ITEM_FDS: {
447 f = realloc(fds, sizeof(int) * (n_fds + j));
452 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
457 case KDBUS_ITEM_SECLABEL:
466 r = bus_header_message_size(h, &total);
470 if (n_bytes != total)
473 /* on kdbus we only speak native endian gvariant, never dbus1
474 * marshalling or reverse endian */
475 if (h->version != 2 ||
476 h->endian != BUS_NATIVE_ENDIAN)
479 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
483 /* The well-known names list is different from the other
484 credentials. If we asked for it, but nothing is there, this
485 means that the list of well-known names is simply empty, not
486 that we lack any data */
488 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
490 KDBUS_ITEM_FOREACH(d, k, items) {
493 l = d->size - offsetof(struct kdbus_item, data);
497 case KDBUS_ITEM_PAYLOAD_OFF: {
500 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
502 if (idx + d->vec.size > begin_body) {
503 struct bus_body_part *part;
505 /* Contains body material */
507 part = message_append_part(m);
513 /* A -1 offset is NUL padding. */
514 part->is_zero = d->vec.offset == ~0ULL;
516 if (idx >= begin_body) {
518 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset;
519 part->size = d->vec.size;
522 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset + (begin_body - idx);
523 part->size = d->vec.size - (begin_body - idx);
533 case KDBUS_ITEM_PAYLOAD_MEMFD: {
534 struct bus_body_part *part;
536 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
541 part = message_append_part(m);
547 part->memfd = d->memfd.fd;
548 part->memfd_offset = d->memfd.start;
549 part->size = d->memfd.size;
552 idx += d->memfd.size;
556 case KDBUS_ITEM_PIDS:
558 /* The PID/TID might be missing, when the data
559 * is faked by some data bus proxy and it
560 * lacks that information about the real
561 * client since SO_PEERCRED is used for
564 if (d->pids.pid > 0) {
565 m->creds.pid = (pid_t) d->pids.pid;
566 m->creds.mask |= SD_BUS_CREDS_PID & bus->creds_mask;
569 if (d->pids.tid > 0) {
570 m->creds.tid = (pid_t) d->pids.tid;
571 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
576 case KDBUS_ITEM_CREDS:
578 /* EUID/SUID/FSUID/EGID/SGID/FSGID might be missing too (see above). */
580 if ((uid_t) d->creds.uid != UID_INVALID) {
581 m->creds.uid = (uid_t) d->creds.uid;
582 m->creds.mask |= SD_BUS_CREDS_UID & bus->creds_mask;
585 if ((uid_t) d->creds.euid != UID_INVALID) {
586 m->creds.euid = (uid_t) d->creds.euid;
587 m->creds.mask |= SD_BUS_CREDS_EUID & bus->creds_mask;
590 if ((uid_t) d->creds.suid != UID_INVALID) {
591 m->creds.suid = (uid_t) d->creds.suid;
592 m->creds.mask |= SD_BUS_CREDS_SUID & bus->creds_mask;
595 if ((uid_t) d->creds.fsuid != UID_INVALID) {
596 m->creds.fsuid = (uid_t) d->creds.fsuid;
597 m->creds.mask |= SD_BUS_CREDS_FSUID & bus->creds_mask;
600 if ((gid_t) d->creds.gid != GID_INVALID) {
601 m->creds.gid = (gid_t) d->creds.gid;
602 m->creds.mask |= SD_BUS_CREDS_GID & bus->creds_mask;
605 if ((gid_t) d->creds.egid != GID_INVALID) {
606 m->creds.egid = (gid_t) d->creds.egid;
607 m->creds.mask |= SD_BUS_CREDS_EGID & bus->creds_mask;
610 if ((gid_t) d->creds.sgid != GID_INVALID) {
611 m->creds.sgid = (gid_t) d->creds.sgid;
612 m->creds.mask |= SD_BUS_CREDS_SGID & bus->creds_mask;
615 if ((gid_t) d->creds.fsgid != GID_INVALID) {
616 m->creds.fsgid = (gid_t) d->creds.fsgid;
617 m->creds.mask |= SD_BUS_CREDS_FSGID & bus->creds_mask;
622 case KDBUS_ITEM_TIMESTAMP:
624 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
625 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
626 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
627 m->seqnum = d->timestamp.seqnum;
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_cmd_free cmd_free = {
826 .size = sizeof(cmd_free),
829 struct kdbus_bloom_parameter *bloom = NULL;
830 struct kdbus_cmd_hello *hello;
831 struct kdbus_item_list *items;
832 struct kdbus_item *item;
833 _cleanup_free_ char *g = NULL;
835 size_t l = 0, m = 0, sz;
845 if (b->description) {
846 g = bus_label_escape(b->description);
854 /* If no name is explicitly set, we'll include a hint
855 * indicating the library implementation, a hint which
856 * kind of bus this is and the thread name */
858 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
861 name = b->is_system ? "sd-system" :
862 b->is_user ? "sd-user" : "sd";
864 _cleanup_free_ char *e = NULL;
866 e = bus_label_escape(pr);
870 g = strappend(b->is_system ? "sd-system-" :
871 b->is_user ? "sd-user-" : "sd-",
879 b->description = bus_label_unescape(name);
886 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
887 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
889 if (b->fake_creds_valid)
890 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
892 if (b->fake_pids_valid)
893 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
896 l = strlen(b->fake_label);
897 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
900 hello = alloca0_align(sz, 8);
902 hello->flags = b->hello_flags;
903 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
904 hello->attach_flags_recv = b->attach_flags;
905 hello->pool_size = KDBUS_POOL_SIZE;
909 item->size = offsetof(struct kdbus_item, str) + m + 1;
910 item->type = KDBUS_ITEM_CONN_DESCRIPTION;
911 memcpy(item->str, name, m + 1);
912 item = KDBUS_ITEM_NEXT(item);
914 if (b->fake_creds_valid) {
915 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
916 item->type = KDBUS_ITEM_CREDS;
917 item->creds = b->fake_creds;
919 item = KDBUS_ITEM_NEXT(item);
922 if (b->fake_pids_valid) {
923 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
924 item->type = KDBUS_ITEM_PIDS;
925 item->pids = b->fake_pids;
927 item = KDBUS_ITEM_NEXT(item);
931 item->size = offsetof(struct kdbus_item, str) + l + 1;
932 item->type = KDBUS_ITEM_SECLABEL;
933 memcpy(item->str, b->fake_label, l+1);
936 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
940 if (!b->kdbus_buffer) {
941 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
942 if (b->kdbus_buffer == MAP_FAILED) {
943 b->kdbus_buffer = NULL;
949 /* The higher 32bit of the bus_flags fields are considered
950 * 'incompatible flags'. Refuse them all for now. */
951 if (hello->bus_flags > 0xFFFFFFFFULL) {
956 /* extract bloom parameters from items */
957 items = (void*)((uint8_t*)b->kdbus_buffer + hello->offset);
958 KDBUS_ITEM_FOREACH(item, items, items) {
959 switch (item->type) {
960 case KDBUS_ITEM_BLOOM_PARAMETER:
961 bloom = &item->bloom_parameter;
966 if (!bloom || !bloom_validate_parameters((size_t) bloom->size, (unsigned) bloom->n_hash)) {
971 b->bloom_size = (size_t) bloom->size;
972 b->bloom_n_hash = (unsigned) bloom->n_hash;
974 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0) {
979 b->unique_id = hello->id;
982 b->bus_client = true;
983 b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
984 b->message_version = 2;
985 b->message_endian = BUS_NATIVE_ENDIAN;
987 /* the kernel told us the UUID of the underlying bus */
988 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
990 /* free returned items */
991 (void) bus_kernel_cmd_free(b, hello->offset);
993 return bus_start_running(b);
996 cmd_free.offset = hello->offset;
997 (void) ioctl(b->input_fd, KDBUS_CMD_FREE, &cmd_free);
1001 int bus_kernel_connect(sd_bus *b) {
1003 assert(b->input_fd < 0);
1004 assert(b->output_fd < 0);
1010 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
1011 if (b->input_fd < 0)
1014 b->output_fd = b->input_fd;
1016 return bus_kernel_take_fd(b);
1019 int bus_kernel_cmd_free(sd_bus *bus, uint64_t offset) {
1020 struct kdbus_cmd_free cmd = {
1021 .size = sizeof(cmd),
1028 assert(bus->is_kernel);
1030 r = ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
1037 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
1038 struct kdbus_item *d;
1043 KDBUS_ITEM_FOREACH(d, k, items) {
1044 if (d->type == KDBUS_ITEM_FDS)
1045 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
1046 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
1047 safe_close(d->memfd.fd);
1050 bus_kernel_cmd_free(bus, (uint8_t*) k - (uint8_t*) bus->kdbus_buffer);
1053 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
1054 struct kdbus_cmd_send cmd = { };
1059 assert(bus->state == BUS_RUNNING);
1061 /* If we can't deliver, we want room for the error message */
1062 r = bus_rqueue_make_room(bus);
1066 r = bus_message_setup_kmsg(bus, m);
1070 cmd.size = sizeof(cmd);
1071 cmd.msg_address = (uintptr_t)m->kdbus;
1073 /* If this is a synchronous method call, then let's tell the
1074 * kernel, so that it can pass CPU time/scheduling to the
1075 * destination for the time, if it wants to. If we
1076 * synchronously wait for the result anyway, we won't need CPU
1078 if (hint_sync_call) {
1079 m->kdbus->flags |= KDBUS_MSG_EXPECT_REPLY;
1080 cmd.flags |= KDBUS_SEND_SYNC_REPLY;
1083 r = ioctl(bus->output_fd, KDBUS_CMD_SEND, &cmd);
1085 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1086 sd_bus_message *reply;
1088 if (errno == EAGAIN || errno == EINTR)
1090 else if (errno == ENXIO || errno == ESRCH) {
1092 /* ENXIO: unique name not known
1093 * ESRCH: well-known name not known */
1095 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1096 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
1098 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
1102 } else if (errno == EADDRNOTAVAIL) {
1104 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
1106 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1107 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
1109 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
1115 r = bus_message_new_synthetic_error(
1117 BUS_MESSAGE_COOKIE(m),
1124 r = bus_seal_synthetic_message(bus, reply);
1128 bus->rqueue[bus->rqueue_size++] = reply;
1130 } else if (hint_sync_call) {
1131 struct kdbus_msg *k;
1133 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + cmd.reply.offset);
1136 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1138 r = bus_kernel_make_message(bus, k);
1140 close_kdbus_msg(bus, k);
1142 /* Anybody can send us invalid messages, let's just drop them. */
1143 if (r == -EBADMSG || r == -EPROTOTYPE)
1144 log_debug_errno(r, "Ignoring invalid message: %m");
1149 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1150 close_kdbus_msg(bus, k);
1157 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
1158 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1163 r = sd_bus_message_new_signal(
1166 "/org/freedesktop/DBus",
1167 "org.freedesktop.DBus",
1168 "NameOwnerChanged");
1172 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1176 bus_message_set_sender_driver(bus, m);
1178 r = bus_seal_synthetic_message(bus, m);
1182 bus->rqueue[bus->rqueue_size++] = m;
1188 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1189 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1195 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1198 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1200 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1202 if (isempty(old_owner))
1207 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1209 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
1212 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1213 char owner[UNIQUE_NAME_MAX];
1219 sprintf(owner, ":1.%llu", d->id_change.id);
1221 return push_name_owner_changed(
1223 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1224 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
1227 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1228 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1235 r = bus_message_new_synthetic_error(
1238 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1239 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1240 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1245 bus_message_set_sender_driver(bus, m);
1247 r = bus_seal_synthetic_message(bus, m);
1251 bus->rqueue[bus->rqueue_size++] = m;
1257 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1258 struct kdbus_item *d, *found = NULL;
1260 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1261 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1262 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1263 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1265 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1266 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1268 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1269 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1274 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1276 KDBUS_ITEM_FOREACH(d, k, items) {
1277 if (d->type == KDBUS_ITEM_TIMESTAMP)
1280 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1285 log_debug("Got unknown field from kernel %llu", d->type);
1289 log_debug("Didn't find a kernel message to translate.");
1293 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1296 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1297 struct kdbus_cmd_recv recv = { .size = sizeof(recv) };
1298 struct kdbus_msg *k;
1303 r = bus_rqueue_make_room(bus);
1307 if (hint_priority) {
1308 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1309 recv.priority = priority;
1312 r = ioctl(bus->input_fd, KDBUS_CMD_RECV, &recv);
1314 if (errno == EAGAIN)
1317 if (errno == EOVERFLOW) {
1318 log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1325 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.reply.offset);
1326 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1327 r = bus_kernel_make_message(bus, k);
1329 /* Anybody can send us invalid messages, let's just drop them. */
1330 if (r == -EBADMSG || r == -EPROTOTYPE) {
1331 log_debug_errno(r, "Ignoring invalid message: %m");
1335 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1336 r = bus_kernel_translate_message(bus, k);
1338 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1343 close_kdbus_msg(bus, k);
1345 return r < 0 ? r : 1;
1348 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1349 struct memfd_cache *c;
1356 if (!bus || !bus->is_kernel)
1359 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1361 if (bus->n_memfd_cache <= 0) {
1364 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1366 r = memfd_new(bus->description);
1376 c = &bus->memfd_cache[--bus->n_memfd_cache];
1379 assert(c->mapped == 0 || c->address);
1381 *address = c->address;
1382 *mapped = c->mapped;
1383 *allocated = c->allocated;
1386 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1391 static void close_and_munmap(int fd, void *address, size_t size) {
1393 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1398 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1399 struct memfd_cache *c;
1400 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1403 assert(mapped == 0 || address);
1405 if (!bus || !bus->is_kernel) {
1406 close_and_munmap(fd, address, mapped);
1410 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1412 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1413 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1415 close_and_munmap(fd, address, mapped);
1419 c = &bus->memfd_cache[bus->n_memfd_cache++];
1421 c->address = address;
1423 /* If overly long, let's return a bit to the OS */
1424 if (mapped > max_mapped) {
1425 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1426 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1427 c->mapped = c->allocated = max_mapped;
1430 c->allocated = allocated;
1433 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1436 void bus_kernel_flush_memfd(sd_bus *b) {
1441 for (i = 0; i < b->n_memfd_cache; i++)
1442 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1445 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1448 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1449 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1451 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1452 f |= KDBUS_NAME_REPLACE_EXISTING;
1454 if (flags & SD_BUS_NAME_QUEUE)
1455 f |= KDBUS_NAME_QUEUE;
1460 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1463 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1464 SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1465 m |= KDBUS_ATTACH_CREDS;
1467 if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_TID))
1468 m |= KDBUS_ATTACH_PIDS;
1470 if (mask & SD_BUS_CREDS_COMM)
1471 m |= KDBUS_ATTACH_PID_COMM;
1473 if (mask & SD_BUS_CREDS_TID_COMM)
1474 m |= KDBUS_ATTACH_TID_COMM;
1476 if (mask & SD_BUS_CREDS_EXE)
1477 m |= KDBUS_ATTACH_EXE;
1479 if (mask & SD_BUS_CREDS_CMDLINE)
1480 m |= KDBUS_ATTACH_CMDLINE;
1482 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))
1483 m |= KDBUS_ATTACH_CGROUP;
1485 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1486 m |= KDBUS_ATTACH_CAPS;
1488 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1489 m |= KDBUS_ATTACH_SECLABEL;
1491 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1492 m |= KDBUS_ATTACH_AUDIT;
1494 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1495 m |= KDBUS_ATTACH_NAMES;
1497 if (mask & SD_BUS_CREDS_DESCRIPTION)
1498 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1500 if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1501 m |= KDBUS_ATTACH_AUXGROUPS;
1506 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1507 struct kdbus_cmd_make *make;
1508 struct kdbus_item *n;
1515 fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1520 make = alloca0_align(offsetof(struct kdbus_cmd_make, items) +
1521 ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1522 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1523 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1524 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1527 make->size = offsetof(struct kdbus_cmd_make, items);
1529 /* Set the bloom parameters */
1531 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1532 sizeof(struct kdbus_bloom_parameter);
1533 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1534 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1535 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1537 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1538 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1540 make->size += ALIGN8(n->size);
1542 /* The busses we create make no restrictions on what metadata
1543 * peers can read from incoming messages. */
1544 n = KDBUS_ITEM_NEXT(n);
1545 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1546 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1547 n->data64[0] = _KDBUS_ATTACH_ANY;
1548 make->size += ALIGN8(n->size);
1550 /* Provide all metadata via bus-owner queries */
1551 n = KDBUS_ITEM_NEXT(n);
1552 n->type = KDBUS_ITEM_ATTACH_FLAGS_SEND;
1553 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1554 n->data64[0] = _KDBUS_ATTACH_ANY;
1555 make->size += ALIGN8(n->size);
1557 /* Set the a good name */
1558 n = KDBUS_ITEM_NEXT(n);
1559 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1560 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1561 n->type = KDBUS_ITEM_MAKE_NAME;
1562 make->size += ALIGN8(n->size);
1564 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1566 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1574 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1586 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1593 len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1600 p = newa(char, len);
1602 sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1604 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1618 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1619 _cleanup_free_ char *path = NULL;
1620 struct kdbus_cmd_make *make;
1621 struct kdbus_item *n;
1625 fd = bus_kernel_open_bus_fd(bus_name, &path);
1629 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) +
1630 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1632 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1633 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1636 sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1637 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1638 n->type = KDBUS_ITEM_MAKE_NAME;
1639 make->size += ALIGN8(n->size);
1642 if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1650 p = strjoin(dirname(path), "/", name, NULL);
1662 int bus_kernel_try_close(sd_bus *bus) {
1664 assert(bus->is_kernel);
1666 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1672 int bus_kernel_drop_one(int fd) {
1673 struct kdbus_cmd_recv recv = {
1674 .size = sizeof(recv),
1675 .flags = KDBUS_RECV_DROP,
1680 if (ioctl(fd, KDBUS_CMD_RECV, &recv) < 0)
1686 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1687 struct kdbus_cmd_update *update;
1688 struct kdbus_item *n;
1691 assert(bus->is_kernel);
1693 update = alloca0_align(offsetof(struct kdbus_cmd_update, items) +
1694 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1698 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1699 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1700 n->data64[0] = bus->attach_flags;
1703 offsetof(struct kdbus_cmd_update, items) +
1706 if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0)
1712 int bus_kernel_fix_attach_mask(void) {
1713 _cleanup_free_ char *mask = NULL;
1714 uint64_t m = (uint64_t) -1;
1718 /* By default we don't want any kdbus metadata fields to be
1719 * suppressed, hence we reset the kernel mask for it to
1720 * (uint64_t) -1. This is overridable via a kernel command
1721 * line option, however. */
1723 r = get_proc_cmdline_key("systemd.kdbus_attach_flags_mask=", &mask);
1725 return log_warning_errno(r, "Failed to read kernel command line: %m");
1728 const char *p = mask;
1730 if (startswith(p, "0x"))
1733 if (sscanf(p, "%" PRIx64, &m) != 1)
1734 log_warning("Couldn't parse systemd.kdbus_attach_flags_mask= kernel command line parameter.");
1737 sprintf(buf, "0x%" PRIx64 "\n", m);
1738 r = write_string_file("/sys/module/kdbus/parameters/attach_flags_mask", buf);
1740 return log_full_errno(
1741 IN_SET(r, -ENOENT, -EROFS) ? LOG_DEBUG : LOG_WARNING, r,
1742 "Failed to write kdbus attach mask: %m");
1747 int bus_kernel_get_bus_name(sd_bus *bus, char **name) {
1748 struct kdbus_cmd_info cmd = {
1749 .size = sizeof(struct kdbus_cmd_info),
1751 struct kdbus_info *info;
1752 struct kdbus_item *item;
1758 assert(bus->is_kernel);
1760 r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
1764 info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset);
1766 KDBUS_ITEM_FOREACH(item, info, items)
1767 if (item->type == KDBUS_ITEM_MAKE_NAME) {
1768 r = free_and_strdup(&n, item->str);
1772 bus_kernel_cmd_free(bus, cmd.offset);