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 int bus_message_setup_bloom(sd_bus_message *m, struct kdbus_bloom_filter *bloom) {
147 memzero(data, m->bus->bloom_size);
148 bloom->generation = 0;
150 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "message-type", bus_message_type_to_string(m->header->type));
153 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "interface", m->interface);
155 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "member", m->member);
157 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path", m->path);
158 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path);
159 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path, '/');
162 r = sd_bus_message_rewind(m, true);
166 for (i = 0; i < 64; i++) {
169 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
172 r = sd_bus_message_peek_type(m, &type, NULL);
176 if (type != SD_BUS_TYPE_STRING &&
177 type != SD_BUS_TYPE_OBJECT_PATH &&
178 type != SD_BUS_TYPE_SIGNATURE)
181 r = sd_bus_message_read_basic(m, type, &t);
185 e = stpcpy(buf, "arg");
187 *(e++) = '0' + (char) i;
189 *(e++) = '0' + (char) (i / 10);
190 *(e++) = '0' + (char) (i % 10);
194 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t);
196 strcpy(e, "-dot-prefix");
197 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t, '.');
198 strcpy(e, "-slash-prefix");
199 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t, '/');
205 static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
206 struct bus_body_part *part;
207 struct kdbus_item *d;
208 const char *destination;
219 /* We put this together only once, if this message is reused
220 * we reuse the earlier-built version */
224 destination = m->destination ?: m->destination_ptr;
227 r = bus_kernel_parse_unique_name(destination, &unique);
235 sz = offsetof(struct kdbus_msg, items);
237 assert_cc(ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec)) ==
238 ALIGN8(offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd)));
240 /* Add in fixed header, fields header and payload */
241 sz += (1 + m->n_body_parts) *
242 ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec));
244 /* Add space for bloom filter */
245 sz += ALIGN8(offsetof(struct kdbus_item, bloom_filter) +
246 offsetof(struct kdbus_bloom_filter, data) +
249 /* Add in well-known destination header */
251 dl = strlen(destination);
252 sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1);
255 /* Add space for unix fds */
257 sz += ALIGN8(offsetof(struct kdbus_item, fds) + sizeof(int)*m->n_fds);
259 m->kdbus = memalign(8, sz);
265 m->free_kdbus = true;
266 memzero(m->kdbus, sz);
269 ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) |
270 ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0);
273 /* verify_destination_id will usually be 0, which makes the kernel driver only look
274 * at the provided well-known name. Otherwise, the kernel will make sure the provided
275 * destination id matches the owner of the provided weel-known-name, and fail if they
276 * differ. Currently, this is only needed for bus-proxyd. */
277 m->kdbus->dst_id = m->verify_destination_id;
279 m->kdbus->dst_id = destination ? unique : KDBUS_DST_ID_BROADCAST;
281 m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
282 m->kdbus->cookie = (uint64_t) m->header->serial;
283 m->kdbus->priority = m->priority;
285 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
286 m->kdbus->cookie_reply = m->reply_cookie;
290 assert_se(clock_gettime(CLOCK_MONOTONIC_COARSE, &now) == 0);
291 m->kdbus->timeout_ns = now.tv_sec * NSEC_PER_SEC + now.tv_nsec +
292 m->timeout * NSEC_PER_USEC;
298 append_destination(&d, destination, dl);
300 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
302 MESSAGE_FOREACH_PART(part, i, m) {
304 /* If this is padding then simply send a
305 * vector with a NULL data pointer which the
306 * kernel will just pass through. This is the
307 * most efficient way to encode zeroes */
309 append_payload_vec(&d, NULL, part->size);
313 if (part->memfd >= 0 && part->sealed && destination) {
314 /* Try to send a memfd, if the part is
315 * sealed and this is not a broadcast. Since we can only */
317 append_payload_memfd(&d, part->memfd, part->size);
321 /* Otherwise, let's send a vector to the actual data.
322 * For that, we need to map it first. */
323 r = bus_body_part_map(part);
327 append_payload_vec(&d, part->data, part->size);
330 if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
331 struct kdbus_bloom_filter *bloom;
333 bloom = append_bloom(&d, m->bus->bloom_size);
334 r = bus_message_setup_bloom(m, bloom);
340 append_fds(&d, m->fds, m->n_fds);
342 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
343 assert(m->kdbus->size <= sz);
352 static void bus_message_set_sender_driver(sd_bus *bus, sd_bus_message *m) {
356 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
357 m->creds.well_known_names_driver = true;
358 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
361 static void unset_memfds(struct sd_bus_message *m) {
362 struct bus_body_part *part;
367 /* Make sure the memfds are not freed twice */
368 MESSAGE_FOREACH_PART(part, i, m)
369 if (part->memfd >= 0)
373 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
374 sd_bus_message *m = NULL;
375 struct kdbus_item *d;
377 _cleanup_free_ int *fds = NULL;
378 struct bus_header *h = NULL;
379 size_t total, n_bytes = 0, idx = 0;
380 const char *destination = NULL, *seclabel = NULL;
385 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
387 KDBUS_ITEM_FOREACH(d, k, items) {
390 l = d->size - offsetof(struct kdbus_item, data);
394 case KDBUS_ITEM_PAYLOAD_OFF:
396 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
398 if (!bus_header_is_complete(h, d->vec.size))
402 n_bytes += d->vec.size;
405 case KDBUS_ITEM_PAYLOAD_MEMFD:
409 n_bytes += d->memfd.size;
412 case KDBUS_ITEM_FDS: {
417 f = realloc(fds, sizeof(int) * (n_fds + j));
422 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
427 case KDBUS_ITEM_SECLABEL:
436 r = bus_header_message_size(h, &total);
440 if (n_bytes != total)
443 /* on kdbus we only speak native endian gvariant, never dbus1
444 * marshalling or reverse endian */
445 if (h->version != 2 ||
446 h->endian != BUS_NATIVE_ENDIAN)
449 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
453 /* The well-known names list is different from the other
454 credentials. If we asked for it, but nothing is there, this
455 means that the list of well-known names is simply empty, not
456 that we lack any data */
458 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
460 KDBUS_ITEM_FOREACH(d, k, items) {
463 l = d->size - offsetof(struct kdbus_item, data);
467 case KDBUS_ITEM_PAYLOAD_OFF: {
470 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
472 if (idx + d->vec.size > begin_body) {
473 struct bus_body_part *part;
475 /* Contains body material */
477 part = message_append_part(m);
483 /* A -1 offset is NUL padding. */
484 part->is_zero = d->vec.offset == ~0ULL;
486 if (idx >= begin_body) {
488 part->data = (uint8_t *)k + d->vec.offset;
489 part->size = d->vec.size;
492 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
493 part->size = d->vec.size - (begin_body - idx);
503 case KDBUS_ITEM_PAYLOAD_MEMFD: {
504 struct bus_body_part *part;
506 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
511 part = message_append_part(m);
517 part->memfd = d->memfd.fd;
518 part->size = d->memfd.size;
521 idx += d->memfd.size;
525 case KDBUS_ITEM_PIDS:
527 /* The PID starttime/TID might be missing,
528 * when the data is faked by some data bus
529 * proxy and it lacks that information about
530 * the real client since SO_PEERCRED is used
533 if (d->pids.pid > 0) {
534 m->creds.pid = (pid_t) d->pids.pid;
535 m->creds.mask |= SD_BUS_CREDS_PID & bus->creds_mask;
538 if (d->pids.starttime > 0) {
539 m->creds.pid_starttime = d->pids.starttime / NSEC_PER_USEC;
540 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
543 if (d->pids.tid > 0) {
544 m->creds.tid = (pid_t) d->pids.tid;
545 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
550 case KDBUS_ITEM_CREDS:
552 /* EUID/SUID/FSUID/EGID/SGID/FSGID might be missing too (see above). */
554 if ((uid_t) d->creds.uid != (uid_t) -1) {
555 m->creds.uid = (uid_t) d->creds.uid;
556 m->creds.mask |= SD_BUS_CREDS_UID & bus->creds_mask;
559 if ((uid_t) d->creds.euid != (uid_t) -1) {
560 m->creds.euid = (uid_t) d->creds.euid;
561 m->creds.mask |= SD_BUS_CREDS_EUID & bus->creds_mask;
564 if ((uid_t) d->creds.suid != (uid_t) -1) {
565 m->creds.suid = (uid_t) d->creds.suid;
566 m->creds.mask |= SD_BUS_CREDS_SUID & bus->creds_mask;
569 if ((uid_t) d->creds.fsuid != (uid_t) -1) {
570 m->creds.fsuid = (uid_t) d->creds.fsuid;
571 m->creds.mask |= SD_BUS_CREDS_FSUID & bus->creds_mask;
574 if ((gid_t) d->creds.gid != (gid_t) -1) {
575 m->creds.gid = (gid_t) d->creds.gid;
576 m->creds.mask |= SD_BUS_CREDS_GID & bus->creds_mask;
579 if ((gid_t) d->creds.egid != (gid_t) -1) {
580 m->creds.egid = (gid_t) d->creds.egid;
581 m->creds.mask |= SD_BUS_CREDS_EGID & bus->creds_mask;
584 if ((gid_t) d->creds.sgid != (gid_t) -1) {
585 m->creds.sgid = (gid_t) d->creds.sgid;
586 m->creds.mask |= SD_BUS_CREDS_SGID & bus->creds_mask;
589 if ((gid_t) d->creds.fsgid != (gid_t) -1) {
590 m->creds.fsgid = (gid_t) d->creds.fsgid;
591 m->creds.mask |= SD_BUS_CREDS_FSGID & bus->creds_mask;
596 case KDBUS_ITEM_TIMESTAMP:
598 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
599 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
600 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
601 m->seqnum = d->timestamp.seqnum;
606 case KDBUS_ITEM_PID_COMM:
607 m->creds.comm = d->str;
608 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
611 case KDBUS_ITEM_TID_COMM:
612 m->creds.tid_comm = d->str;
613 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
617 m->creds.exe = d->str;
618 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
621 case KDBUS_ITEM_CMDLINE:
622 m->creds.cmdline = d->str;
623 m->creds.cmdline_size = l;
624 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
627 case KDBUS_ITEM_CGROUP:
628 m->creds.cgroup = d->str;
629 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;
631 r = bus_get_root_path(bus);
635 m->creds.cgroup_root = bus->cgroup_root;
639 case KDBUS_ITEM_AUDIT:
640 if ((uint32_t) d->audit.sessionid != (uint32_t) -1) {
641 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
642 m->creds.mask |= SD_BUS_CREDS_AUDIT_SESSION_ID & bus->creds_mask;
645 if ((uid_t) d->audit.loginuid != (uid_t) -1) {
646 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
647 m->creds.mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID & bus->creds_mask;
651 case KDBUS_ITEM_CAPS:
652 m->creds.capability = (uint8_t *) d->caps.caps;
653 m->creds.capability_size = d->size - offsetof(struct kdbus_item, caps.caps);
654 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;
657 case KDBUS_ITEM_DST_NAME:
658 if (!service_name_is_valid(d->str)) {
663 destination = d->str;
666 case KDBUS_ITEM_OWNED_NAME:
667 if (!service_name_is_valid(d->name.name)) {
672 if (bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) {
676 /* We just extend the array here, but
677 * do not allocate the strings inside
678 * of it, instead we just point to our
679 * buffer directly. */
680 n = strv_length(m->creds.well_known_names);
681 wkn = realloc(m->creds.well_known_names, (n + 2) * sizeof(char*));
687 wkn[n] = d->name.name;
689 m->creds.well_known_names = wkn;
691 m->creds.mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES;
695 case KDBUS_ITEM_CONN_DESCRIPTION:
696 m->creds.description = d->str;
697 m->creds.mask |= SD_BUS_CREDS_DESCRIPTION & bus->creds_mask;
700 case KDBUS_ITEM_AUXGROUPS:
702 if (bus->creds_mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS) {
703 assert_cc(sizeof(gid_t) == sizeof(uint32_t));
705 m->creds.n_supplementary_gids = (d->size - offsetof(struct kdbus_item, data32)) / sizeof(uint32_t);
706 m->creds.supplementary_gids = (gid_t*) d->data32;
707 m->creds.mask |= SD_BUS_CREDS_SUPPLEMENTARY_GIDS;
713 case KDBUS_ITEM_SECLABEL:
717 log_debug("Got unknown field from kernel %llu", d->type);
721 /* If we requested the list of well-known names to be appended
722 * and the sender had none no item for it will be
723 * attached. However, this does *not* mean that we the kernel
724 * didn't want to provide this information to us. Hence, let's
725 * explicitly mark this information as available if it was
727 m->creds.mask |= bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES;
729 r = bus_message_parse_fields(m);
733 /* Refuse messages if kdbus and dbus1 cookie doesn't match up */
734 if ((uint64_t) m->header->serial != k->cookie) {
739 /* Refuse messages where the reply flag doesn't match up */
740 if (!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) != !!(k->flags & KDBUS_MSG_FLAGS_EXPECT_REPLY)) {
745 /* Refuse reply messages where the reply cookie doesn't match up */
746 if ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) && m->reply_cookie != k->cookie_reply) {
751 /* Refuse messages where the autostart flag doesn't match up */
752 if (!(m->header->flags & BUS_MESSAGE_NO_AUTO_START) != !(k->flags & KDBUS_MSG_FLAGS_NO_AUTO_START)) {
757 /* Override information from the user header with data from the kernel */
758 if (k->src_id == KDBUS_SRC_ID_KERNEL)
759 bus_message_set_sender_driver(bus, m);
761 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
762 m->sender = m->creds.unique_name = m->sender_buffer;
766 m->destination = destination;
767 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
768 m->destination = NULL;
769 else if (k->dst_id == KDBUS_DST_ID_NAME)
770 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
772 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
773 m->destination = m->destination_buffer;
776 /* We take possession of the kmsg struct now */
778 m->release_kdbus = true;
782 bus->rqueue[bus->rqueue_size++] = m;
788 sd_bus_message_unref(m);
793 int bus_kernel_take_fd(sd_bus *b) {
794 struct kdbus_cmd_hello *hello;
795 struct kdbus_item *item;
796 _cleanup_free_ char *g = NULL;
798 size_t l = 0, m = 0, sz;
808 if (b->description) {
809 g = bus_label_escape(b->description);
817 /* If no name is explicitly set, we'll include a hint
818 * indicating the library implementation, a hint which
819 * kind of bus this is and the thread name */
821 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
824 name = b->is_system ? "sd-system" :
825 b->is_user ? "sd-user" : "sd";
827 _cleanup_free_ char *e = NULL;
829 e = bus_label_escape(pr);
833 g = strappend(b->is_system ? "sd-system-" :
834 b->is_user ? "sd-user-" : "sd-",
842 b->description = bus_label_unescape(name);
849 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
850 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
852 if (b->fake_creds_valid)
853 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
855 if (b->fake_pids_valid)
856 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
859 l = strlen(b->fake_label);
860 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
863 hello = alloca0_align(sz, 8);
865 hello->flags = b->hello_flags;
866 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
867 hello->attach_flags_recv = b->attach_flags;
868 hello->pool_size = KDBUS_POOL_SIZE;
872 item->size = offsetof(struct kdbus_item, str) + m + 1;
873 item->type = KDBUS_ITEM_CONN_DESCRIPTION;
874 memcpy(item->str, name, m + 1);
875 item = KDBUS_ITEM_NEXT(item);
877 if (b->fake_creds_valid) {
878 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
879 item->type = KDBUS_ITEM_CREDS;
880 item->creds = b->fake_creds;
882 item = KDBUS_ITEM_NEXT(item);
885 if (b->fake_pids_valid) {
886 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
887 item->type = KDBUS_ITEM_PIDS;
888 item->pids = b->fake_pids;
890 item = KDBUS_ITEM_NEXT(item);
894 item->size = offsetof(struct kdbus_item, str) + l + 1;
895 item->type = KDBUS_ITEM_SECLABEL;
896 memcpy(item->str, b->fake_label, l+1);
899 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
903 if (!b->kdbus_buffer) {
904 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
905 if (b->kdbus_buffer == MAP_FAILED) {
906 b->kdbus_buffer = NULL;
911 /* The higher 32bit of the bus_flags fields are considered
912 * 'incompatible flags'. Refuse them all for now. */
913 if (hello->bus_flags > 0xFFFFFFFFULL)
916 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
919 b->bloom_size = (size_t) hello->bloom.size;
920 b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
922 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
925 b->unique_id = hello->id;
928 b->bus_client = true;
929 b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
930 b->message_version = 2;
931 b->message_endian = BUS_NATIVE_ENDIAN;
933 /* the kernel told us the UUID of the underlying bus */
934 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
936 return bus_start_running(b);
939 int bus_kernel_connect(sd_bus *b) {
941 assert(b->input_fd < 0);
942 assert(b->output_fd < 0);
948 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
952 b->output_fd = b->input_fd;
954 return bus_kernel_take_fd(b);
957 int bus_kernel_cmd_free(sd_bus *bus, uint64_t offset) {
958 struct kdbus_cmd_free cmd = {
965 assert(bus->is_kernel);
967 r = ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
974 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
975 struct kdbus_item *d;
980 KDBUS_ITEM_FOREACH(d, k, items) {
981 if (d->type == KDBUS_ITEM_FDS)
982 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
983 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
984 safe_close(d->memfd.fd);
987 bus_kernel_cmd_free(bus, (uint8_t*) k - (uint8_t*) bus->kdbus_buffer);
990 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
995 assert(bus->state == BUS_RUNNING);
997 /* If we can't deliver, we want room for the error message */
998 r = bus_rqueue_make_room(bus);
1002 r = bus_message_setup_kmsg(bus, m);
1006 /* If this is a synchronous method call, then let's tell the
1007 * kernel, so that it can pass CPU time/scheduling to the
1008 * destination for the time, if it wants to. If we
1009 * synchronously wait for the result anyway, we won't need CPU
1012 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
1014 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
1016 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1017 sd_bus_message *reply;
1019 if (errno == EAGAIN || errno == EINTR)
1021 else if (errno == ENXIO || errno == ESRCH) {
1023 /* ENXIO: unique name not known
1024 * ESRCH: well-known name not known */
1026 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1027 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
1029 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
1033 } else if (errno == EADDRNOTAVAIL) {
1035 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
1037 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1038 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
1040 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
1046 r = bus_message_new_synthetic_error(
1048 BUS_MESSAGE_COOKIE(m),
1055 r = bus_seal_synthetic_message(bus, reply);
1059 bus->rqueue[bus->rqueue_size++] = reply;
1061 } else if (hint_sync_call) {
1062 struct kdbus_msg *k;
1064 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
1067 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1069 r = bus_kernel_make_message(bus, k);
1071 close_kdbus_msg(bus, k);
1073 /* Anybody can send us invalid messages, let's just drop them. */
1074 if (r == -EBADMSG || r == -EPROTOTYPE)
1075 log_debug_errno(r, "Ignoring invalid message: %m");
1080 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1081 close_kdbus_msg(bus, k);
1088 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
1089 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1094 r = sd_bus_message_new_signal(
1097 "/org/freedesktop/DBus",
1098 "org.freedesktop.DBus",
1099 "NameOwnerChanged");
1103 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1107 bus_message_set_sender_driver(bus, m);
1109 r = bus_seal_synthetic_message(bus, m);
1113 bus->rqueue[bus->rqueue_size++] = m;
1119 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1120 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1126 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1129 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1131 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1133 if (isempty(old_owner))
1138 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1140 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
1143 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1144 char owner[UNIQUE_NAME_MAX];
1150 sprintf(owner, ":1.%llu", d->id_change.id);
1152 return push_name_owner_changed(
1154 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1155 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
1158 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1159 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1166 r = bus_message_new_synthetic_error(
1169 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1170 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1171 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
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 bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1189 struct kdbus_item *d, *found = NULL;
1191 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1192 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1193 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1194 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1196 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1197 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1199 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1200 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1205 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1207 KDBUS_ITEM_FOREACH(d, k, items) {
1208 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1213 log_debug("Got unknown field from kernel %llu", d->type);
1217 log_debug("Didn't find a kernel message to translate.");
1221 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1224 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1225 struct kdbus_cmd_recv recv = {};
1226 struct kdbus_msg *k;
1231 r = bus_rqueue_make_room(bus);
1235 if (hint_priority) {
1236 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1237 recv.priority = priority;
1240 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1242 if (errno == EAGAIN)
1245 if (errno == EOVERFLOW) {
1246 log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1253 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1254 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1255 r = bus_kernel_make_message(bus, k);
1257 /* Anybody can send us invalid messages, let's just drop them. */
1258 if (r == -EBADMSG || r == -EPROTOTYPE) {
1259 log_debug_errno(r, "Ignoring invalid message: %m");
1263 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1264 r = bus_kernel_translate_message(bus, k);
1266 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1271 close_kdbus_msg(bus, k);
1273 return r < 0 ? r : 1;
1276 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1277 struct memfd_cache *c;
1284 if (!bus || !bus->is_kernel)
1287 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1289 if (bus->n_memfd_cache <= 0) {
1292 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1294 r = memfd_new(bus->description);
1304 c = &bus->memfd_cache[--bus->n_memfd_cache];
1307 assert(c->mapped == 0 || c->address);
1309 *address = c->address;
1310 *mapped = c->mapped;
1311 *allocated = c->allocated;
1314 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1319 static void close_and_munmap(int fd, void *address, size_t size) {
1321 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1326 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1327 struct memfd_cache *c;
1328 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1331 assert(mapped == 0 || address);
1333 if (!bus || !bus->is_kernel) {
1334 close_and_munmap(fd, address, mapped);
1338 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1340 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1341 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1343 close_and_munmap(fd, address, mapped);
1347 c = &bus->memfd_cache[bus->n_memfd_cache++];
1349 c->address = address;
1351 /* If overly long, let's return a bit to the OS */
1352 if (mapped > max_mapped) {
1353 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1354 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1355 c->mapped = c->allocated = max_mapped;
1358 c->allocated = allocated;
1361 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1364 void bus_kernel_flush_memfd(sd_bus *b) {
1369 for (i = 0; i < b->n_memfd_cache; i++)
1370 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1373 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1376 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1377 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1379 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1380 f |= KDBUS_NAME_REPLACE_EXISTING;
1382 if (flags & SD_BUS_NAME_QUEUE)
1383 f |= KDBUS_NAME_QUEUE;
1388 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1391 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1392 SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1393 m |= KDBUS_ATTACH_CREDS;
1395 if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1396 m |= KDBUS_ATTACH_PIDS;
1398 if (mask & SD_BUS_CREDS_COMM)
1399 m |= KDBUS_ATTACH_PID_COMM;
1401 if (mask & SD_BUS_CREDS_TID_COMM)
1402 m |= KDBUS_ATTACH_TID_COMM;
1404 if (mask & SD_BUS_CREDS_EXE)
1405 m |= KDBUS_ATTACH_EXE;
1407 if (mask & SD_BUS_CREDS_CMDLINE)
1408 m |= KDBUS_ATTACH_CMDLINE;
1410 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))
1411 m |= KDBUS_ATTACH_CGROUP;
1413 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1414 m |= KDBUS_ATTACH_CAPS;
1416 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1417 m |= KDBUS_ATTACH_SECLABEL;
1419 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1420 m |= KDBUS_ATTACH_AUDIT;
1422 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1423 m |= KDBUS_ATTACH_NAMES;
1425 if (mask & SD_BUS_CREDS_DESCRIPTION)
1426 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1428 if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1429 m |= KDBUS_ATTACH_AUXGROUPS;
1434 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1435 struct kdbus_cmd_make *make;
1436 struct kdbus_item *n;
1443 fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1448 make = alloca0_align(offsetof(struct kdbus_cmd_make, items) +
1449 ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1450 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1451 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1454 make->size = offsetof(struct kdbus_cmd_make, items);
1456 /* Set the bloom parameters */
1458 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1459 sizeof(struct kdbus_bloom_parameter);
1460 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1461 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1462 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1464 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1465 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1467 make->size += ALIGN8(n->size);
1469 /* The busses we create make no restrictions on what metadata
1470 * peers can read from incoming messages. */
1471 n = KDBUS_ITEM_NEXT(n);
1472 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1473 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1474 n->data64[0] = _KDBUS_ATTACH_ANY;
1475 make->size += ALIGN8(n->size);
1477 /* Set the a good name */
1478 n = KDBUS_ITEM_NEXT(n);
1479 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1480 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1481 n->type = KDBUS_ITEM_MAKE_NAME;
1482 make->size += ALIGN8(n->size);
1484 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1486 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1494 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1506 static int bus_kernel_translate_access(BusPolicyAccess access) {
1507 assert(access >= 0);
1508 assert(access < _BUS_POLICY_ACCESS_MAX);
1512 case BUS_POLICY_ACCESS_SEE:
1513 return KDBUS_POLICY_SEE;
1515 case BUS_POLICY_ACCESS_TALK:
1516 return KDBUS_POLICY_TALK;
1518 case BUS_POLICY_ACCESS_OWN:
1519 return KDBUS_POLICY_OWN;
1522 assert_not_reached("Unknown policy access");
1526 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1532 switch (policy->type) {
1534 case BUSNAME_POLICY_TYPE_USER: {
1535 const char *user = policy->name;
1538 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1542 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1543 item->policy_access.id = uid;
1547 case BUSNAME_POLICY_TYPE_GROUP: {
1548 const char *group = policy->name;
1551 r = get_group_creds(&group, &gid);
1555 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1556 item->policy_access.id = gid;
1561 assert_not_reached("Unknown policy type");
1564 item->policy_access.access = bus_kernel_translate_access(policy->access);
1569 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1576 len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1583 p = newa(char, len);
1585 sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1587 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1601 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1602 _cleanup_free_ char *path = NULL;
1603 struct kdbus_cmd_make *make;
1604 struct kdbus_item *n;
1608 fd = bus_kernel_open_bus_fd(bus_name, &path);
1612 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) +
1613 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1615 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1616 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1619 sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1620 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1621 n->type = KDBUS_ITEM_MAKE_NAME;
1622 make->size += ALIGN8(n->size);
1625 if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1633 p = strjoin(dirname(path), "/", name, NULL);
1645 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
1647 struct kdbus_cmd_update *update;
1648 struct kdbus_item *n;
1649 BusEndpointPolicy *po;
1654 size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
1656 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1657 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
1658 size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1661 update = alloca0_align(size, 8);
1662 update->size = size;
1666 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1667 n->type = KDBUS_ITEM_NAME;
1668 n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1;
1669 strcpy(n->str, po->name);
1670 n = KDBUS_ITEM_NEXT(n);
1672 n->type = KDBUS_ITEM_POLICY_ACCESS;
1673 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1675 n->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1676 n->policy_access.access = bus_kernel_translate_access(po->access);
1677 n->policy_access.id = uid;
1679 n = KDBUS_ITEM_NEXT(n);
1682 r = ioctl(fd, KDBUS_CMD_ENDPOINT_UPDATE, update);
1689 int bus_kernel_make_starter(
1694 BusNamePolicy *policy,
1695 BusPolicyAccess world_policy) {
1697 struct kdbus_cmd_hello *hello;
1698 struct kdbus_item *n;
1699 size_t policy_cnt = 0;
1707 LIST_FOREACH(policy, po, policy)
1710 if (world_policy >= 0)
1713 size = offsetof(struct kdbus_cmd_hello, items) +
1714 ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1715 policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1717 hello = alloca0_align(size, 8);
1720 strcpy(n->str, name);
1721 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1722 n->type = KDBUS_ITEM_NAME;
1723 n = KDBUS_ITEM_NEXT(n);
1725 LIST_FOREACH(policy, po, policy) {
1726 n->type = KDBUS_ITEM_POLICY_ACCESS;
1727 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1729 r = bus_kernel_translate_policy(po, n);
1733 n = KDBUS_ITEM_NEXT(n);
1736 if (world_policy >= 0) {
1737 n->type = KDBUS_ITEM_POLICY_ACCESS;
1738 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1739 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1740 n->policy_access.access = bus_kernel_translate_access(world_policy);
1745 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1746 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1747 hello->pool_size = KDBUS_POOL_SIZE;
1748 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
1749 hello->attach_flags_recv = _KDBUS_ATTACH_ANY;
1751 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1754 /* The higher 32bit of the bus_flags fields are considered
1755 * 'incompatible flags'. Refuse them all for now. */
1756 if (hello->bus_flags > 0xFFFFFFFFULL)
1759 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
1765 int bus_kernel_try_close(sd_bus *bus) {
1767 assert(bus->is_kernel);
1769 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1775 int bus_kernel_drop_one(int fd) {
1776 struct kdbus_cmd_recv recv = {
1777 .flags = KDBUS_RECV_DROP
1782 if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0)
1788 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1789 struct kdbus_cmd_update *update;
1790 struct kdbus_item *n;
1793 assert(bus->is_kernel);
1795 update = alloca0_align(offsetof(struct kdbus_cmd_update, items) +
1796 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1800 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1801 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1802 n->data64[0] = bus->attach_flags;
1805 offsetof(struct kdbus_cmd_update, items) +
1808 if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0)
1814 int bus_kernel_fix_attach_mask(void) {
1815 _cleanup_free_ char *mask = NULL;
1816 uint64_t m = (uint64_t) -1;
1820 /* By default we don't want any kdbus metadata fields to be
1821 * suppressed, hence we reset the kernel mask for it to
1822 * (uint64_t) -1. This is overridable via a kernel command
1823 * line option, however. */
1825 r = get_proc_cmdline_key("systemd.kdbus_attach_flags_mask=", &mask);
1827 return log_warning_errno(r, "Failed to read kernel command line: %m");
1830 const char *p = mask;
1832 if (startswith(p, "0x"))
1835 if (sscanf(p, "%" PRIx64, &m) != 1)
1836 log_warning("Couldn't parse systemd.kdbus_attach_flags_mask= kernel command line parameter.");
1839 sprintf(buf, "0x%" PRIx64 "\n", m);
1840 r = write_string_file("/sys/module/kdbus/parameters/attach_flags_mask", buf);
1842 return log_full_errno(
1843 r == -EROFS ? LOG_DEBUG : LOG_WARNING, r,
1844 "Failed to write kdbus attach mask: %m");
1849 int bus_kernel_get_bus_name(sd_bus *bus, char **name) {
1850 struct kdbus_cmd_info cmd = {
1851 .size = sizeof(struct kdbus_cmd_info),
1853 struct kdbus_info *info;
1854 struct kdbus_item *item;
1860 assert(bus->is_kernel);
1862 r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
1866 info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset);
1868 KDBUS_ITEM_FOREACH(item, info, items)
1869 if (item->type == KDBUS_ITEM_MAKE_NAME) {
1870 r = free_and_strdup(&n, item->str);
1874 bus_kernel_cmd_free(bus, cmd.offset);