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>
35 #include "bus-internal.h"
36 #include "bus-message.h"
37 #include "bus-kernel.h"
38 #include "bus-bloom.h"
40 #include "bus-label.h"
41 #include "cgroup-util.h"
43 #define UNIQUE_NAME_MAX (3+DECIMAL_STR_MAX(uint64_t))
45 int bus_kernel_parse_unique_name(const char *s, uint64_t *id) {
51 if (!startswith(s, ":1."))
54 r = safe_atou64(s + 3, id);
61 static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) {
67 /* Note that p can be NULL, which encodes a region full of
68 * zeroes, which is useful to optimize certain padding
71 (*d)->size = offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec);
72 (*d)->type = KDBUS_ITEM_PAYLOAD_VEC;
73 (*d)->vec.address = PTR_TO_UINT64(p);
76 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
79 static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t sz) {
85 (*d)->size = offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd);
86 (*d)->type = KDBUS_ITEM_PAYLOAD_MEMFD;
87 (*d)->memfd.fd = memfd;
88 (*d)->memfd.size = sz;
90 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
93 static void append_destination(struct kdbus_item **d, const char *s, size_t length) {
99 (*d)->size = offsetof(struct kdbus_item, str) + length + 1;
100 (*d)->type = KDBUS_ITEM_DST_NAME;
101 memcpy((*d)->str, s, length + 1);
103 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
106 static struct kdbus_bloom_filter *append_bloom(struct kdbus_item **d, size_t length) {
107 struct kdbus_item *i;
113 i->size = offsetof(struct kdbus_item, bloom_filter) +
114 offsetof(struct kdbus_bloom_filter, data) +
116 i->type = KDBUS_ITEM_BLOOM_FILTER;
118 *d = (struct kdbus_item *) ((uint8_t*) i + i->size);
120 return &i->bloom_filter;
123 static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) {
129 (*d)->size = offsetof(struct kdbus_item, fds) + sizeof(int) * n_fds;
130 (*d)->type = KDBUS_ITEM_FDS;
131 memcpy((*d)->fds, fds, sizeof(int) * n_fds);
133 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
136 static int bus_message_setup_bloom(sd_bus_message *m, struct kdbus_bloom_filter *bloom) {
145 memzero(data, m->bus->bloom_size);
146 bloom->generation = 0;
148 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "message-type", bus_message_type_to_string(m->header->type));
151 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "interface", m->interface);
153 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "member", m->member);
155 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path", m->path);
156 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path);
157 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path, '/');
160 r = sd_bus_message_rewind(m, true);
164 for (i = 0; i < 64; i++) {
167 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
170 r = sd_bus_message_peek_type(m, &type, NULL);
174 if (type != SD_BUS_TYPE_STRING &&
175 type != SD_BUS_TYPE_OBJECT_PATH &&
176 type != SD_BUS_TYPE_SIGNATURE)
179 r = sd_bus_message_read_basic(m, type, &t);
183 e = stpcpy(buf, "arg");
185 *(e++) = '0' + (char) i;
187 *(e++) = '0' + (char) (i / 10);
188 *(e++) = '0' + (char) (i % 10);
192 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t);
194 strcpy(e, "-dot-prefix");
195 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t, '.');
196 strcpy(e, "-slash-prefix");
197 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t, '/');
203 static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
204 struct bus_body_part *part;
205 struct kdbus_item *d;
216 /* We put this together only once, if this message is reused
217 * we reuse the earlier-built version */
221 if (m->destination) {
222 r = bus_kernel_parse_unique_name(m->destination, &unique);
230 sz = offsetof(struct kdbus_msg, items);
232 assert_cc(ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec)) ==
233 ALIGN8(offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd)));
235 /* Add in fixed header, fields header and payload */
236 sz += (1 + m->n_body_parts) *
237 ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec));
239 /* Add space for bloom filter */
240 sz += ALIGN8(offsetof(struct kdbus_item, bloom_filter) +
241 offsetof(struct kdbus_bloom_filter, data) +
244 /* Add in well-known destination header */
246 dl = strlen(m->destination);
247 sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1);
250 /* Add space for unix fds */
252 sz += ALIGN8(offsetof(struct kdbus_item, fds) + sizeof(int)*m->n_fds);
254 m->kdbus = memalign(8, sz);
260 m->free_kdbus = true;
261 memzero(m->kdbus, sz);
264 ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) |
265 ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0);
268 m->destination ? unique : KDBUS_DST_ID_BROADCAST;
269 m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
270 m->kdbus->cookie = (uint64_t) m->header->serial;
271 m->kdbus->priority = m->priority;
273 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) {
274 m->kdbus->cookie_reply = m->reply_cookie;
278 r = clock_gettime(CLOCK_MONOTONIC_COARSE, &now);
284 m->kdbus->timeout_ns = now.tv_sec * NSEC_PER_SEC + now.tv_nsec +
285 m->timeout * NSEC_PER_USEC;
291 append_destination(&d, m->destination, dl);
293 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
295 MESSAGE_FOREACH_PART(part, i, m) {
297 /* If this is padding then simply send a
298 * vector with a NULL data pointer which the
299 * kernel will just pass through. This is the
300 * most efficient way to encode zeroes */
302 append_payload_vec(&d, NULL, part->size);
306 if (part->memfd >= 0 && part->sealed && m->destination) {
307 /* Try to send a memfd, if the part is
308 * sealed and this is not a broadcast. Since we can only */
310 append_payload_memfd(&d, part->memfd, part->size);
314 /* Otherwise, let's send a vector to the actual data.
315 * For that, we need to map it first. */
316 r = bus_body_part_map(part);
320 append_payload_vec(&d, part->data, part->size);
323 if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
324 struct kdbus_bloom_filter *bloom;
326 bloom = append_bloom(&d, m->bus->bloom_size);
327 r = bus_message_setup_bloom(m, bloom);
333 append_fds(&d, m->fds, m->n_fds);
335 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
336 assert(m->kdbus->size <= sz);
345 static void unset_memfds(struct sd_bus_message *m) {
346 struct bus_body_part *part;
351 /* Make sure the memfds are not freed twice */
352 MESSAGE_FOREACH_PART(part, i, m)
353 if (part->memfd >= 0)
357 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
358 sd_bus_message *m = NULL;
359 struct kdbus_item *d;
361 _cleanup_free_ int *fds = NULL;
362 struct bus_header *h = NULL;
363 size_t total, n_bytes = 0, idx = 0;
364 const char *destination = NULL, *seclabel = NULL;
369 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
371 KDBUS_ITEM_FOREACH(d, k, items) {
374 l = d->size - offsetof(struct kdbus_item, data);
378 case KDBUS_ITEM_PAYLOAD_OFF:
380 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
382 if (!bus_header_is_complete(h, d->vec.size))
386 n_bytes += d->vec.size;
389 case KDBUS_ITEM_PAYLOAD_MEMFD:
393 n_bytes += d->memfd.size;
396 case KDBUS_ITEM_FDS: {
401 f = realloc(fds, sizeof(int) * (n_fds + j));
406 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
411 case KDBUS_ITEM_SECLABEL:
420 r = bus_header_message_size(h, &total);
424 if (n_bytes != total)
427 /* on kdbus we only speak native endian gvariant, never dbus1
428 * marshalling or reverse endian */
429 if (h->version != 2 ||
430 h->endian != BUS_NATIVE_ENDIAN)
433 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
437 /* The well-known names list is different from the other
438 credentials. If we asked for it, but nothing is there, this
439 means that the list of well-known names is simply empty, not
440 that we lack any data */
442 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
444 KDBUS_ITEM_FOREACH(d, k, items) {
447 l = d->size - offsetof(struct kdbus_item, data);
451 case KDBUS_ITEM_PAYLOAD_OFF: {
454 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
456 if (idx + d->vec.size > begin_body) {
457 struct bus_body_part *part;
459 /* Contains body material */
461 part = message_append_part(m);
467 /* A -1 offset is NUL padding. */
468 part->is_zero = d->vec.offset == ~0ULL;
470 if (idx >= begin_body) {
472 part->data = (uint8_t *)k + d->vec.offset;
473 part->size = d->vec.size;
476 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
477 part->size = d->vec.size - (begin_body - idx);
487 case KDBUS_ITEM_PAYLOAD_MEMFD: {
488 struct bus_body_part *part;
490 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
495 part = message_append_part(m);
501 part->memfd = d->memfd.fd;
502 part->size = d->memfd.size;
505 idx += d->memfd.size;
509 case KDBUS_ITEM_CREDS:
510 /* UID/GID/PID are always valid */
511 m->creds.uid = (uid_t) d->creds.uid;
512 m->creds.gid = (gid_t) d->creds.gid;
513 m->creds.pid = (pid_t) d->creds.pid;
514 m->creds.mask |= (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID) & bus->creds_mask;
516 /* The PID starttime/TID might be missing
517 * however, when the data is faked by some
518 * data bus proxy and it lacks that
519 * information about the real client since
520 * SO_PEERCRED is used for that */
522 if (d->creds.starttime > 0) {
523 m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
524 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
527 if (d->creds.tid > 0) {
528 m->creds.tid = (pid_t) d->creds.tid;
529 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
533 case KDBUS_ITEM_TIMESTAMP:
535 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
536 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
537 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
538 m->seqnum = d->timestamp.seqnum;
543 case KDBUS_ITEM_PID_COMM:
544 m->creds.comm = d->str;
545 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
548 case KDBUS_ITEM_TID_COMM:
549 m->creds.tid_comm = d->str;
550 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
554 m->creds.exe = d->str;
555 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
558 case KDBUS_ITEM_CMDLINE:
559 m->creds.cmdline = d->str;
560 m->creds.cmdline_size = l;
561 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
564 case KDBUS_ITEM_CGROUP:
565 m->creds.cgroup = d->str;
566 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;
568 r = bus_get_root_path(bus);
572 m->creds.cgroup_root = bus->cgroup_root;
576 case KDBUS_ITEM_AUDIT:
577 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
578 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
579 m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
582 case KDBUS_ITEM_CAPS:
583 m->creds.capability = d->data;
584 m->creds.capability_size = l;
585 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;
588 case KDBUS_ITEM_DST_NAME:
589 if (!service_name_is_valid(d->str))
592 destination = d->str;
595 case KDBUS_ITEM_NAME:
596 if (!service_name_is_valid(d->name.name))
599 r = strv_extend(&m->creds.well_known_names, d->name.name);
604 case KDBUS_ITEM_CONN_NAME:
605 m->creds.conn_name = d->str;
606 m->creds.mask |= SD_BUS_CREDS_CONNECTION_NAME & bus->creds_mask;
610 case KDBUS_ITEM_SECLABEL:
614 log_debug("Got unknown field from kernel %llu", d->type);
618 r = bus_message_parse_fields(m);
622 /* Override information from the user header with data from the kernel */
623 if (k->src_id == KDBUS_SRC_ID_KERNEL)
624 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
626 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
627 m->sender = m->creds.unique_name = m->sender_buffer;
631 m->destination = destination;
632 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
633 m->destination = NULL;
634 else if (k->dst_id == KDBUS_DST_ID_NAME)
635 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
637 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
638 m->destination = m->destination_buffer;
641 /* We take possession of the kmsg struct now */
643 m->release_kdbus = true;
647 bus->rqueue[bus->rqueue_size++] = m;
653 sd_bus_message_unref(m);
658 int bus_kernel_take_fd(sd_bus *b) {
659 struct kdbus_cmd_hello *hello;
660 struct kdbus_item *item;
661 _cleanup_free_ char *g = NULL;
663 size_t l = 0, m = 0, sz;
673 if (b->connection_name) {
674 g = bus_label_escape(b->connection_name);
682 /* If no name is explicitly set, we'll include a hint
683 * indicating the library implementation, a hint which
684 * kind of bus this is and the thread name */
686 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
689 name = b->is_system ? "sd-system" :
690 b->is_user ? "sd-user" : "sd";
692 _cleanup_free_ char *e = NULL;
694 e = bus_label_escape(pr);
698 g = strappend(b->is_system ? "sd-system-" :
699 b->is_user ? "sd-user-" : "sd-",
707 b->connection_name = bus_label_unescape(name);
708 if (!b->connection_name)
714 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
715 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
717 if (b->fake_creds_valid)
718 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
721 l = strlen(b->fake_label);
722 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
725 hello = alloca0_align(sz, 8);
727 hello->flags = b->hello_flags;
728 hello->attach_flags = b->attach_flags;
729 hello->pool_size = KDBUS_POOL_SIZE;
733 item->size = offsetof(struct kdbus_item, str) + m + 1;
734 item->type = KDBUS_ITEM_CONN_NAME;
735 memcpy(item->str, name, m + 1);
736 item = KDBUS_ITEM_NEXT(item);
738 if (b->fake_creds_valid) {
739 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
740 item->type = KDBUS_ITEM_CREDS;
741 item->creds = b->fake_creds;
743 item = KDBUS_ITEM_NEXT(item);
747 item->size = offsetof(struct kdbus_item, str) + l + 1;
748 item->type = KDBUS_ITEM_SECLABEL;
749 memcpy(item->str, b->fake_label, l+1);
752 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
756 if (!b->kdbus_buffer) {
757 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
758 if (b->kdbus_buffer == MAP_FAILED) {
759 b->kdbus_buffer = NULL;
764 /* The higher 32bit of the bus_flags fields are considered
765 * 'incompatible flags'. Refuse them all for now. */
766 if (hello->bus_flags > 0xFFFFFFFFULL)
769 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
772 b->bloom_size = (size_t) hello->bloom.size;
773 b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
775 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
778 b->unique_id = hello->id;
781 b->bus_client = true;
782 b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
783 b->message_version = 2;
784 b->message_endian = BUS_NATIVE_ENDIAN;
786 /* the kernel told us the UUID of the underlying bus */
787 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
789 return bus_start_running(b);
792 int bus_kernel_connect(sd_bus *b) {
794 assert(b->input_fd < 0);
795 assert(b->output_fd < 0);
801 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
805 b->output_fd = b->input_fd;
807 return bus_kernel_take_fd(b);
810 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
811 struct kdbus_cmd_free cmd;
812 struct kdbus_item *d;
818 cmd.offset = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
820 KDBUS_ITEM_FOREACH(d, k, items) {
822 if (d->type == KDBUS_ITEM_FDS)
823 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
824 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
825 safe_close(d->memfd.fd);
828 (void) ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
831 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
836 assert(bus->state == BUS_RUNNING);
838 /* If we can't deliver, we want room for the error message */
839 r = bus_rqueue_make_room(bus);
843 r = bus_message_setup_kmsg(bus, m);
847 /* If this is a synchronous method call, then let's tell the
848 * kernel, so that it can pass CPU time/scheduling to the
849 * destination for the time, if it wants to. If we
850 * synchronously wait for the result anyway, we won't need CPU
853 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
855 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
857 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
858 sd_bus_message *reply;
860 if (errno == EAGAIN || errno == EINTR)
862 else if (errno == ENXIO || errno == ESRCH) {
864 /* ENXIO: unique name not known
865 * ESRCH: well-known name not known */
867 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
868 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
870 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
874 } else if (errno == EADDRNOTAVAIL) {
876 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
878 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
879 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
881 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
887 r = bus_message_new_synthetic_error(
889 BUS_MESSAGE_COOKIE(m),
896 r = bus_seal_synthetic_message(bus, reply);
900 bus->rqueue[bus->rqueue_size++] = reply;
902 } else if (hint_sync_call) {
905 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
908 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
910 r = bus_kernel_make_message(bus, k);
912 close_kdbus_msg(bus, k);
914 /* Anybody can send us invalid messages, let's just drop them. */
915 if (r == -EBADMSG || r == -EPROTOTYPE)
916 log_debug("Ignoring invalid message: %s", strerror(-r));
921 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
922 close_kdbus_msg(bus, k);
929 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
930 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
935 r = sd_bus_message_new_signal(
938 "/org/freedesktop/DBus",
939 "org.freedesktop.DBus",
944 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
948 m->sender = "org.freedesktop.DBus";
950 r = bus_seal_synthetic_message(bus, m);
954 bus->rqueue[bus->rqueue_size++] = m;
960 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
961 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
967 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
970 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
972 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
974 if (isempty(old_owner))
979 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
981 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
984 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
985 char owner[UNIQUE_NAME_MAX];
991 sprintf(owner, ":1.%llu", d->id_change.id);
993 return push_name_owner_changed(
995 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
996 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
999 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1000 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1007 r = bus_message_new_synthetic_error(
1010 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1011 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1012 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1017 m->sender = "org.freedesktop.DBus";
1019 r = bus_seal_synthetic_message(bus, m);
1023 bus->rqueue[bus->rqueue_size++] = m;
1029 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1030 struct kdbus_item *d, *found = NULL;
1032 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1033 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1034 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1035 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1037 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1038 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1040 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1041 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1046 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1048 KDBUS_ITEM_FOREACH(d, k, items) {
1049 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1054 log_debug("Got unknown field from kernel %llu", d->type);
1058 log_debug("Didn't find a kernel message to translate.");
1062 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1065 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1066 struct kdbus_cmd_recv recv = {};
1067 struct kdbus_msg *k;
1072 r = bus_rqueue_make_room(bus);
1076 if (hint_priority) {
1077 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1078 recv.priority = priority;
1081 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1083 if (errno == EAGAIN)
1089 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1090 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1091 r = bus_kernel_make_message(bus, k);
1093 /* Anybody can send us invalid messages, let's just drop them. */
1094 if (r == -EBADMSG || r == -EPROTOTYPE) {
1095 log_debug("Ignoring invalid message: %s", strerror(-r));
1099 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1100 r = bus_kernel_translate_message(bus, k);
1102 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1107 close_kdbus_msg(bus, k);
1109 return r < 0 ? r : 1;
1112 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1113 struct memfd_cache *c;
1120 if (!bus || !bus->is_kernel)
1123 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1125 if (bus->n_memfd_cache <= 0) {
1126 _cleanup_free_ char *g = NULL;
1129 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1131 assert(bus->connection_name);
1133 g = bus_label_escape(bus->connection_name);
1137 r = memfd_create(g, MFD_ALLOW_SEALING);
1147 c = &bus->memfd_cache[--bus->n_memfd_cache];
1150 assert(c->mapped == 0 || c->address);
1152 *address = c->address;
1153 *mapped = c->mapped;
1154 *allocated = c->allocated;
1157 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1162 static void close_and_munmap(int fd, void *address, size_t size) {
1164 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1169 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1170 struct memfd_cache *c;
1171 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1174 assert(mapped == 0 || address);
1176 if (!bus || !bus->is_kernel) {
1177 close_and_munmap(fd, address, mapped);
1181 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1183 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1184 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1186 close_and_munmap(fd, address, mapped);
1190 c = &bus->memfd_cache[bus->n_memfd_cache++];
1192 c->address = address;
1194 /* If overly long, let's return a bit to the OS */
1195 if (mapped > max_mapped) {
1196 assert_se(ftruncate(fd, max_mapped) >= 0);
1197 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1198 c->mapped = c->allocated = max_mapped;
1201 c->allocated = allocated;
1204 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1207 void bus_kernel_flush_memfd(sd_bus *b) {
1212 for (i = 0; i < b->n_memfd_cache; i++)
1213 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1216 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1219 assert(kdbus_flags);
1221 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1222 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1224 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1225 f |= KDBUS_NAME_REPLACE_EXISTING;
1227 if (flags & SD_BUS_NAME_QUEUE)
1228 f |= KDBUS_NAME_QUEUE;
1234 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1239 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1240 m |= KDBUS_ATTACH_CREDS;
1242 if (mask & SD_BUS_CREDS_COMM)
1243 m |= KDBUS_ATTACH_PID_COMM;
1245 if (mask & SD_BUS_CREDS_TID_COMM)
1246 m |= KDBUS_ATTACH_TID_COMM;
1248 if (mask & SD_BUS_CREDS_EXE)
1249 m |= KDBUS_ATTACH_EXE;
1251 if (mask & SD_BUS_CREDS_CMDLINE)
1252 m |= KDBUS_ATTACH_CMDLINE;
1254 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))
1255 m |= KDBUS_ATTACH_CGROUP;
1257 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1258 m |= KDBUS_ATTACH_CAPS;
1260 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1261 m |= KDBUS_ATTACH_SECLABEL;
1263 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1264 m |= KDBUS_ATTACH_AUDIT;
1266 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1267 m |= KDBUS_ATTACH_NAMES;
1269 if (mask & SD_BUS_CREDS_CONNECTION_NAME)
1270 m |= KDBUS_ATTACH_CONN_NAME;
1276 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1277 struct kdbus_cmd_make *make;
1278 struct kdbus_item *n;
1284 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1288 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1289 offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1290 offsetof(struct kdbus_item, str) +
1291 DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1),
1294 make->size = offsetof(struct kdbus_cmd_make, items);
1297 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1298 sizeof(struct kdbus_bloom_parameter);
1299 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1301 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1302 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1304 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1305 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1307 make->size += ALIGN8(n->size);
1309 n = KDBUS_ITEM_NEXT(n);
1310 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1311 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1312 n->type = KDBUS_ITEM_MAKE_NAME;
1313 make->size += ALIGN8(n->size);
1315 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1317 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1325 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1337 static int bus_kernel_translate_access(BusPolicyAccess access) {
1338 assert(access >= 0);
1339 assert(access < _BUS_POLICY_ACCESS_MAX);
1343 case BUS_POLICY_ACCESS_SEE:
1344 return KDBUS_POLICY_SEE;
1346 case BUS_POLICY_ACCESS_TALK:
1347 return KDBUS_POLICY_TALK;
1349 case BUS_POLICY_ACCESS_OWN:
1350 return KDBUS_POLICY_OWN;
1353 assert_not_reached("Unknown policy access");
1357 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1363 switch (policy->type) {
1365 case BUSNAME_POLICY_TYPE_USER: {
1366 const char *user = policy->name;
1369 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1373 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1374 item->policy_access.id = uid;
1378 case BUSNAME_POLICY_TYPE_GROUP: {
1379 const char *group = policy->name;
1382 r = get_group_creds(&group, &gid);
1386 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1387 item->policy_access.id = gid;
1392 assert_not_reached("Unknown policy type");
1395 item->policy_access.access = bus_kernel_translate_access(policy->access);
1400 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1405 len = strlen("/dev/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1414 sprintf(p, "/dev/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1416 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1423 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1424 _cleanup_free_ char *path = NULL;
1425 struct kdbus_cmd_make *make;
1426 struct kdbus_item *n;
1430 fd = bus_kernel_open_bus_fd(bus_name, &path);
1434 size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1435 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(ep_name) + 1);
1437 make = alloca0_align(size, 8);
1439 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1443 n->type = KDBUS_ITEM_MAKE_NAME;
1444 n->size = offsetof(struct kdbus_item, str) + strlen(ep_name) + 1;
1445 strcpy(n->str, ep_name);
1447 if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1455 p = strjoin(dirname(path), "/", ep_name, NULL);
1467 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
1469 struct kdbus_cmd_update *update;
1470 struct kdbus_item *n;
1471 BusEndpointPolicy *po;
1476 size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
1478 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1479 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
1480 size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1483 update = alloca0_align(size, 8);
1484 update->size = size;
1488 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1489 n->type = KDBUS_ITEM_NAME;
1490 n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1;
1491 strcpy(n->str, po->name);
1492 n = KDBUS_ITEM_NEXT(n);
1494 n->type = KDBUS_ITEM_POLICY_ACCESS;
1495 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1497 n->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1498 n->policy_access.access = bus_kernel_translate_access(po->access);
1499 n->policy_access.id = uid;
1501 n = KDBUS_ITEM_NEXT(n);
1504 r = ioctl(fd, KDBUS_CMD_ENDPOINT_UPDATE, update);
1511 int bus_kernel_make_starter(
1516 BusNamePolicy *policy,
1517 BusPolicyAccess world_policy) {
1519 struct kdbus_cmd_hello *hello;
1520 struct kdbus_item *n;
1521 size_t policy_cnt = 0;
1529 LIST_FOREACH(policy, po, policy)
1532 if (world_policy >= 0)
1535 size = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
1536 ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1537 policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1539 hello = alloca0_align(size, 8);
1542 strcpy(n->str, name);
1543 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1544 n->type = KDBUS_ITEM_NAME;
1545 n = KDBUS_ITEM_NEXT(n);
1547 LIST_FOREACH(policy, po, policy) {
1548 n->type = KDBUS_ITEM_POLICY_ACCESS;
1549 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1551 r = bus_kernel_translate_policy(po, n);
1555 n = KDBUS_ITEM_NEXT(n);
1558 if (world_policy >= 0) {
1559 n->type = KDBUS_ITEM_POLICY_ACCESS;
1560 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1561 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1562 n->policy_access.access = bus_kernel_translate_access(world_policy);
1567 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1568 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1569 hello->pool_size = KDBUS_POOL_SIZE;
1570 hello->attach_flags = _KDBUS_ATTACH_ALL;
1572 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1575 /* The higher 32bit of the bus_flags fields are considered
1576 * 'incompatible flags'. Refuse them all for now. */
1577 if (hello->bus_flags > 0xFFFFFFFFULL)
1580 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
1586 int bus_kernel_create_domain(const char *name, char **s) {
1587 struct kdbus_cmd_make *make;
1588 struct kdbus_item *n;
1594 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1598 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1599 offsetof(struct kdbus_item, str) +
1604 strcpy(n->str, name);
1605 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1606 n->type = KDBUS_ITEM_MAKE_NAME;
1608 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1609 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1611 if (ioctl(fd, KDBUS_CMD_DOMAIN_MAKE, make) < 0) {
1616 /* The higher 32bit of the flags field are considered
1617 * 'incompatible flags'. Refuse them all for now. */
1618 if (make->flags > 0xFFFFFFFFULL) {
1626 p = strappend("/dev/kdbus/domain/", name);
1638 int bus_kernel_try_close(sd_bus *bus) {
1640 assert(bus->is_kernel);
1642 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1648 int bus_kernel_drop_one(int fd) {
1649 struct kdbus_cmd_recv recv = {
1650 .flags = KDBUS_RECV_DROP
1655 if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0)