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;
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 unset_memfds(struct sd_bus_message *m) {
353 struct bus_body_part *part;
358 /* Make sure the memfds are not freed twice */
359 MESSAGE_FOREACH_PART(part, i, m)
360 if (part->memfd >= 0)
364 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
365 sd_bus_message *m = NULL;
366 struct kdbus_item *d;
368 _cleanup_free_ int *fds = NULL;
369 struct bus_header *h = NULL;
370 size_t total, n_bytes = 0, idx = 0;
371 const char *destination = NULL, *seclabel = NULL;
376 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
378 KDBUS_ITEM_FOREACH(d, k, items) {
381 l = d->size - offsetof(struct kdbus_item, data);
385 case KDBUS_ITEM_PAYLOAD_OFF:
387 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
389 if (!bus_header_is_complete(h, d->vec.size))
393 n_bytes += d->vec.size;
396 case KDBUS_ITEM_PAYLOAD_MEMFD:
400 n_bytes += d->memfd.size;
403 case KDBUS_ITEM_FDS: {
408 f = realloc(fds, sizeof(int) * (n_fds + j));
413 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
418 case KDBUS_ITEM_SECLABEL:
427 r = bus_header_message_size(h, &total);
431 if (n_bytes != total)
434 /* on kdbus we only speak native endian gvariant, never dbus1
435 * marshalling or reverse endian */
436 if (h->version != 2 ||
437 h->endian != BUS_NATIVE_ENDIAN)
440 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
444 /* The well-known names list is different from the other
445 credentials. If we asked for it, but nothing is there, this
446 means that the list of well-known names is simply empty, not
447 that we lack any data */
449 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
451 KDBUS_ITEM_FOREACH(d, k, items) {
454 l = d->size - offsetof(struct kdbus_item, data);
458 case KDBUS_ITEM_PAYLOAD_OFF: {
461 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
463 if (idx + d->vec.size > begin_body) {
464 struct bus_body_part *part;
466 /* Contains body material */
468 part = message_append_part(m);
474 /* A -1 offset is NUL padding. */
475 part->is_zero = d->vec.offset == ~0ULL;
477 if (idx >= begin_body) {
479 part->data = (uint8_t *)k + d->vec.offset;
480 part->size = d->vec.size;
483 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
484 part->size = d->vec.size - (begin_body - idx);
494 case KDBUS_ITEM_PAYLOAD_MEMFD: {
495 struct bus_body_part *part;
497 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
502 part = message_append_part(m);
508 part->memfd = d->memfd.fd;
509 part->size = d->memfd.size;
512 idx += d->memfd.size;
516 case KDBUS_ITEM_PIDS:
518 /* The PID starttime/TID might be missing,
519 * when the data is faked by some data bus
520 * proxy and it lacks that information about
521 * the real client since SO_PEERCRED is used
524 if (d->pids.pid > 0) {
525 m->creds.pid = (pid_t) d->pids.pid;
526 m->creds.mask |= SD_BUS_CREDS_PID & bus->creds_mask;
529 if (d->pids.starttime > 0) {
530 m->creds.pid_starttime = d->pids.starttime / NSEC_PER_USEC;
531 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
534 if (d->pids.tid > 0) {
535 m->creds.tid = (pid_t) d->pids.tid;
536 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
541 case KDBUS_ITEM_CREDS:
543 /* EUID/SUID/FSUID/EGID/SGID/FSGID might be missing too (see above). */
545 if ((uid_t) d->creds.uid != (uid_t) -1) {
546 m->creds.uid = (uid_t) d->creds.uid;
547 m->creds.mask |= SD_BUS_CREDS_UID & bus->creds_mask;
550 if ((uid_t) d->creds.euid != (uid_t) -1) {
551 m->creds.euid = (uid_t) d->creds.euid;
552 m->creds.mask |= SD_BUS_CREDS_EUID & bus->creds_mask;
555 if ((uid_t) d->creds.suid != (uid_t) -1) {
556 m->creds.suid = (uid_t) d->creds.suid;
557 m->creds.mask |= SD_BUS_CREDS_SUID & bus->creds_mask;
560 if ((uid_t) d->creds.fsuid != (uid_t) -1) {
561 m->creds.fsuid = (uid_t) d->creds.fsuid;
562 m->creds.mask |= SD_BUS_CREDS_FSUID & bus->creds_mask;
565 if ((gid_t) d->creds.gid != (gid_t) -1) {
566 m->creds.gid = (gid_t) d->creds.gid;
567 m->creds.mask |= SD_BUS_CREDS_GID & bus->creds_mask;
570 if ((gid_t) d->creds.egid != (gid_t) -1) {
571 m->creds.egid = (gid_t) d->creds.egid;
572 m->creds.mask |= SD_BUS_CREDS_EGID & bus->creds_mask;
575 if ((gid_t) d->creds.sgid != (gid_t) -1) {
576 m->creds.sgid = (gid_t) d->creds.sgid;
577 m->creds.mask |= SD_BUS_CREDS_SGID & bus->creds_mask;
580 if ((gid_t) d->creds.fsgid != (gid_t) -1) {
581 m->creds.fsgid = (gid_t) d->creds.fsgid;
582 m->creds.mask |= SD_BUS_CREDS_FSGID & bus->creds_mask;
587 case KDBUS_ITEM_TIMESTAMP:
589 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
590 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
591 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
592 m->seqnum = d->timestamp.seqnum;
597 case KDBUS_ITEM_PID_COMM:
598 m->creds.comm = d->str;
599 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
602 case KDBUS_ITEM_TID_COMM:
603 m->creds.tid_comm = d->str;
604 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
608 m->creds.exe = d->str;
609 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
612 case KDBUS_ITEM_CMDLINE:
613 m->creds.cmdline = d->str;
614 m->creds.cmdline_size = l;
615 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
618 case KDBUS_ITEM_CGROUP:
619 m->creds.cgroup = d->str;
620 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;
622 r = bus_get_root_path(bus);
626 m->creds.cgroup_root = bus->cgroup_root;
630 case KDBUS_ITEM_AUDIT:
631 if ((uint32_t) d->audit.sessionid != (uint32_t) -1) {
632 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
633 m->creds.mask |= SD_BUS_CREDS_AUDIT_SESSION_ID & bus->creds_mask;
636 if ((uid_t) d->audit.loginuid != (uid_t) -1) {
637 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
638 m->creds.mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID & bus->creds_mask;
642 case KDBUS_ITEM_CAPS:
643 m->creds.capability = (uint8_t *) d->caps.caps;
644 m->creds.capability_size = d->size - offsetof(struct kdbus_item, caps.caps);
645 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;
648 case KDBUS_ITEM_DST_NAME:
649 if (!service_name_is_valid(d->str)) {
654 destination = d->str;
657 case KDBUS_ITEM_OWNED_NAME:
658 if (!service_name_is_valid(d->name.name)) {
663 if (bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) {
664 r = strv_extend(&m->creds.well_known_names, d->name.name);
668 m->creds.mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES;
672 case KDBUS_ITEM_CONN_DESCRIPTION:
673 m->creds.description = d->str;
674 m->creds.mask |= SD_BUS_CREDS_DESCRIPTION & bus->creds_mask;
677 case KDBUS_ITEM_AUXGROUPS:
679 if (bus->creds_mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS) {
682 n = (d->size - offsetof(struct kdbus_item, data32)) / sizeof(uint32_t);
689 for (i = 0; i < n; i++)
690 u[i] = (uid_t) d->data32[i];
692 m->creds.supplementary_gids = u;
693 m->creds.n_supplementary_gids = n;
695 m->creds.mask |= SD_BUS_CREDS_SUPPLEMENTARY_GIDS;
701 case KDBUS_ITEM_SECLABEL:
705 log_debug("Got unknown field from kernel %llu", d->type);
709 r = bus_message_parse_fields(m);
713 /* Override information from the user header with data from the kernel */
714 if (k->src_id == KDBUS_SRC_ID_KERNEL)
715 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
717 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
718 m->sender = m->creds.unique_name = m->sender_buffer;
722 m->destination = destination;
723 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
724 m->destination = NULL;
725 else if (k->dst_id == KDBUS_DST_ID_NAME)
726 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
728 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
729 m->destination = m->destination_buffer;
732 /* We take possession of the kmsg struct now */
734 m->release_kdbus = true;
738 bus->rqueue[bus->rqueue_size++] = m;
744 sd_bus_message_unref(m);
749 int bus_kernel_take_fd(sd_bus *b) {
750 struct kdbus_cmd_hello *hello;
751 struct kdbus_item *item;
752 _cleanup_free_ char *g = NULL;
754 size_t l = 0, m = 0, sz;
764 if (b->description) {
765 g = bus_label_escape(b->description);
773 /* If no name is explicitly set, we'll include a hint
774 * indicating the library implementation, a hint which
775 * kind of bus this is and the thread name */
777 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
780 name = b->is_system ? "sd-system" :
781 b->is_user ? "sd-user" : "sd";
783 _cleanup_free_ char *e = NULL;
785 e = bus_label_escape(pr);
789 g = strappend(b->is_system ? "sd-system-" :
790 b->is_user ? "sd-user-" : "sd-",
798 b->description = bus_label_unescape(name);
805 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
806 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
808 if (b->fake_creds_valid)
809 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
811 if (b->fake_pids_valid)
812 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
815 l = strlen(b->fake_label);
816 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
819 hello = alloca0_align(sz, 8);
821 hello->flags = b->hello_flags;
822 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
823 hello->attach_flags_recv = b->attach_flags;
824 hello->pool_size = KDBUS_POOL_SIZE;
828 item->size = offsetof(struct kdbus_item, str) + m + 1;
829 item->type = KDBUS_ITEM_CONN_DESCRIPTION;
830 memcpy(item->str, name, m + 1);
831 item = KDBUS_ITEM_NEXT(item);
833 if (b->fake_creds_valid) {
834 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
835 item->type = KDBUS_ITEM_CREDS;
836 item->creds = b->fake_creds;
838 item = KDBUS_ITEM_NEXT(item);
841 if (b->fake_pids_valid) {
842 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
843 item->type = KDBUS_ITEM_PIDS;
844 item->pids = b->fake_pids;
846 item = KDBUS_ITEM_NEXT(item);
850 item->size = offsetof(struct kdbus_item, str) + l + 1;
851 item->type = KDBUS_ITEM_SECLABEL;
852 memcpy(item->str, b->fake_label, l+1);
855 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
859 if (!b->kdbus_buffer) {
860 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
861 if (b->kdbus_buffer == MAP_FAILED) {
862 b->kdbus_buffer = NULL;
867 /* The higher 32bit of the bus_flags fields are considered
868 * 'incompatible flags'. Refuse them all for now. */
869 if (hello->bus_flags > 0xFFFFFFFFULL)
872 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
875 b->bloom_size = (size_t) hello->bloom.size;
876 b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
878 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
881 b->unique_id = hello->id;
884 b->bus_client = true;
885 b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
886 b->message_version = 2;
887 b->message_endian = BUS_NATIVE_ENDIAN;
889 /* the kernel told us the UUID of the underlying bus */
890 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
892 return bus_start_running(b);
895 int bus_kernel_connect(sd_bus *b) {
897 assert(b->input_fd < 0);
898 assert(b->output_fd < 0);
904 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
908 b->output_fd = b->input_fd;
910 return bus_kernel_take_fd(b);
913 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
914 struct kdbus_cmd_free cmd = {};
915 struct kdbus_item *d;
920 cmd.offset = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
922 KDBUS_ITEM_FOREACH(d, k, items) {
924 if (d->type == KDBUS_ITEM_FDS)
925 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
926 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
927 safe_close(d->memfd.fd);
930 (void) ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
933 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
938 assert(bus->state == BUS_RUNNING);
940 /* If we can't deliver, we want room for the error message */
941 r = bus_rqueue_make_room(bus);
945 r = bus_message_setup_kmsg(bus, m);
949 /* If this is a synchronous method call, then let's tell the
950 * kernel, so that it can pass CPU time/scheduling to the
951 * destination for the time, if it wants to. If we
952 * synchronously wait for the result anyway, we won't need CPU
955 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
957 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
959 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
960 sd_bus_message *reply;
962 if (errno == EAGAIN || errno == EINTR)
964 else if (errno == ENXIO || errno == ESRCH) {
966 /* ENXIO: unique name not known
967 * ESRCH: well-known name not known */
969 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
970 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
972 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
976 } else if (errno == EADDRNOTAVAIL) {
978 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
980 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
981 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
983 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
989 r = bus_message_new_synthetic_error(
991 BUS_MESSAGE_COOKIE(m),
998 r = bus_seal_synthetic_message(bus, reply);
1002 bus->rqueue[bus->rqueue_size++] = reply;
1004 } else if (hint_sync_call) {
1005 struct kdbus_msg *k;
1007 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
1010 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1012 r = bus_kernel_make_message(bus, k);
1014 close_kdbus_msg(bus, k);
1016 /* Anybody can send us invalid messages, let's just drop them. */
1017 if (r == -EBADMSG || r == -EPROTOTYPE)
1018 log_debug("Ignoring invalid message: %s", strerror(-r));
1023 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1024 close_kdbus_msg(bus, k);
1031 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
1032 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1037 r = sd_bus_message_new_signal(
1040 "/org/freedesktop/DBus",
1041 "org.freedesktop.DBus",
1042 "NameOwnerChanged");
1046 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1050 m->sender = "org.freedesktop.DBus";
1052 r = bus_seal_synthetic_message(bus, m);
1056 bus->rqueue[bus->rqueue_size++] = m;
1062 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1063 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1069 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1072 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1074 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1076 if (isempty(old_owner))
1081 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1083 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
1086 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1087 char owner[UNIQUE_NAME_MAX];
1093 sprintf(owner, ":1.%llu", d->id_change.id);
1095 return push_name_owner_changed(
1097 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1098 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
1101 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1102 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1109 r = bus_message_new_synthetic_error(
1112 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1113 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1114 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1119 m->sender = "org.freedesktop.DBus";
1121 r = bus_seal_synthetic_message(bus, m);
1125 bus->rqueue[bus->rqueue_size++] = m;
1131 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1132 struct kdbus_item *d, *found = NULL;
1134 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1135 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1136 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1137 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1139 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1140 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1142 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1143 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1148 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1150 KDBUS_ITEM_FOREACH(d, k, items) {
1151 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1156 log_debug("Got unknown field from kernel %llu", d->type);
1160 log_debug("Didn't find a kernel message to translate.");
1164 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1167 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1168 struct kdbus_cmd_recv recv = {};
1169 struct kdbus_msg *k;
1174 r = bus_rqueue_make_room(bus);
1178 if (hint_priority) {
1179 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1180 recv.priority = priority;
1183 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1185 if (errno == EAGAIN)
1188 if (errno == EOVERFLOW) {
1189 log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1196 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1197 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1198 r = bus_kernel_make_message(bus, k);
1200 /* Anybody can send us invalid messages, let's just drop them. */
1201 if (r == -EBADMSG || r == -EPROTOTYPE) {
1202 log_debug("Ignoring invalid message: %s", strerror(-r));
1206 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1207 r = bus_kernel_translate_message(bus, k);
1209 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1214 close_kdbus_msg(bus, k);
1216 return r < 0 ? r : 1;
1219 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1220 struct memfd_cache *c;
1227 if (!bus || !bus->is_kernel)
1230 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1232 if (bus->n_memfd_cache <= 0) {
1235 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1237 r = memfd_new(bus->description);
1247 c = &bus->memfd_cache[--bus->n_memfd_cache];
1250 assert(c->mapped == 0 || c->address);
1252 *address = c->address;
1253 *mapped = c->mapped;
1254 *allocated = c->allocated;
1257 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1262 static void close_and_munmap(int fd, void *address, size_t size) {
1264 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1269 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1270 struct memfd_cache *c;
1271 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1274 assert(mapped == 0 || address);
1276 if (!bus || !bus->is_kernel) {
1277 close_and_munmap(fd, address, mapped);
1281 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1283 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1284 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1286 close_and_munmap(fd, address, mapped);
1290 c = &bus->memfd_cache[bus->n_memfd_cache++];
1292 c->address = address;
1294 /* If overly long, let's return a bit to the OS */
1295 if (mapped > max_mapped) {
1296 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1297 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1298 c->mapped = c->allocated = max_mapped;
1301 c->allocated = allocated;
1304 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1307 void bus_kernel_flush_memfd(sd_bus *b) {
1312 for (i = 0; i < b->n_memfd_cache; i++)
1313 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1316 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1319 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1320 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1322 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1323 f |= KDBUS_NAME_REPLACE_EXISTING;
1325 if (flags & SD_BUS_NAME_QUEUE)
1326 f |= KDBUS_NAME_QUEUE;
1331 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1334 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1335 SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1336 m |= KDBUS_ATTACH_CREDS;
1338 if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1339 m |= KDBUS_ATTACH_PIDS;
1341 if (mask & SD_BUS_CREDS_COMM)
1342 m |= KDBUS_ATTACH_PID_COMM;
1344 if (mask & SD_BUS_CREDS_TID_COMM)
1345 m |= KDBUS_ATTACH_TID_COMM;
1347 if (mask & SD_BUS_CREDS_EXE)
1348 m |= KDBUS_ATTACH_EXE;
1350 if (mask & SD_BUS_CREDS_CMDLINE)
1351 m |= KDBUS_ATTACH_CMDLINE;
1353 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))
1354 m |= KDBUS_ATTACH_CGROUP;
1356 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1357 m |= KDBUS_ATTACH_CAPS;
1359 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1360 m |= KDBUS_ATTACH_SECLABEL;
1362 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1363 m |= KDBUS_ATTACH_AUDIT;
1365 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1366 m |= KDBUS_ATTACH_NAMES;
1368 if (mask & SD_BUS_CREDS_DESCRIPTION)
1369 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1371 if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1372 m |= KDBUS_ATTACH_AUXGROUPS;
1377 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1378 struct kdbus_cmd_make *make;
1379 struct kdbus_item *n;
1386 fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1391 make = alloca0_align(offsetof(struct kdbus_cmd_make, items) +
1392 ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1393 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1394 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1397 make->size = offsetof(struct kdbus_cmd_make, items);
1399 /* Set the bloom parameters */
1401 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1402 sizeof(struct kdbus_bloom_parameter);
1403 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1404 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1405 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1407 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1408 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1410 make->size += ALIGN8(n->size);
1412 /* The busses we create make no restrictions on what metadata
1413 * peers can read from incoming messages. */
1414 n = KDBUS_ITEM_NEXT(n);
1415 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1416 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1417 n->data64[0] = _KDBUS_ATTACH_ANY;
1418 make->size += ALIGN8(n->size);
1420 /* Set the a good name */
1421 n = KDBUS_ITEM_NEXT(n);
1422 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1423 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1424 n->type = KDBUS_ITEM_MAKE_NAME;
1425 make->size += ALIGN8(n->size);
1427 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1429 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1437 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1449 static int bus_kernel_translate_access(BusPolicyAccess access) {
1450 assert(access >= 0);
1451 assert(access < _BUS_POLICY_ACCESS_MAX);
1455 case BUS_POLICY_ACCESS_SEE:
1456 return KDBUS_POLICY_SEE;
1458 case BUS_POLICY_ACCESS_TALK:
1459 return KDBUS_POLICY_TALK;
1461 case BUS_POLICY_ACCESS_OWN:
1462 return KDBUS_POLICY_OWN;
1465 assert_not_reached("Unknown policy access");
1469 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1475 switch (policy->type) {
1477 case BUSNAME_POLICY_TYPE_USER: {
1478 const char *user = policy->name;
1481 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1485 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1486 item->policy_access.id = uid;
1490 case BUSNAME_POLICY_TYPE_GROUP: {
1491 const char *group = policy->name;
1494 r = get_group_creds(&group, &gid);
1498 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1499 item->policy_access.id = gid;
1504 assert_not_reached("Unknown policy type");
1507 item->policy_access.access = bus_kernel_translate_access(policy->access);
1512 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1519 len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1526 p = newa(char, len);
1528 sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1530 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1544 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1545 _cleanup_free_ char *path = NULL;
1546 struct kdbus_cmd_make *make;
1547 struct kdbus_item *n;
1551 fd = bus_kernel_open_bus_fd(bus_name, &path);
1555 size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1556 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(ep_name) + 1);
1558 make = alloca0_align(size, 8);
1560 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1564 n->type = KDBUS_ITEM_MAKE_NAME;
1565 n->size = offsetof(struct kdbus_item, str) + strlen(ep_name) + 1;
1566 strcpy(n->str, ep_name);
1568 if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1576 p = strjoin(dirname(path), "/", ep_name, NULL);
1588 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
1590 struct kdbus_cmd_update *update;
1591 struct kdbus_item *n;
1592 BusEndpointPolicy *po;
1597 size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
1599 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1600 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
1601 size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1604 update = alloca0_align(size, 8);
1605 update->size = size;
1609 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1610 n->type = KDBUS_ITEM_NAME;
1611 n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1;
1612 strcpy(n->str, po->name);
1613 n = KDBUS_ITEM_NEXT(n);
1615 n->type = KDBUS_ITEM_POLICY_ACCESS;
1616 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1618 n->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1619 n->policy_access.access = bus_kernel_translate_access(po->access);
1620 n->policy_access.id = uid;
1622 n = KDBUS_ITEM_NEXT(n);
1625 r = ioctl(fd, KDBUS_CMD_ENDPOINT_UPDATE, update);
1632 int bus_kernel_make_starter(
1637 BusNamePolicy *policy,
1638 BusPolicyAccess world_policy) {
1640 struct kdbus_cmd_hello *hello;
1641 struct kdbus_item *n;
1642 size_t policy_cnt = 0;
1650 LIST_FOREACH(policy, po, policy)
1653 if (world_policy >= 0)
1656 size = offsetof(struct kdbus_cmd_hello, items) +
1657 ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1658 policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1660 hello = alloca0_align(size, 8);
1663 strcpy(n->str, name);
1664 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1665 n->type = KDBUS_ITEM_NAME;
1666 n = KDBUS_ITEM_NEXT(n);
1668 LIST_FOREACH(policy, po, policy) {
1669 n->type = KDBUS_ITEM_POLICY_ACCESS;
1670 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1672 r = bus_kernel_translate_policy(po, n);
1676 n = KDBUS_ITEM_NEXT(n);
1679 if (world_policy >= 0) {
1680 n->type = KDBUS_ITEM_POLICY_ACCESS;
1681 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1682 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1683 n->policy_access.access = bus_kernel_translate_access(world_policy);
1688 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1689 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1690 hello->pool_size = KDBUS_POOL_SIZE;
1691 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
1692 hello->attach_flags_recv = _KDBUS_ATTACH_ANY;
1694 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1697 /* The higher 32bit of the bus_flags fields are considered
1698 * 'incompatible flags'. Refuse them all for now. */
1699 if (hello->bus_flags > 0xFFFFFFFFULL)
1702 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
1708 int bus_kernel_try_close(sd_bus *bus) {
1710 assert(bus->is_kernel);
1712 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1718 int bus_kernel_drop_one(int fd) {
1719 struct kdbus_cmd_recv recv = {
1720 .flags = KDBUS_RECV_DROP
1725 if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0)
1731 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1732 struct kdbus_cmd_update *update;
1733 struct kdbus_item *n;
1736 assert(bus->is_kernel);
1738 update = alloca0_align(offsetof(struct kdbus_cmd_update, items) +
1739 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1743 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1744 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1745 n->data64[0] = bus->attach_flags;
1748 offsetof(struct kdbus_cmd_update, items) +
1751 if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0)