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"
36 #include "bus-internal.h"
37 #include "bus-message.h"
38 #include "bus-kernel.h"
39 #include "bus-bloom.h"
41 #include "bus-label.h"
42 #include "cgroup-util.h"
44 #define UNIQUE_NAME_MAX (3+DECIMAL_STR_MAX(uint64_t))
46 int bus_kernel_parse_unique_name(const char *s, uint64_t *id) {
52 if (!startswith(s, ":1."))
55 r = safe_atou64(s + 3, id);
62 static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) {
68 /* Note that p can be NULL, which encodes a region full of
69 * zeroes, which is useful to optimize certain padding
72 (*d)->size = offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec);
73 (*d)->type = KDBUS_ITEM_PAYLOAD_VEC;
74 (*d)->vec.address = PTR_TO_UINT64(p);
77 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
80 static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t sz) {
86 (*d)->size = offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd);
87 (*d)->type = KDBUS_ITEM_PAYLOAD_MEMFD;
88 (*d)->memfd.fd = memfd;
89 (*d)->memfd.size = sz;
91 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
94 static void append_destination(struct kdbus_item **d, const char *s, size_t length) {
100 (*d)->size = offsetof(struct kdbus_item, str) + length + 1;
101 (*d)->type = KDBUS_ITEM_DST_NAME;
102 memcpy((*d)->str, s, length + 1);
104 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
107 static struct kdbus_bloom_filter *append_bloom(struct kdbus_item **d, size_t length) {
108 struct kdbus_item *i;
114 i->size = offsetof(struct kdbus_item, bloom_filter) +
115 offsetof(struct kdbus_bloom_filter, data) +
117 i->type = KDBUS_ITEM_BLOOM_FILTER;
119 *d = (struct kdbus_item *) ((uint8_t*) i + i->size);
121 return &i->bloom_filter;
124 static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) {
130 (*d)->size = offsetof(struct kdbus_item, fds) + sizeof(int) * n_fds;
131 (*d)->type = KDBUS_ITEM_FDS;
132 memcpy((*d)->fds, fds, sizeof(int) * n_fds);
134 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
137 static int bus_message_setup_bloom(sd_bus_message *m, struct kdbus_bloom_filter *bloom) {
146 memzero(data, m->bus->bloom_size);
147 bloom->generation = 0;
149 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "message-type", bus_message_type_to_string(m->header->type));
152 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "interface", m->interface);
154 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "member", m->member);
156 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path", m->path);
157 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path);
158 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path, '/');
161 r = sd_bus_message_rewind(m, true);
165 for (i = 0; i < 64; i++) {
168 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
171 r = sd_bus_message_peek_type(m, &type, NULL);
175 if (type != SD_BUS_TYPE_STRING &&
176 type != SD_BUS_TYPE_OBJECT_PATH &&
177 type != SD_BUS_TYPE_SIGNATURE)
180 r = sd_bus_message_read_basic(m, type, &t);
184 e = stpcpy(buf, "arg");
186 *(e++) = '0' + (char) i;
188 *(e++) = '0' + (char) (i / 10);
189 *(e++) = '0' + (char) (i % 10);
193 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t);
195 strcpy(e, "-dot-prefix");
196 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t, '.');
197 strcpy(e, "-slash-prefix");
198 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t, '/');
204 static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
205 struct bus_body_part *part;
206 struct kdbus_item *d;
207 const char *destination;
218 /* We put this together only once, if this message is reused
219 * we reuse the earlier-built version */
223 destination = m->destination ?: m->destination_ptr;
226 r = bus_kernel_parse_unique_name(destination, &unique);
234 sz = offsetof(struct kdbus_msg, items);
236 assert_cc(ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec)) ==
237 ALIGN8(offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd)));
239 /* Add in fixed header, fields header and payload */
240 sz += (1 + m->n_body_parts) *
241 ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec));
243 /* Add space for bloom filter */
244 sz += ALIGN8(offsetof(struct kdbus_item, bloom_filter) +
245 offsetof(struct kdbus_bloom_filter, data) +
248 /* Add in well-known destination header */
250 dl = strlen(destination);
251 sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1);
254 /* Add space for unix fds */
256 sz += ALIGN8(offsetof(struct kdbus_item, fds) + sizeof(int)*m->n_fds);
258 m->kdbus = memalign(8, sz);
264 m->free_kdbus = true;
265 memzero(m->kdbus, sz);
268 ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) |
269 ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0);
272 /* verify_destination_id will usually be 0, which makes the kernel driver only look
273 * at the provided well-known name. Otherwise, the kernel will make sure the provided
274 * destination id matches the owner of the provided weel-known-name, and fail if they
275 * differ. Currently, this is only needed for bus-proxyd. */
276 m->kdbus->dst_id = m->verify_destination_id;
278 m->kdbus->dst_id = destination ? unique : KDBUS_DST_ID_BROADCAST;
280 m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
281 m->kdbus->cookie = (uint64_t) m->header->serial;
282 m->kdbus->priority = m->priority;
284 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
285 m->kdbus->cookie_reply = m->reply_cookie;
289 assert_se(clock_gettime(CLOCK_MONOTONIC_COARSE, &now) == 0);
290 m->kdbus->timeout_ns = now.tv_sec * NSEC_PER_SEC + now.tv_nsec +
291 m->timeout * NSEC_PER_USEC;
297 append_destination(&d, destination, dl);
299 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
301 MESSAGE_FOREACH_PART(part, i, m) {
303 /* If this is padding then simply send a
304 * vector with a NULL data pointer which the
305 * kernel will just pass through. This is the
306 * most efficient way to encode zeroes */
308 append_payload_vec(&d, NULL, part->size);
312 if (part->memfd >= 0 && part->sealed && destination) {
313 /* Try to send a memfd, if the part is
314 * sealed and this is not a broadcast. Since we can only */
316 append_payload_memfd(&d, part->memfd, part->size);
320 /* Otherwise, let's send a vector to the actual data.
321 * For that, we need to map it first. */
322 r = bus_body_part_map(part);
326 append_payload_vec(&d, part->data, part->size);
329 if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
330 struct kdbus_bloom_filter *bloom;
332 bloom = append_bloom(&d, m->bus->bloom_size);
333 r = bus_message_setup_bloom(m, bloom);
339 append_fds(&d, m->fds, m->n_fds);
341 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
342 assert(m->kdbus->size <= sz);
351 static void unset_memfds(struct sd_bus_message *m) {
352 struct bus_body_part *part;
357 /* Make sure the memfds are not freed twice */
358 MESSAGE_FOREACH_PART(part, i, m)
359 if (part->memfd >= 0)
363 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
364 sd_bus_message *m = NULL;
365 struct kdbus_item *d;
367 _cleanup_free_ int *fds = NULL;
368 struct bus_header *h = NULL;
369 size_t total, n_bytes = 0, idx = 0;
370 const char *destination = NULL, *seclabel = NULL;
375 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
377 KDBUS_ITEM_FOREACH(d, k, items) {
380 l = d->size - offsetof(struct kdbus_item, data);
384 case KDBUS_ITEM_PAYLOAD_OFF:
386 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
388 if (!bus_header_is_complete(h, d->vec.size))
392 n_bytes += d->vec.size;
395 case KDBUS_ITEM_PAYLOAD_MEMFD:
399 n_bytes += d->memfd.size;
402 case KDBUS_ITEM_FDS: {
407 f = realloc(fds, sizeof(int) * (n_fds + j));
412 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
417 case KDBUS_ITEM_SECLABEL:
426 r = bus_header_message_size(h, &total);
430 if (n_bytes != total)
433 /* on kdbus we only speak native endian gvariant, never dbus1
434 * marshalling or reverse endian */
435 if (h->version != 2 ||
436 h->endian != BUS_NATIVE_ENDIAN)
439 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
443 /* The well-known names list is different from the other
444 credentials. If we asked for it, but nothing is there, this
445 means that the list of well-known names is simply empty, not
446 that we lack any data */
448 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
450 KDBUS_ITEM_FOREACH(d, k, items) {
453 l = d->size - offsetof(struct kdbus_item, data);
457 case KDBUS_ITEM_PAYLOAD_OFF: {
460 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
462 if (idx + d->vec.size > begin_body) {
463 struct bus_body_part *part;
465 /* Contains body material */
467 part = message_append_part(m);
473 /* A -1 offset is NUL padding. */
474 part->is_zero = d->vec.offset == ~0ULL;
476 if (idx >= begin_body) {
478 part->data = (uint8_t *)k + d->vec.offset;
479 part->size = d->vec.size;
482 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
483 part->size = d->vec.size - (begin_body - idx);
493 case KDBUS_ITEM_PAYLOAD_MEMFD: {
494 struct bus_body_part *part;
496 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
501 part = message_append_part(m);
507 part->memfd = d->memfd.fd;
508 part->size = d->memfd.size;
511 idx += d->memfd.size;
515 case KDBUS_ITEM_PIDS:
517 /* The PID starttime/TID might be missing,
518 * when the data is faked by some data bus
519 * proxy and it lacks that information about
520 * the real client since SO_PEERCRED is used
523 if (d->pids.pid > 0) {
524 m->creds.pid = (pid_t) d->pids.pid;
525 m->creds.mask |= SD_BUS_CREDS_PID & bus->creds_mask;
528 if (d->pids.starttime > 0) {
529 m->creds.pid_starttime = d->pids.starttime / NSEC_PER_USEC;
530 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
533 if (d->pids.tid > 0) {
534 m->creds.tid = (pid_t) d->pids.tid;
535 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
540 case KDBUS_ITEM_CREDS:
542 /* EUID/SUID/FSUID/EGID/SGID/FSGID might be missing too (see above). */
544 if ((uid_t) d->creds.uid != (uid_t) -1) {
545 m->creds.uid = (uid_t) d->creds.uid;
546 m->creds.mask |= SD_BUS_CREDS_UID & bus->creds_mask;
549 if ((uid_t) d->creds.euid != (uid_t) -1) {
550 m->creds.euid = (uid_t) d->creds.euid;
551 m->creds.mask |= SD_BUS_CREDS_EUID & bus->creds_mask;
554 if ((uid_t) d->creds.suid != (uid_t) -1) {
555 m->creds.suid = (uid_t) d->creds.suid;
556 m->creds.mask |= SD_BUS_CREDS_SUID & bus->creds_mask;
559 if ((uid_t) d->creds.fsuid != (uid_t) -1) {
560 m->creds.fsuid = (uid_t) d->creds.fsuid;
561 m->creds.mask |= SD_BUS_CREDS_FSUID & bus->creds_mask;
564 if ((gid_t) d->creds.gid != (gid_t) -1) {
565 m->creds.gid = (gid_t) d->creds.gid;
566 m->creds.mask |= SD_BUS_CREDS_GID & bus->creds_mask;
569 if ((gid_t) d->creds.egid != (gid_t) -1) {
570 m->creds.egid = (gid_t) d->creds.egid;
571 m->creds.mask |= SD_BUS_CREDS_EGID & bus->creds_mask;
574 if ((gid_t) d->creds.sgid != (gid_t) -1) {
575 m->creds.sgid = (gid_t) d->creds.sgid;
576 m->creds.mask |= SD_BUS_CREDS_SGID & bus->creds_mask;
579 if ((gid_t) d->creds.fsgid != (gid_t) -1) {
580 m->creds.fsgid = (gid_t) d->creds.fsgid;
581 m->creds.mask |= SD_BUS_CREDS_FSGID & bus->creds_mask;
586 case KDBUS_ITEM_TIMESTAMP:
588 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
589 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
590 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
591 m->seqnum = d->timestamp.seqnum;
596 case KDBUS_ITEM_PID_COMM:
597 m->creds.comm = d->str;
598 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
601 case KDBUS_ITEM_TID_COMM:
602 m->creds.tid_comm = d->str;
603 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
607 m->creds.exe = d->str;
608 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
611 case KDBUS_ITEM_CMDLINE:
612 m->creds.cmdline = d->str;
613 m->creds.cmdline_size = l;
614 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
617 case KDBUS_ITEM_CGROUP:
618 m->creds.cgroup = d->str;
619 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;
621 r = bus_get_root_path(bus);
625 m->creds.cgroup_root = bus->cgroup_root;
629 case KDBUS_ITEM_AUDIT:
630 if ((uint32_t) d->audit.sessionid != (uint32_t) -1) {
631 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
632 m->creds.mask |= SD_BUS_CREDS_AUDIT_SESSION_ID & bus->creds_mask;
635 if ((uid_t) d->audit.loginuid != (uid_t) -1) {
636 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
637 m->creds.mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID & bus->creds_mask;
641 case KDBUS_ITEM_CAPS:
642 m->creds.capability = (uint8_t *) d->caps.caps;
643 m->creds.capability_size = d->size - offsetof(struct kdbus_item, caps.caps);
644 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;
647 case KDBUS_ITEM_DST_NAME:
648 if (!service_name_is_valid(d->str)) {
653 destination = d->str;
656 case KDBUS_ITEM_OWNED_NAME:
657 if (!service_name_is_valid(d->name.name)) {
662 if (bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) {
663 r = strv_extend(&m->creds.well_known_names, d->name.name);
667 m->creds.mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES;
671 case KDBUS_ITEM_CONN_DESCRIPTION:
672 m->creds.description = d->str;
673 m->creds.mask |= SD_BUS_CREDS_DESCRIPTION & bus->creds_mask;
676 case KDBUS_ITEM_AUXGROUPS:
678 if (bus->creds_mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS) {
679 assert_cc(sizeof(gid_t) == sizeof(uint32_t));
681 m->creds.n_supplementary_gids = (d->size - offsetof(struct kdbus_item, data32)) / sizeof(uint32_t);
682 m->creds.supplementary_gids = (gid_t*) d->data32;
683 m->creds.mask |= SD_BUS_CREDS_SUPPLEMENTARY_GIDS;
689 case KDBUS_ITEM_SECLABEL:
693 log_debug("Got unknown field from kernel %llu", d->type);
697 r = bus_message_parse_fields(m);
701 /* Refuse messages if kdbus and dbus1 cookie doesn't match up */
702 if ((uint64_t) m->header->serial != k->cookie) {
707 /* Refuse messages where the reply flag doesn't match up */
708 if (!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) != !!(k->flags & KDBUS_MSG_FLAGS_EXPECT_REPLY)) {
713 /* Refuse reply messages where the reply cookie doesn't match up */
714 if ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) && m->reply_cookie != k->cookie_reply) {
719 /* Refuse messages where the autostart flag doesn't match up */
720 if (!(m->header->flags & BUS_MESSAGE_NO_AUTO_START) != !(k->flags & KDBUS_MSG_FLAGS_NO_AUTO_START)) {
725 /* Override information from the user header with data from the kernel */
726 if (k->src_id == KDBUS_SRC_ID_KERNEL)
727 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
729 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
730 m->sender = m->creds.unique_name = m->sender_buffer;
734 m->destination = destination;
735 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
736 m->destination = NULL;
737 else if (k->dst_id == KDBUS_DST_ID_NAME)
738 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
740 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
741 m->destination = m->destination_buffer;
744 /* We take possession of the kmsg struct now */
746 m->release_kdbus = true;
750 bus->rqueue[bus->rqueue_size++] = m;
756 sd_bus_message_unref(m);
761 int bus_kernel_take_fd(sd_bus *b) {
762 struct kdbus_cmd_hello *hello;
763 struct kdbus_item *item;
764 _cleanup_free_ char *g = NULL;
766 size_t l = 0, m = 0, sz;
776 if (b->description) {
777 g = bus_label_escape(b->description);
785 /* If no name is explicitly set, we'll include a hint
786 * indicating the library implementation, a hint which
787 * kind of bus this is and the thread name */
789 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
792 name = b->is_system ? "sd-system" :
793 b->is_user ? "sd-user" : "sd";
795 _cleanup_free_ char *e = NULL;
797 e = bus_label_escape(pr);
801 g = strappend(b->is_system ? "sd-system-" :
802 b->is_user ? "sd-user-" : "sd-",
810 b->description = bus_label_unescape(name);
817 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
818 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
820 if (b->fake_creds_valid)
821 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
823 if (b->fake_pids_valid)
824 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
827 l = strlen(b->fake_label);
828 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
831 hello = alloca0_align(sz, 8);
833 hello->flags = b->hello_flags;
834 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
835 hello->attach_flags_recv = b->attach_flags;
836 hello->pool_size = KDBUS_POOL_SIZE;
840 item->size = offsetof(struct kdbus_item, str) + m + 1;
841 item->type = KDBUS_ITEM_CONN_DESCRIPTION;
842 memcpy(item->str, name, m + 1);
843 item = KDBUS_ITEM_NEXT(item);
845 if (b->fake_creds_valid) {
846 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
847 item->type = KDBUS_ITEM_CREDS;
848 item->creds = b->fake_creds;
850 item = KDBUS_ITEM_NEXT(item);
853 if (b->fake_pids_valid) {
854 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
855 item->type = KDBUS_ITEM_PIDS;
856 item->pids = b->fake_pids;
858 item = KDBUS_ITEM_NEXT(item);
862 item->size = offsetof(struct kdbus_item, str) + l + 1;
863 item->type = KDBUS_ITEM_SECLABEL;
864 memcpy(item->str, b->fake_label, l+1);
867 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
871 if (!b->kdbus_buffer) {
872 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
873 if (b->kdbus_buffer == MAP_FAILED) {
874 b->kdbus_buffer = NULL;
879 /* The higher 32bit of the bus_flags fields are considered
880 * 'incompatible flags'. Refuse them all for now. */
881 if (hello->bus_flags > 0xFFFFFFFFULL)
884 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
887 b->bloom_size = (size_t) hello->bloom.size;
888 b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
890 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
893 b->unique_id = hello->id;
896 b->bus_client = true;
897 b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
898 b->message_version = 2;
899 b->message_endian = BUS_NATIVE_ENDIAN;
901 /* the kernel told us the UUID of the underlying bus */
902 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
904 return bus_start_running(b);
907 int bus_kernel_connect(sd_bus *b) {
909 assert(b->input_fd < 0);
910 assert(b->output_fd < 0);
916 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
920 b->output_fd = b->input_fd;
922 return bus_kernel_take_fd(b);
925 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
926 struct kdbus_cmd_free cmd = {};
927 struct kdbus_item *d;
932 cmd.offset = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
934 KDBUS_ITEM_FOREACH(d, k, items) {
936 if (d->type == KDBUS_ITEM_FDS)
937 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
938 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
939 safe_close(d->memfd.fd);
942 (void) ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
945 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
950 assert(bus->state == BUS_RUNNING);
952 /* If we can't deliver, we want room for the error message */
953 r = bus_rqueue_make_room(bus);
957 r = bus_message_setup_kmsg(bus, m);
961 /* If this is a synchronous method call, then let's tell the
962 * kernel, so that it can pass CPU time/scheduling to the
963 * destination for the time, if it wants to. If we
964 * synchronously wait for the result anyway, we won't need CPU
967 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
969 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
971 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
972 sd_bus_message *reply;
974 if (errno == EAGAIN || errno == EINTR)
976 else if (errno == ENXIO || errno == ESRCH) {
978 /* ENXIO: unique name not known
979 * ESRCH: well-known name not known */
981 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
982 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
984 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
988 } else if (errno == EADDRNOTAVAIL) {
990 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
992 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
993 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
995 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
1001 r = bus_message_new_synthetic_error(
1003 BUS_MESSAGE_COOKIE(m),
1010 r = bus_seal_synthetic_message(bus, reply);
1014 bus->rqueue[bus->rqueue_size++] = reply;
1016 } else if (hint_sync_call) {
1017 struct kdbus_msg *k;
1019 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
1022 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1024 r = bus_kernel_make_message(bus, k);
1026 close_kdbus_msg(bus, k);
1028 /* Anybody can send us invalid messages, let's just drop them. */
1029 if (r == -EBADMSG || r == -EPROTOTYPE)
1030 log_debug("Ignoring invalid message: %s", strerror(-r));
1035 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1036 close_kdbus_msg(bus, k);
1043 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
1044 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1049 r = sd_bus_message_new_signal(
1052 "/org/freedesktop/DBus",
1053 "org.freedesktop.DBus",
1054 "NameOwnerChanged");
1058 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1062 m->sender = "org.freedesktop.DBus";
1064 r = bus_seal_synthetic_message(bus, m);
1068 bus->rqueue[bus->rqueue_size++] = m;
1074 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1075 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1081 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1084 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1086 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1088 if (isempty(old_owner))
1093 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1095 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
1098 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1099 char owner[UNIQUE_NAME_MAX];
1105 sprintf(owner, ":1.%llu", d->id_change.id);
1107 return push_name_owner_changed(
1109 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1110 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
1113 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1114 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1121 r = bus_message_new_synthetic_error(
1124 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1125 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1126 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1131 m->sender = "org.freedesktop.DBus";
1133 r = bus_seal_synthetic_message(bus, m);
1137 bus->rqueue[bus->rqueue_size++] = m;
1143 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1144 struct kdbus_item *d, *found = NULL;
1146 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1147 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1148 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1149 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1151 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1152 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1154 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1155 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1160 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1162 KDBUS_ITEM_FOREACH(d, k, items) {
1163 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1168 log_debug("Got unknown field from kernel %llu", d->type);
1172 log_debug("Didn't find a kernel message to translate.");
1176 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1179 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1180 struct kdbus_cmd_recv recv = {};
1181 struct kdbus_msg *k;
1186 r = bus_rqueue_make_room(bus);
1190 if (hint_priority) {
1191 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1192 recv.priority = priority;
1195 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1197 if (errno == EAGAIN)
1200 if (errno == EOVERFLOW) {
1201 log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1208 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1209 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1210 r = bus_kernel_make_message(bus, k);
1212 /* Anybody can send us invalid messages, let's just drop them. */
1213 if (r == -EBADMSG || r == -EPROTOTYPE) {
1214 log_debug("Ignoring invalid message: %s", strerror(-r));
1218 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1219 r = bus_kernel_translate_message(bus, k);
1221 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1226 close_kdbus_msg(bus, k);
1228 return r < 0 ? r : 1;
1231 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1232 struct memfd_cache *c;
1239 if (!bus || !bus->is_kernel)
1242 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1244 if (bus->n_memfd_cache <= 0) {
1247 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1249 r = memfd_new(bus->description);
1259 c = &bus->memfd_cache[--bus->n_memfd_cache];
1262 assert(c->mapped == 0 || c->address);
1264 *address = c->address;
1265 *mapped = c->mapped;
1266 *allocated = c->allocated;
1269 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1274 static void close_and_munmap(int fd, void *address, size_t size) {
1276 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1281 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1282 struct memfd_cache *c;
1283 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1286 assert(mapped == 0 || address);
1288 if (!bus || !bus->is_kernel) {
1289 close_and_munmap(fd, address, mapped);
1293 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1295 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1296 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1298 close_and_munmap(fd, address, mapped);
1302 c = &bus->memfd_cache[bus->n_memfd_cache++];
1304 c->address = address;
1306 /* If overly long, let's return a bit to the OS */
1307 if (mapped > max_mapped) {
1308 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1309 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1310 c->mapped = c->allocated = max_mapped;
1313 c->allocated = allocated;
1316 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1319 void bus_kernel_flush_memfd(sd_bus *b) {
1324 for (i = 0; i < b->n_memfd_cache; i++)
1325 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1328 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1331 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1332 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1334 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1335 f |= KDBUS_NAME_REPLACE_EXISTING;
1337 if (flags & SD_BUS_NAME_QUEUE)
1338 f |= KDBUS_NAME_QUEUE;
1343 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1346 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1347 SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1348 m |= KDBUS_ATTACH_CREDS;
1350 if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1351 m |= KDBUS_ATTACH_PIDS;
1353 if (mask & SD_BUS_CREDS_COMM)
1354 m |= KDBUS_ATTACH_PID_COMM;
1356 if (mask & SD_BUS_CREDS_TID_COMM)
1357 m |= KDBUS_ATTACH_TID_COMM;
1359 if (mask & SD_BUS_CREDS_EXE)
1360 m |= KDBUS_ATTACH_EXE;
1362 if (mask & SD_BUS_CREDS_CMDLINE)
1363 m |= KDBUS_ATTACH_CMDLINE;
1365 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))
1366 m |= KDBUS_ATTACH_CGROUP;
1368 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1369 m |= KDBUS_ATTACH_CAPS;
1371 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1372 m |= KDBUS_ATTACH_SECLABEL;
1374 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1375 m |= KDBUS_ATTACH_AUDIT;
1377 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1378 m |= KDBUS_ATTACH_NAMES;
1380 if (mask & SD_BUS_CREDS_DESCRIPTION)
1381 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1383 if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1384 m |= KDBUS_ATTACH_AUXGROUPS;
1389 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1390 struct kdbus_cmd_make *make;
1391 struct kdbus_item *n;
1398 fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1403 make = alloca0_align(offsetof(struct kdbus_cmd_make, items) +
1404 ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1405 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1406 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1409 make->size = offsetof(struct kdbus_cmd_make, items);
1411 /* Set the bloom parameters */
1413 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1414 sizeof(struct kdbus_bloom_parameter);
1415 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1416 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1417 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1419 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1420 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1422 make->size += ALIGN8(n->size);
1424 /* The busses we create make no restrictions on what metadata
1425 * peers can read from incoming messages. */
1426 n = KDBUS_ITEM_NEXT(n);
1427 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1428 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1429 n->data64[0] = _KDBUS_ATTACH_ANY;
1430 make->size += ALIGN8(n->size);
1432 /* Set the a good name */
1433 n = KDBUS_ITEM_NEXT(n);
1434 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1435 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1436 n->type = KDBUS_ITEM_MAKE_NAME;
1437 make->size += ALIGN8(n->size);
1439 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1441 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1449 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1461 static int bus_kernel_translate_access(BusPolicyAccess access) {
1462 assert(access >= 0);
1463 assert(access < _BUS_POLICY_ACCESS_MAX);
1467 case BUS_POLICY_ACCESS_SEE:
1468 return KDBUS_POLICY_SEE;
1470 case BUS_POLICY_ACCESS_TALK:
1471 return KDBUS_POLICY_TALK;
1473 case BUS_POLICY_ACCESS_OWN:
1474 return KDBUS_POLICY_OWN;
1477 assert_not_reached("Unknown policy access");
1481 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1487 switch (policy->type) {
1489 case BUSNAME_POLICY_TYPE_USER: {
1490 const char *user = policy->name;
1493 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1497 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1498 item->policy_access.id = uid;
1502 case BUSNAME_POLICY_TYPE_GROUP: {
1503 const char *group = policy->name;
1506 r = get_group_creds(&group, &gid);
1510 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1511 item->policy_access.id = gid;
1516 assert_not_reached("Unknown policy type");
1519 item->policy_access.access = bus_kernel_translate_access(policy->access);
1524 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1531 len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1538 p = newa(char, len);
1540 sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1542 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1556 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1557 _cleanup_free_ char *path = NULL;
1558 struct kdbus_cmd_make *make;
1559 struct kdbus_item *n;
1563 fd = bus_kernel_open_bus_fd(bus_name, &path);
1567 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) +
1568 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1570 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1571 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1574 sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1575 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1576 n->type = KDBUS_ITEM_MAKE_NAME;
1577 make->size += ALIGN8(n->size);
1580 if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1588 p = strjoin(dirname(path), "/", name, NULL);
1600 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
1602 struct kdbus_cmd_update *update;
1603 struct kdbus_item *n;
1604 BusEndpointPolicy *po;
1609 size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
1611 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1612 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
1613 size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1616 update = alloca0_align(size, 8);
1617 update->size = size;
1621 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1622 n->type = KDBUS_ITEM_NAME;
1623 n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1;
1624 strcpy(n->str, po->name);
1625 n = KDBUS_ITEM_NEXT(n);
1627 n->type = KDBUS_ITEM_POLICY_ACCESS;
1628 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1630 n->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1631 n->policy_access.access = bus_kernel_translate_access(po->access);
1632 n->policy_access.id = uid;
1634 n = KDBUS_ITEM_NEXT(n);
1637 r = ioctl(fd, KDBUS_CMD_ENDPOINT_UPDATE, update);
1644 int bus_kernel_make_starter(
1649 BusNamePolicy *policy,
1650 BusPolicyAccess world_policy) {
1652 struct kdbus_cmd_hello *hello;
1653 struct kdbus_item *n;
1654 size_t policy_cnt = 0;
1662 LIST_FOREACH(policy, po, policy)
1665 if (world_policy >= 0)
1668 size = offsetof(struct kdbus_cmd_hello, items) +
1669 ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1670 policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1672 hello = alloca0_align(size, 8);
1675 strcpy(n->str, name);
1676 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1677 n->type = KDBUS_ITEM_NAME;
1678 n = KDBUS_ITEM_NEXT(n);
1680 LIST_FOREACH(policy, po, policy) {
1681 n->type = KDBUS_ITEM_POLICY_ACCESS;
1682 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1684 r = bus_kernel_translate_policy(po, n);
1688 n = KDBUS_ITEM_NEXT(n);
1691 if (world_policy >= 0) {
1692 n->type = KDBUS_ITEM_POLICY_ACCESS;
1693 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1694 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1695 n->policy_access.access = bus_kernel_translate_access(world_policy);
1700 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1701 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1702 hello->pool_size = KDBUS_POOL_SIZE;
1703 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
1704 hello->attach_flags_recv = _KDBUS_ATTACH_ANY;
1706 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1709 /* The higher 32bit of the bus_flags fields are considered
1710 * 'incompatible flags'. Refuse them all for now. */
1711 if (hello->bus_flags > 0xFFFFFFFFULL)
1714 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
1720 int bus_kernel_try_close(sd_bus *bus) {
1722 assert(bus->is_kernel);
1724 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1730 int bus_kernel_drop_one(int fd) {
1731 struct kdbus_cmd_recv recv = {
1732 .flags = KDBUS_RECV_DROP
1737 if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0)
1743 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1744 struct kdbus_cmd_update *update;
1745 struct kdbus_item *n;
1748 assert(bus->is_kernel);
1750 update = alloca0_align(offsetof(struct kdbus_cmd_update, items) +
1751 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1755 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1756 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1757 n->data64[0] = bus->attach_flags;
1760 offsetof(struct kdbus_cmd_update, items) +
1763 if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0)