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 bus_message_set_sender_driver(sd_bus *bus, sd_bus_message *m) {
355 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
356 m->creds.well_known_names_driver = true;
357 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
360 static void unset_memfds(struct sd_bus_message *m) {
361 struct bus_body_part *part;
366 /* Make sure the memfds are not freed twice */
367 MESSAGE_FOREACH_PART(part, i, m)
368 if (part->memfd >= 0)
372 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
373 sd_bus_message *m = NULL;
374 struct kdbus_item *d;
376 _cleanup_free_ int *fds = NULL;
377 struct bus_header *h = NULL;
378 size_t total, n_bytes = 0, idx = 0;
379 const char *destination = NULL, *seclabel = NULL;
384 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
386 KDBUS_ITEM_FOREACH(d, k, items) {
389 l = d->size - offsetof(struct kdbus_item, data);
393 case KDBUS_ITEM_PAYLOAD_OFF:
395 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
397 if (!bus_header_is_complete(h, d->vec.size))
401 n_bytes += d->vec.size;
404 case KDBUS_ITEM_PAYLOAD_MEMFD:
408 n_bytes += d->memfd.size;
411 case KDBUS_ITEM_FDS: {
416 f = realloc(fds, sizeof(int) * (n_fds + j));
421 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
426 case KDBUS_ITEM_SECLABEL:
435 r = bus_header_message_size(h, &total);
439 if (n_bytes != total)
442 /* on kdbus we only speak native endian gvariant, never dbus1
443 * marshalling or reverse endian */
444 if (h->version != 2 ||
445 h->endian != BUS_NATIVE_ENDIAN)
448 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
452 /* The well-known names list is different from the other
453 credentials. If we asked for it, but nothing is there, this
454 means that the list of well-known names is simply empty, not
455 that we lack any data */
457 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
459 KDBUS_ITEM_FOREACH(d, k, items) {
462 l = d->size - offsetof(struct kdbus_item, data);
466 case KDBUS_ITEM_PAYLOAD_OFF: {
469 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
471 if (idx + d->vec.size > begin_body) {
472 struct bus_body_part *part;
474 /* Contains body material */
476 part = message_append_part(m);
482 /* A -1 offset is NUL padding. */
483 part->is_zero = d->vec.offset == ~0ULL;
485 if (idx >= begin_body) {
487 part->data = (uint8_t *)k + d->vec.offset;
488 part->size = d->vec.size;
491 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
492 part->size = d->vec.size - (begin_body - idx);
502 case KDBUS_ITEM_PAYLOAD_MEMFD: {
503 struct bus_body_part *part;
505 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
510 part = message_append_part(m);
516 part->memfd = d->memfd.fd;
517 part->size = d->memfd.size;
520 idx += d->memfd.size;
524 case KDBUS_ITEM_PIDS:
526 /* The PID starttime/TID might be missing,
527 * when the data is faked by some data bus
528 * proxy and it lacks that information about
529 * the real client since SO_PEERCRED is used
532 if (d->pids.pid > 0) {
533 m->creds.pid = (pid_t) d->pids.pid;
534 m->creds.mask |= SD_BUS_CREDS_PID & bus->creds_mask;
537 if (d->pids.starttime > 0) {
538 m->creds.pid_starttime = d->pids.starttime / NSEC_PER_USEC;
539 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
542 if (d->pids.tid > 0) {
543 m->creds.tid = (pid_t) d->pids.tid;
544 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
549 case KDBUS_ITEM_CREDS:
551 /* EUID/SUID/FSUID/EGID/SGID/FSGID might be missing too (see above). */
553 if ((uid_t) d->creds.uid != (uid_t) -1) {
554 m->creds.uid = (uid_t) d->creds.uid;
555 m->creds.mask |= SD_BUS_CREDS_UID & bus->creds_mask;
558 if ((uid_t) d->creds.euid != (uid_t) -1) {
559 m->creds.euid = (uid_t) d->creds.euid;
560 m->creds.mask |= SD_BUS_CREDS_EUID & bus->creds_mask;
563 if ((uid_t) d->creds.suid != (uid_t) -1) {
564 m->creds.suid = (uid_t) d->creds.suid;
565 m->creds.mask |= SD_BUS_CREDS_SUID & bus->creds_mask;
568 if ((uid_t) d->creds.fsuid != (uid_t) -1) {
569 m->creds.fsuid = (uid_t) d->creds.fsuid;
570 m->creds.mask |= SD_BUS_CREDS_FSUID & bus->creds_mask;
573 if ((gid_t) d->creds.gid != (gid_t) -1) {
574 m->creds.gid = (gid_t) d->creds.gid;
575 m->creds.mask |= SD_BUS_CREDS_GID & bus->creds_mask;
578 if ((gid_t) d->creds.egid != (gid_t) -1) {
579 m->creds.egid = (gid_t) d->creds.egid;
580 m->creds.mask |= SD_BUS_CREDS_EGID & bus->creds_mask;
583 if ((gid_t) d->creds.sgid != (gid_t) -1) {
584 m->creds.sgid = (gid_t) d->creds.sgid;
585 m->creds.mask |= SD_BUS_CREDS_SGID & bus->creds_mask;
588 if ((gid_t) d->creds.fsgid != (gid_t) -1) {
589 m->creds.fsgid = (gid_t) d->creds.fsgid;
590 m->creds.mask |= SD_BUS_CREDS_FSGID & bus->creds_mask;
595 case KDBUS_ITEM_TIMESTAMP:
597 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
598 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
599 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
600 m->seqnum = d->timestamp.seqnum;
605 case KDBUS_ITEM_PID_COMM:
606 m->creds.comm = d->str;
607 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
610 case KDBUS_ITEM_TID_COMM:
611 m->creds.tid_comm = d->str;
612 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
616 m->creds.exe = d->str;
617 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
620 case KDBUS_ITEM_CMDLINE:
621 m->creds.cmdline = d->str;
622 m->creds.cmdline_size = l;
623 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
626 case KDBUS_ITEM_CGROUP:
627 m->creds.cgroup = d->str;
628 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;
630 r = bus_get_root_path(bus);
634 m->creds.cgroup_root = bus->cgroup_root;
638 case KDBUS_ITEM_AUDIT:
639 if ((uint32_t) d->audit.sessionid != (uint32_t) -1) {
640 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
641 m->creds.mask |= SD_BUS_CREDS_AUDIT_SESSION_ID & bus->creds_mask;
644 if ((uid_t) d->audit.loginuid != (uid_t) -1) {
645 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
646 m->creds.mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID & bus->creds_mask;
650 case KDBUS_ITEM_CAPS:
651 m->creds.capability = (uint8_t *) d->caps.caps;
652 m->creds.capability_size = d->size - offsetof(struct kdbus_item, caps.caps);
653 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;
656 case KDBUS_ITEM_DST_NAME:
657 if (!service_name_is_valid(d->str)) {
662 destination = d->str;
665 case KDBUS_ITEM_OWNED_NAME:
666 if (!service_name_is_valid(d->name.name)) {
671 if (bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) {
675 /* We just extend the array here, but
676 * do not allocate the strings inside
677 * of it, instead we just point to our
678 * buffer directly. */
679 n = strv_length(m->creds.well_known_names);
680 wkn = realloc(m->creds.well_known_names, (n + 2) * sizeof(char*));
686 wkn[n] = d->name.name;
688 m->creds.well_known_names = wkn;
690 m->creds.mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES;
694 case KDBUS_ITEM_CONN_DESCRIPTION:
695 m->creds.description = d->str;
696 m->creds.mask |= SD_BUS_CREDS_DESCRIPTION & bus->creds_mask;
699 case KDBUS_ITEM_AUXGROUPS:
701 if (bus->creds_mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS) {
702 assert_cc(sizeof(gid_t) == sizeof(uint32_t));
704 m->creds.n_supplementary_gids = (d->size - offsetof(struct kdbus_item, data32)) / sizeof(uint32_t);
705 m->creds.supplementary_gids = (gid_t*) d->data32;
706 m->creds.mask |= SD_BUS_CREDS_SUPPLEMENTARY_GIDS;
712 case KDBUS_ITEM_SECLABEL:
716 log_debug("Got unknown field from kernel %llu", d->type);
720 /* If we requested the list of well-known names to be appended
721 * and the sender had none no item for it will be
722 * attached. However, this does *not* mean that we the kernel
723 * didn't want to provide this information to us. Hence, let's
724 * explicitly mark this information as available if it was
726 m->creds.mask |= bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES;
728 r = bus_message_parse_fields(m);
732 /* Refuse messages if kdbus and dbus1 cookie doesn't match up */
733 if ((uint64_t) m->header->serial != k->cookie) {
738 /* Refuse messages where the reply flag doesn't match up */
739 if (!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) != !!(k->flags & KDBUS_MSG_FLAGS_EXPECT_REPLY)) {
744 /* Refuse reply messages where the reply cookie doesn't match up */
745 if ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) && m->reply_cookie != k->cookie_reply) {
750 /* Refuse messages where the autostart flag doesn't match up */
751 if (!(m->header->flags & BUS_MESSAGE_NO_AUTO_START) != !(k->flags & KDBUS_MSG_FLAGS_NO_AUTO_START)) {
756 /* Override information from the user header with data from the kernel */
757 if (k->src_id == KDBUS_SRC_ID_KERNEL)
758 bus_message_set_sender_driver(bus, m);
760 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
761 m->sender = m->creds.unique_name = m->sender_buffer;
765 m->destination = destination;
766 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
767 m->destination = NULL;
768 else if (k->dst_id == KDBUS_DST_ID_NAME)
769 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
771 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
772 m->destination = m->destination_buffer;
775 /* We take possession of the kmsg struct now */
777 m->release_kdbus = true;
781 bus->rqueue[bus->rqueue_size++] = m;
787 sd_bus_message_unref(m);
792 int bus_kernel_take_fd(sd_bus *b) {
793 struct kdbus_cmd_hello *hello;
794 struct kdbus_item *item;
795 _cleanup_free_ char *g = NULL;
797 size_t l = 0, m = 0, sz;
807 if (b->description) {
808 g = bus_label_escape(b->description);
816 /* If no name is explicitly set, we'll include a hint
817 * indicating the library implementation, a hint which
818 * kind of bus this is and the thread name */
820 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
823 name = b->is_system ? "sd-system" :
824 b->is_user ? "sd-user" : "sd";
826 _cleanup_free_ char *e = NULL;
828 e = bus_label_escape(pr);
832 g = strappend(b->is_system ? "sd-system-" :
833 b->is_user ? "sd-user-" : "sd-",
841 b->description = bus_label_unescape(name);
848 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
849 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
851 if (b->fake_creds_valid)
852 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
854 if (b->fake_pids_valid)
855 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
858 l = strlen(b->fake_label);
859 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
862 hello = alloca0_align(sz, 8);
864 hello->flags = b->hello_flags;
865 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
866 hello->attach_flags_recv = b->attach_flags;
867 hello->pool_size = KDBUS_POOL_SIZE;
871 item->size = offsetof(struct kdbus_item, str) + m + 1;
872 item->type = KDBUS_ITEM_CONN_DESCRIPTION;
873 memcpy(item->str, name, m + 1);
874 item = KDBUS_ITEM_NEXT(item);
876 if (b->fake_creds_valid) {
877 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
878 item->type = KDBUS_ITEM_CREDS;
879 item->creds = b->fake_creds;
881 item = KDBUS_ITEM_NEXT(item);
884 if (b->fake_pids_valid) {
885 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
886 item->type = KDBUS_ITEM_PIDS;
887 item->pids = b->fake_pids;
889 item = KDBUS_ITEM_NEXT(item);
893 item->size = offsetof(struct kdbus_item, str) + l + 1;
894 item->type = KDBUS_ITEM_SECLABEL;
895 memcpy(item->str, b->fake_label, l+1);
898 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
902 if (!b->kdbus_buffer) {
903 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
904 if (b->kdbus_buffer == MAP_FAILED) {
905 b->kdbus_buffer = NULL;
910 /* The higher 32bit of the bus_flags fields are considered
911 * 'incompatible flags'. Refuse them all for now. */
912 if (hello->bus_flags > 0xFFFFFFFFULL)
915 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
918 b->bloom_size = (size_t) hello->bloom.size;
919 b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
921 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
924 b->unique_id = hello->id;
927 b->bus_client = true;
928 b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
929 b->message_version = 2;
930 b->message_endian = BUS_NATIVE_ENDIAN;
932 /* the kernel told us the UUID of the underlying bus */
933 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
935 return bus_start_running(b);
938 int bus_kernel_connect(sd_bus *b) {
940 assert(b->input_fd < 0);
941 assert(b->output_fd < 0);
947 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
951 b->output_fd = b->input_fd;
953 return bus_kernel_take_fd(b);
956 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
957 struct kdbus_cmd_free cmd = {};
958 struct kdbus_item *d;
963 cmd.offset = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
965 KDBUS_ITEM_FOREACH(d, k, items) {
967 if (d->type == KDBUS_ITEM_FDS)
968 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
969 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
970 safe_close(d->memfd.fd);
973 (void) ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
976 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
981 assert(bus->state == BUS_RUNNING);
983 /* If we can't deliver, we want room for the error message */
984 r = bus_rqueue_make_room(bus);
988 r = bus_message_setup_kmsg(bus, m);
992 /* If this is a synchronous method call, then let's tell the
993 * kernel, so that it can pass CPU time/scheduling to the
994 * destination for the time, if it wants to. If we
995 * synchronously wait for the result anyway, we won't need CPU
998 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
1000 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
1002 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1003 sd_bus_message *reply;
1005 if (errno == EAGAIN || errno == EINTR)
1007 else if (errno == ENXIO || errno == ESRCH) {
1009 /* ENXIO: unique name not known
1010 * ESRCH: well-known name not known */
1012 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1013 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
1015 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
1019 } else if (errno == EADDRNOTAVAIL) {
1021 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
1023 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1024 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
1026 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
1032 r = bus_message_new_synthetic_error(
1034 BUS_MESSAGE_COOKIE(m),
1041 r = bus_seal_synthetic_message(bus, reply);
1045 bus->rqueue[bus->rqueue_size++] = reply;
1047 } else if (hint_sync_call) {
1048 struct kdbus_msg *k;
1050 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
1053 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1055 r = bus_kernel_make_message(bus, k);
1057 close_kdbus_msg(bus, k);
1059 /* Anybody can send us invalid messages, let's just drop them. */
1060 if (r == -EBADMSG || r == -EPROTOTYPE)
1061 log_debug("Ignoring invalid message: %s", strerror(-r));
1066 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1067 close_kdbus_msg(bus, k);
1074 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
1075 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1080 r = sd_bus_message_new_signal(
1083 "/org/freedesktop/DBus",
1084 "org.freedesktop.DBus",
1085 "NameOwnerChanged");
1089 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1093 bus_message_set_sender_driver(bus, m);
1095 r = bus_seal_synthetic_message(bus, m);
1099 bus->rqueue[bus->rqueue_size++] = m;
1105 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1106 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1112 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1115 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1117 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1119 if (isempty(old_owner))
1124 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1126 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
1129 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1130 char owner[UNIQUE_NAME_MAX];
1136 sprintf(owner, ":1.%llu", d->id_change.id);
1138 return push_name_owner_changed(
1140 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1141 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
1144 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1145 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1152 r = bus_message_new_synthetic_error(
1155 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1156 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1157 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1162 bus_message_set_sender_driver(bus, m);
1164 r = bus_seal_synthetic_message(bus, m);
1168 bus->rqueue[bus->rqueue_size++] = m;
1174 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1175 struct kdbus_item *d, *found = NULL;
1177 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1178 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1179 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1180 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1182 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1183 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1185 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1186 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1191 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1193 KDBUS_ITEM_FOREACH(d, k, items) {
1194 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1199 log_debug("Got unknown field from kernel %llu", d->type);
1203 log_debug("Didn't find a kernel message to translate.");
1207 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1210 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1211 struct kdbus_cmd_recv recv = {};
1212 struct kdbus_msg *k;
1217 r = bus_rqueue_make_room(bus);
1221 if (hint_priority) {
1222 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1223 recv.priority = priority;
1226 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1228 if (errno == EAGAIN)
1231 if (errno == EOVERFLOW) {
1232 log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1239 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1240 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1241 r = bus_kernel_make_message(bus, k);
1243 /* Anybody can send us invalid messages, let's just drop them. */
1244 if (r == -EBADMSG || r == -EPROTOTYPE) {
1245 log_debug("Ignoring invalid message: %s", strerror(-r));
1249 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1250 r = bus_kernel_translate_message(bus, k);
1252 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1257 close_kdbus_msg(bus, k);
1259 return r < 0 ? r : 1;
1262 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1263 struct memfd_cache *c;
1270 if (!bus || !bus->is_kernel)
1273 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1275 if (bus->n_memfd_cache <= 0) {
1278 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1280 r = memfd_new(bus->description);
1290 c = &bus->memfd_cache[--bus->n_memfd_cache];
1293 assert(c->mapped == 0 || c->address);
1295 *address = c->address;
1296 *mapped = c->mapped;
1297 *allocated = c->allocated;
1300 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1305 static void close_and_munmap(int fd, void *address, size_t size) {
1307 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1312 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1313 struct memfd_cache *c;
1314 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1317 assert(mapped == 0 || address);
1319 if (!bus || !bus->is_kernel) {
1320 close_and_munmap(fd, address, mapped);
1324 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1326 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1327 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1329 close_and_munmap(fd, address, mapped);
1333 c = &bus->memfd_cache[bus->n_memfd_cache++];
1335 c->address = address;
1337 /* If overly long, let's return a bit to the OS */
1338 if (mapped > max_mapped) {
1339 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1340 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1341 c->mapped = c->allocated = max_mapped;
1344 c->allocated = allocated;
1347 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1350 void bus_kernel_flush_memfd(sd_bus *b) {
1355 for (i = 0; i < b->n_memfd_cache; i++)
1356 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1359 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1362 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1363 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1365 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1366 f |= KDBUS_NAME_REPLACE_EXISTING;
1368 if (flags & SD_BUS_NAME_QUEUE)
1369 f |= KDBUS_NAME_QUEUE;
1374 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1377 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1378 SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1379 m |= KDBUS_ATTACH_CREDS;
1381 if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1382 m |= KDBUS_ATTACH_PIDS;
1384 if (mask & SD_BUS_CREDS_COMM)
1385 m |= KDBUS_ATTACH_PID_COMM;
1387 if (mask & SD_BUS_CREDS_TID_COMM)
1388 m |= KDBUS_ATTACH_TID_COMM;
1390 if (mask & SD_BUS_CREDS_EXE)
1391 m |= KDBUS_ATTACH_EXE;
1393 if (mask & SD_BUS_CREDS_CMDLINE)
1394 m |= KDBUS_ATTACH_CMDLINE;
1396 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))
1397 m |= KDBUS_ATTACH_CGROUP;
1399 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1400 m |= KDBUS_ATTACH_CAPS;
1402 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1403 m |= KDBUS_ATTACH_SECLABEL;
1405 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1406 m |= KDBUS_ATTACH_AUDIT;
1408 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1409 m |= KDBUS_ATTACH_NAMES;
1411 if (mask & SD_BUS_CREDS_DESCRIPTION)
1412 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1414 if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1415 m |= KDBUS_ATTACH_AUXGROUPS;
1420 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1421 struct kdbus_cmd_make *make;
1422 struct kdbus_item *n;
1429 fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1434 make = alloca0_align(offsetof(struct kdbus_cmd_make, items) +
1435 ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1436 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1437 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1440 make->size = offsetof(struct kdbus_cmd_make, items);
1442 /* Set the bloom parameters */
1444 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1445 sizeof(struct kdbus_bloom_parameter);
1446 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1447 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1448 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1450 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1451 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1453 make->size += ALIGN8(n->size);
1455 /* The busses we create make no restrictions on what metadata
1456 * peers can read from incoming messages. */
1457 n = KDBUS_ITEM_NEXT(n);
1458 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1459 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1460 n->data64[0] = _KDBUS_ATTACH_ANY;
1461 make->size += ALIGN8(n->size);
1463 /* Set the a good name */
1464 n = KDBUS_ITEM_NEXT(n);
1465 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1466 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1467 n->type = KDBUS_ITEM_MAKE_NAME;
1468 make->size += ALIGN8(n->size);
1470 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1472 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1480 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1492 static int bus_kernel_translate_access(BusPolicyAccess access) {
1493 assert(access >= 0);
1494 assert(access < _BUS_POLICY_ACCESS_MAX);
1498 case BUS_POLICY_ACCESS_SEE:
1499 return KDBUS_POLICY_SEE;
1501 case BUS_POLICY_ACCESS_TALK:
1502 return KDBUS_POLICY_TALK;
1504 case BUS_POLICY_ACCESS_OWN:
1505 return KDBUS_POLICY_OWN;
1508 assert_not_reached("Unknown policy access");
1512 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1518 switch (policy->type) {
1520 case BUSNAME_POLICY_TYPE_USER: {
1521 const char *user = policy->name;
1524 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1528 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1529 item->policy_access.id = uid;
1533 case BUSNAME_POLICY_TYPE_GROUP: {
1534 const char *group = policy->name;
1537 r = get_group_creds(&group, &gid);
1541 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1542 item->policy_access.id = gid;
1547 assert_not_reached("Unknown policy type");
1550 item->policy_access.access = bus_kernel_translate_access(policy->access);
1555 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1562 len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1569 p = newa(char, len);
1571 sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1573 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1587 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1588 _cleanup_free_ char *path = NULL;
1589 struct kdbus_cmd_make *make;
1590 struct kdbus_item *n;
1594 fd = bus_kernel_open_bus_fd(bus_name, &path);
1598 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) +
1599 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1601 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1602 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1605 sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1606 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1607 n->type = KDBUS_ITEM_MAKE_NAME;
1608 make->size += ALIGN8(n->size);
1611 if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1619 p = strjoin(dirname(path), "/", name, NULL);
1631 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
1633 struct kdbus_cmd_update *update;
1634 struct kdbus_item *n;
1635 BusEndpointPolicy *po;
1640 size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
1642 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1643 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
1644 size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1647 update = alloca0_align(size, 8);
1648 update->size = size;
1652 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1653 n->type = KDBUS_ITEM_NAME;
1654 n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1;
1655 strcpy(n->str, po->name);
1656 n = KDBUS_ITEM_NEXT(n);
1658 n->type = KDBUS_ITEM_POLICY_ACCESS;
1659 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1661 n->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1662 n->policy_access.access = bus_kernel_translate_access(po->access);
1663 n->policy_access.id = uid;
1665 n = KDBUS_ITEM_NEXT(n);
1668 r = ioctl(fd, KDBUS_CMD_ENDPOINT_UPDATE, update);
1675 int bus_kernel_make_starter(
1680 BusNamePolicy *policy,
1681 BusPolicyAccess world_policy) {
1683 struct kdbus_cmd_hello *hello;
1684 struct kdbus_item *n;
1685 size_t policy_cnt = 0;
1693 LIST_FOREACH(policy, po, policy)
1696 if (world_policy >= 0)
1699 size = offsetof(struct kdbus_cmd_hello, items) +
1700 ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1701 policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1703 hello = alloca0_align(size, 8);
1706 strcpy(n->str, name);
1707 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1708 n->type = KDBUS_ITEM_NAME;
1709 n = KDBUS_ITEM_NEXT(n);
1711 LIST_FOREACH(policy, po, policy) {
1712 n->type = KDBUS_ITEM_POLICY_ACCESS;
1713 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1715 r = bus_kernel_translate_policy(po, n);
1719 n = KDBUS_ITEM_NEXT(n);
1722 if (world_policy >= 0) {
1723 n->type = KDBUS_ITEM_POLICY_ACCESS;
1724 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1725 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1726 n->policy_access.access = bus_kernel_translate_access(world_policy);
1731 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1732 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1733 hello->pool_size = KDBUS_POOL_SIZE;
1734 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
1735 hello->attach_flags_recv = _KDBUS_ATTACH_ANY;
1737 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1740 /* The higher 32bit of the bus_flags fields are considered
1741 * 'incompatible flags'. Refuse them all for now. */
1742 if (hello->bus_flags > 0xFFFFFFFFULL)
1745 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
1751 int bus_kernel_try_close(sd_bus *bus) {
1753 assert(bus->is_kernel);
1755 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1761 int bus_kernel_drop_one(int fd) {
1762 struct kdbus_cmd_recv recv = {
1763 .flags = KDBUS_RECV_DROP
1768 if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0)
1774 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1775 struct kdbus_cmd_update *update;
1776 struct kdbus_item *n;
1779 assert(bus->is_kernel);
1781 update = alloca0_align(offsetof(struct kdbus_cmd_update, items) +
1782 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1786 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1787 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1788 n->data64[0] = bus->attach_flags;
1791 offsetof(struct kdbus_cmd_update, items) +
1794 if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0)