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 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
632 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
633 m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
636 case KDBUS_ITEM_CAPS:
637 m->creds.capability = (uint8_t *) d->caps.caps;
638 m->creds.capability_size = d->size - offsetof(struct kdbus_item, caps.caps);
639 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;
642 case KDBUS_ITEM_DST_NAME:
643 if (!service_name_is_valid(d->str))
646 destination = d->str;
649 case KDBUS_ITEM_OWNED_NAME:
650 if (!service_name_is_valid(d->name.name))
653 r = strv_extend(&m->creds.well_known_names, d->name.name);
658 case KDBUS_ITEM_CONN_DESCRIPTION:
659 m->creds.description = d->str;
660 m->creds.mask |= SD_BUS_CREDS_DESCRIPTION & bus->creds_mask;
664 case KDBUS_ITEM_SECLABEL:
668 log_debug("Got unknown field from kernel %llu", d->type);
672 r = bus_message_parse_fields(m);
676 /* Override information from the user header with data from the kernel */
677 if (k->src_id == KDBUS_SRC_ID_KERNEL)
678 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
680 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
681 m->sender = m->creds.unique_name = m->sender_buffer;
685 m->destination = destination;
686 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
687 m->destination = NULL;
688 else if (k->dst_id == KDBUS_DST_ID_NAME)
689 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
691 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
692 m->destination = m->destination_buffer;
695 /* We take possession of the kmsg struct now */
697 m->release_kdbus = true;
701 bus->rqueue[bus->rqueue_size++] = m;
707 sd_bus_message_unref(m);
712 int bus_kernel_take_fd(sd_bus *b) {
713 struct kdbus_cmd_hello *hello;
714 struct kdbus_item *item;
715 _cleanup_free_ char *g = NULL;
717 size_t l = 0, m = 0, sz;
727 if (b->description) {
728 g = bus_label_escape(b->description);
736 /* If no name is explicitly set, we'll include a hint
737 * indicating the library implementation, a hint which
738 * kind of bus this is and the thread name */
740 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
743 name = b->is_system ? "sd-system" :
744 b->is_user ? "sd-user" : "sd";
746 _cleanup_free_ char *e = NULL;
748 e = bus_label_escape(pr);
752 g = strappend(b->is_system ? "sd-system-" :
753 b->is_user ? "sd-user-" : "sd-",
761 b->description = bus_label_unescape(name);
768 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
769 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
771 if (b->fake_creds_valid)
772 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
774 if (b->fake_pids_valid)
775 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
778 l = strlen(b->fake_label);
779 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
782 hello = alloca0_align(sz, 8);
784 hello->flags = b->hello_flags;
785 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
786 hello->attach_flags_recv = b->attach_flags;
787 hello->pool_size = KDBUS_POOL_SIZE;
791 item->size = offsetof(struct kdbus_item, str) + m + 1;
792 item->type = KDBUS_ITEM_CONN_DESCRIPTION;
793 memcpy(item->str, name, m + 1);
794 item = KDBUS_ITEM_NEXT(item);
796 if (b->fake_creds_valid) {
797 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
798 item->type = KDBUS_ITEM_CREDS;
799 item->creds = b->fake_creds;
801 item = KDBUS_ITEM_NEXT(item);
804 if (b->fake_pids_valid) {
805 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
806 item->type = KDBUS_ITEM_PIDS;
807 item->pids = b->fake_pids;
809 item = KDBUS_ITEM_NEXT(item);
813 item->size = offsetof(struct kdbus_item, str) + l + 1;
814 item->type = KDBUS_ITEM_SECLABEL;
815 memcpy(item->str, b->fake_label, l+1);
818 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
822 if (!b->kdbus_buffer) {
823 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
824 if (b->kdbus_buffer == MAP_FAILED) {
825 b->kdbus_buffer = NULL;
830 /* The higher 32bit of the bus_flags fields are considered
831 * 'incompatible flags'. Refuse them all for now. */
832 if (hello->bus_flags > 0xFFFFFFFFULL)
835 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
838 b->bloom_size = (size_t) hello->bloom.size;
839 b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
841 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
844 b->unique_id = hello->id;
847 b->bus_client = true;
848 b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
849 b->message_version = 2;
850 b->message_endian = BUS_NATIVE_ENDIAN;
852 /* the kernel told us the UUID of the underlying bus */
853 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
855 return bus_start_running(b);
858 int bus_kernel_connect(sd_bus *b) {
860 assert(b->input_fd < 0);
861 assert(b->output_fd < 0);
867 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
871 b->output_fd = b->input_fd;
873 return bus_kernel_take_fd(b);
876 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
877 struct kdbus_cmd_free cmd;
878 struct kdbus_item *d;
884 cmd.offset = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
886 KDBUS_ITEM_FOREACH(d, k, items) {
888 if (d->type == KDBUS_ITEM_FDS)
889 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
890 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
891 safe_close(d->memfd.fd);
894 (void) ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
897 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
902 assert(bus->state == BUS_RUNNING);
904 /* If we can't deliver, we want room for the error message */
905 r = bus_rqueue_make_room(bus);
909 r = bus_message_setup_kmsg(bus, m);
913 /* If this is a synchronous method call, then let's tell the
914 * kernel, so that it can pass CPU time/scheduling to the
915 * destination for the time, if it wants to. If we
916 * synchronously wait for the result anyway, we won't need CPU
919 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
921 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
923 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
924 sd_bus_message *reply;
926 if (errno == EAGAIN || errno == EINTR)
928 else if (errno == ENXIO || errno == ESRCH) {
930 /* ENXIO: unique name not known
931 * ESRCH: well-known name not known */
933 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
934 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
936 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
940 } else if (errno == EADDRNOTAVAIL) {
942 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
944 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
945 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
947 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
953 r = bus_message_new_synthetic_error(
955 BUS_MESSAGE_COOKIE(m),
962 r = bus_seal_synthetic_message(bus, reply);
966 bus->rqueue[bus->rqueue_size++] = reply;
968 } else if (hint_sync_call) {
971 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
974 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
976 r = bus_kernel_make_message(bus, k);
978 close_kdbus_msg(bus, k);
980 /* Anybody can send us invalid messages, let's just drop them. */
981 if (r == -EBADMSG || r == -EPROTOTYPE)
982 log_debug("Ignoring invalid message: %s", strerror(-r));
987 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
988 close_kdbus_msg(bus, k);
995 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
996 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1001 r = sd_bus_message_new_signal(
1004 "/org/freedesktop/DBus",
1005 "org.freedesktop.DBus",
1006 "NameOwnerChanged");
1010 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1014 m->sender = "org.freedesktop.DBus";
1016 r = bus_seal_synthetic_message(bus, m);
1020 bus->rqueue[bus->rqueue_size++] = m;
1026 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1027 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1033 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1036 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1038 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1040 if (isempty(old_owner))
1045 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1047 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
1050 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1051 char owner[UNIQUE_NAME_MAX];
1057 sprintf(owner, ":1.%llu", d->id_change.id);
1059 return push_name_owner_changed(
1061 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1062 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
1065 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1066 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1073 r = bus_message_new_synthetic_error(
1076 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1077 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1078 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1083 m->sender = "org.freedesktop.DBus";
1085 r = bus_seal_synthetic_message(bus, m);
1089 bus->rqueue[bus->rqueue_size++] = m;
1095 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1096 struct kdbus_item *d, *found = NULL;
1098 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1099 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1100 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1101 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1103 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1104 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1106 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1107 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1112 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1114 KDBUS_ITEM_FOREACH(d, k, items) {
1115 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1120 log_debug("Got unknown field from kernel %llu", d->type);
1124 log_debug("Didn't find a kernel message to translate.");
1128 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1131 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1132 struct kdbus_cmd_recv recv = {};
1133 struct kdbus_msg *k;
1138 r = bus_rqueue_make_room(bus);
1142 if (hint_priority) {
1143 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1144 recv.priority = priority;
1147 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1149 if (errno == EAGAIN)
1155 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1156 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1157 r = bus_kernel_make_message(bus, k);
1159 /* Anybody can send us invalid messages, let's just drop them. */
1160 if (r == -EBADMSG || r == -EPROTOTYPE) {
1161 log_debug("Ignoring invalid message: %s", strerror(-r));
1165 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1166 r = bus_kernel_translate_message(bus, k);
1168 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1173 close_kdbus_msg(bus, k);
1175 return r < 0 ? r : 1;
1178 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1179 struct memfd_cache *c;
1186 if (!bus || !bus->is_kernel)
1189 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1191 if (bus->n_memfd_cache <= 0) {
1194 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1196 r = memfd_new(bus->description);
1206 c = &bus->memfd_cache[--bus->n_memfd_cache];
1209 assert(c->mapped == 0 || c->address);
1211 *address = c->address;
1212 *mapped = c->mapped;
1213 *allocated = c->allocated;
1216 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1221 static void close_and_munmap(int fd, void *address, size_t size) {
1223 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1228 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1229 struct memfd_cache *c;
1230 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1233 assert(mapped == 0 || address);
1235 if (!bus || !bus->is_kernel) {
1236 close_and_munmap(fd, address, mapped);
1240 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1242 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1243 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1245 close_and_munmap(fd, address, mapped);
1249 c = &bus->memfd_cache[bus->n_memfd_cache++];
1251 c->address = address;
1253 /* If overly long, let's return a bit to the OS */
1254 if (mapped > max_mapped) {
1255 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1256 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1257 c->mapped = c->allocated = max_mapped;
1260 c->allocated = allocated;
1263 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1266 void bus_kernel_flush_memfd(sd_bus *b) {
1271 for (i = 0; i < b->n_memfd_cache; i++)
1272 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1275 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1278 assert(kdbus_flags);
1280 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1281 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1283 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1284 f |= KDBUS_NAME_REPLACE_EXISTING;
1286 if (flags & SD_BUS_NAME_QUEUE)
1287 f |= KDBUS_NAME_QUEUE;
1293 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1298 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1299 SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1300 m |= KDBUS_ATTACH_CREDS;
1302 if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1303 m |= KDBUS_ATTACH_PIDS;
1305 if (mask & SD_BUS_CREDS_COMM)
1306 m |= KDBUS_ATTACH_PID_COMM;
1308 if (mask & SD_BUS_CREDS_TID_COMM)
1309 m |= KDBUS_ATTACH_TID_COMM;
1311 if (mask & SD_BUS_CREDS_EXE)
1312 m |= KDBUS_ATTACH_EXE;
1314 if (mask & SD_BUS_CREDS_CMDLINE)
1315 m |= KDBUS_ATTACH_CMDLINE;
1317 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))
1318 m |= KDBUS_ATTACH_CGROUP;
1320 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1321 m |= KDBUS_ATTACH_CAPS;
1323 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1324 m |= KDBUS_ATTACH_SECLABEL;
1326 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1327 m |= KDBUS_ATTACH_AUDIT;
1329 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1330 m |= KDBUS_ATTACH_NAMES;
1332 if (mask & SD_BUS_CREDS_DESCRIPTION)
1333 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1339 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1340 struct kdbus_cmd_make *make;
1341 struct kdbus_item *n;
1347 fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1351 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1352 offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1353 offsetof(struct kdbus_item, str) +
1354 DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1),
1357 make->size = offsetof(struct kdbus_cmd_make, items);
1360 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1361 sizeof(struct kdbus_bloom_parameter);
1362 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1364 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1365 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1367 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1368 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1370 make->size += ALIGN8(n->size);
1372 n = KDBUS_ITEM_NEXT(n);
1373 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1374 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1375 n->type = KDBUS_ITEM_MAKE_NAME;
1376 make->size += ALIGN8(n->size);
1378 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1380 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1388 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1400 static int bus_kernel_translate_access(BusPolicyAccess access) {
1401 assert(access >= 0);
1402 assert(access < _BUS_POLICY_ACCESS_MAX);
1406 case BUS_POLICY_ACCESS_SEE:
1407 return KDBUS_POLICY_SEE;
1409 case BUS_POLICY_ACCESS_TALK:
1410 return KDBUS_POLICY_TALK;
1412 case BUS_POLICY_ACCESS_OWN:
1413 return KDBUS_POLICY_OWN;
1416 assert_not_reached("Unknown policy access");
1420 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1426 switch (policy->type) {
1428 case BUSNAME_POLICY_TYPE_USER: {
1429 const char *user = policy->name;
1432 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1436 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1437 item->policy_access.id = uid;
1441 case BUSNAME_POLICY_TYPE_GROUP: {
1442 const char *group = policy->name;
1445 r = get_group_creds(&group, &gid);
1449 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1450 item->policy_access.id = gid;
1455 assert_not_reached("Unknown policy type");
1458 item->policy_access.access = bus_kernel_translate_access(policy->access);
1463 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1468 len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1477 sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1479 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1486 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1487 _cleanup_free_ char *path = NULL;
1488 struct kdbus_cmd_make *make;
1489 struct kdbus_item *n;
1493 fd = bus_kernel_open_bus_fd(bus_name, &path);
1497 size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1498 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(ep_name) + 1);
1500 make = alloca0_align(size, 8);
1502 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1506 n->type = KDBUS_ITEM_MAKE_NAME;
1507 n->size = offsetof(struct kdbus_item, str) + strlen(ep_name) + 1;
1508 strcpy(n->str, ep_name);
1510 if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1518 p = strjoin(dirname(path), "/", ep_name, NULL);
1530 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
1532 struct kdbus_cmd_update *update;
1533 struct kdbus_item *n;
1534 BusEndpointPolicy *po;
1539 size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
1541 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1542 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
1543 size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1546 update = alloca0_align(size, 8);
1547 update->size = size;
1551 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1552 n->type = KDBUS_ITEM_NAME;
1553 n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1;
1554 strcpy(n->str, po->name);
1555 n = KDBUS_ITEM_NEXT(n);
1557 n->type = KDBUS_ITEM_POLICY_ACCESS;
1558 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1560 n->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1561 n->policy_access.access = bus_kernel_translate_access(po->access);
1562 n->policy_access.id = uid;
1564 n = KDBUS_ITEM_NEXT(n);
1567 r = ioctl(fd, KDBUS_CMD_ENDPOINT_UPDATE, update);
1574 int bus_kernel_make_starter(
1579 BusNamePolicy *policy,
1580 BusPolicyAccess world_policy) {
1582 struct kdbus_cmd_hello *hello;
1583 struct kdbus_item *n;
1584 size_t policy_cnt = 0;
1592 LIST_FOREACH(policy, po, policy)
1595 if (world_policy >= 0)
1598 size = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
1599 ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1600 policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1602 hello = alloca0_align(size, 8);
1605 strcpy(n->str, name);
1606 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1607 n->type = KDBUS_ITEM_NAME;
1608 n = KDBUS_ITEM_NEXT(n);
1610 LIST_FOREACH(policy, po, policy) {
1611 n->type = KDBUS_ITEM_POLICY_ACCESS;
1612 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1614 r = bus_kernel_translate_policy(po, n);
1618 n = KDBUS_ITEM_NEXT(n);
1621 if (world_policy >= 0) {
1622 n->type = KDBUS_ITEM_POLICY_ACCESS;
1623 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1624 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1625 n->policy_access.access = bus_kernel_translate_access(world_policy);
1630 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1631 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1632 hello->pool_size = KDBUS_POOL_SIZE;
1633 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
1634 hello->attach_flags_recv = _KDBUS_ATTACH_ALL;
1636 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1639 /* The higher 32bit of the bus_flags fields are considered
1640 * 'incompatible flags'. Refuse them all for now. */
1641 if (hello->bus_flags > 0xFFFFFFFFULL)
1644 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
1650 int bus_kernel_try_close(sd_bus *bus) {
1652 assert(bus->is_kernel);
1654 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1660 int bus_kernel_drop_one(int fd) {
1661 struct kdbus_cmd_recv recv = {
1662 .flags = KDBUS_RECV_DROP
1667 if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0)