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 assert_se(clock_gettime(CLOCK_MONOTONIC_COARSE, &now) == 0);
279 m->kdbus->timeout_ns = now.tv_sec * NSEC_PER_SEC + now.tv_nsec +
280 m->timeout * NSEC_PER_USEC;
286 append_destination(&d, m->destination, dl);
288 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
290 MESSAGE_FOREACH_PART(part, i, m) {
292 /* If this is padding then simply send a
293 * vector with a NULL data pointer which the
294 * kernel will just pass through. This is the
295 * most efficient way to encode zeroes */
297 append_payload_vec(&d, NULL, part->size);
301 if (part->memfd >= 0 && part->sealed && m->destination) {
302 /* Try to send a memfd, if the part is
303 * sealed and this is not a broadcast. Since we can only */
305 append_payload_memfd(&d, part->memfd, part->size);
309 /* Otherwise, let's send a vector to the actual data.
310 * For that, we need to map it first. */
311 r = bus_body_part_map(part);
315 append_payload_vec(&d, part->data, part->size);
318 if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
319 struct kdbus_bloom_filter *bloom;
321 bloom = append_bloom(&d, m->bus->bloom_size);
322 r = bus_message_setup_bloom(m, bloom);
328 append_fds(&d, m->fds, m->n_fds);
330 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
331 assert(m->kdbus->size <= sz);
340 static void unset_memfds(struct sd_bus_message *m) {
341 struct bus_body_part *part;
346 /* Make sure the memfds are not freed twice */
347 MESSAGE_FOREACH_PART(part, i, m)
348 if (part->memfd >= 0)
352 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
353 sd_bus_message *m = NULL;
354 struct kdbus_item *d;
356 _cleanup_free_ int *fds = NULL;
357 struct bus_header *h = NULL;
358 size_t total, n_bytes = 0, idx = 0;
359 const char *destination = NULL, *seclabel = NULL;
364 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
366 KDBUS_ITEM_FOREACH(d, k, items) {
369 l = d->size - offsetof(struct kdbus_item, data);
373 case KDBUS_ITEM_PAYLOAD_OFF:
375 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
377 if (!bus_header_is_complete(h, d->vec.size))
381 n_bytes += d->vec.size;
384 case KDBUS_ITEM_PAYLOAD_MEMFD:
388 n_bytes += d->memfd.size;
391 case KDBUS_ITEM_FDS: {
396 f = realloc(fds, sizeof(int) * (n_fds + j));
401 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
406 case KDBUS_ITEM_SECLABEL:
415 r = bus_header_message_size(h, &total);
419 if (n_bytes != total)
422 /* on kdbus we only speak native endian gvariant, never dbus1
423 * marshalling or reverse endian */
424 if (h->version != 2 ||
425 h->endian != BUS_NATIVE_ENDIAN)
428 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
432 /* The well-known names list is different from the other
433 credentials. If we asked for it, but nothing is there, this
434 means that the list of well-known names is simply empty, not
435 that we lack any data */
437 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
439 KDBUS_ITEM_FOREACH(d, k, items) {
442 l = d->size - offsetof(struct kdbus_item, data);
446 case KDBUS_ITEM_PAYLOAD_OFF: {
449 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
451 if (idx + d->vec.size > begin_body) {
452 struct bus_body_part *part;
454 /* Contains body material */
456 part = message_append_part(m);
462 /* A -1 offset is NUL padding. */
463 part->is_zero = d->vec.offset == ~0ULL;
465 if (idx >= begin_body) {
467 part->data = (uint8_t *)k + d->vec.offset;
468 part->size = d->vec.size;
471 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
472 part->size = d->vec.size - (begin_body - idx);
482 case KDBUS_ITEM_PAYLOAD_MEMFD: {
483 struct bus_body_part *part;
485 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
490 part = message_append_part(m);
496 part->memfd = d->memfd.fd;
497 part->size = d->memfd.size;
500 idx += d->memfd.size;
504 case KDBUS_ITEM_CREDS:
505 /* UID/GID/PID are always valid */
506 m->creds.uid = (uid_t) d->creds.uid;
507 m->creds.gid = (gid_t) d->creds.gid;
508 m->creds.pid = (pid_t) d->creds.pid;
509 m->creds.mask |= (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID) & bus->creds_mask;
511 /* The PID starttime/TID might be missing
512 * however, when the data is faked by some
513 * data bus proxy and it lacks that
514 * information about the real client since
515 * SO_PEERCRED is used for that */
517 if (d->creds.starttime > 0) {
518 m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
519 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
522 if (d->creds.tid > 0) {
523 m->creds.tid = (pid_t) d->creds.tid;
524 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
528 case KDBUS_ITEM_TIMESTAMP:
530 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
531 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
532 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
533 m->seqnum = d->timestamp.seqnum;
538 case KDBUS_ITEM_PID_COMM:
539 m->creds.comm = d->str;
540 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
543 case KDBUS_ITEM_TID_COMM:
544 m->creds.tid_comm = d->str;
545 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
549 m->creds.exe = d->str;
550 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
553 case KDBUS_ITEM_CMDLINE:
554 m->creds.cmdline = d->str;
555 m->creds.cmdline_size = l;
556 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
559 case KDBUS_ITEM_CGROUP:
560 m->creds.cgroup = d->str;
561 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;
563 r = bus_get_root_path(bus);
567 m->creds.cgroup_root = bus->cgroup_root;
571 case KDBUS_ITEM_AUDIT:
572 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
573 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
574 m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
577 case KDBUS_ITEM_CAPS:
578 m->creds.capability = d->data;
579 m->creds.capability_size = l;
580 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;
583 case KDBUS_ITEM_DST_NAME:
584 if (!service_name_is_valid(d->str))
587 destination = d->str;
590 case KDBUS_ITEM_NAME:
591 if (!service_name_is_valid(d->name.name))
594 r = strv_extend(&m->creds.well_known_names, d->name.name);
599 case KDBUS_ITEM_CONN_NAME:
600 m->creds.conn_name = d->str;
601 m->creds.mask |= SD_BUS_CREDS_CONNECTION_NAME & bus->creds_mask;
605 case KDBUS_ITEM_SECLABEL:
609 log_debug("Got unknown field from kernel %llu", d->type);
613 r = bus_message_parse_fields(m);
617 /* Override information from the user header with data from the kernel */
618 if (k->src_id == KDBUS_SRC_ID_KERNEL)
619 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
621 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
622 m->sender = m->creds.unique_name = m->sender_buffer;
626 m->destination = destination;
627 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
628 m->destination = NULL;
629 else if (k->dst_id == KDBUS_DST_ID_NAME)
630 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
632 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
633 m->destination = m->destination_buffer;
636 /* We take possession of the kmsg struct now */
638 m->release_kdbus = true;
642 bus->rqueue[bus->rqueue_size++] = m;
648 sd_bus_message_unref(m);
653 int bus_kernel_take_fd(sd_bus *b) {
654 struct kdbus_cmd_hello *hello;
655 struct kdbus_item *item;
656 _cleanup_free_ char *g = NULL;
658 size_t l = 0, m = 0, sz;
668 if (b->connection_name) {
669 g = bus_label_escape(b->connection_name);
677 /* If no name is explicitly set, we'll include a hint
678 * indicating the library implementation, a hint which
679 * kind of bus this is and the thread name */
681 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
684 name = b->is_system ? "sd-system" :
685 b->is_user ? "sd-user" : "sd";
687 _cleanup_free_ char *e = NULL;
689 e = bus_label_escape(pr);
693 g = strappend(b->is_system ? "sd-system-" :
694 b->is_user ? "sd-user-" : "sd-",
702 b->connection_name = bus_label_unescape(name);
703 if (!b->connection_name)
709 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
710 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
712 if (b->fake_creds_valid)
713 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
716 l = strlen(b->fake_label);
717 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
720 hello = alloca0_align(sz, 8);
722 hello->flags = b->hello_flags;
723 hello->attach_flags = b->attach_flags;
724 hello->pool_size = KDBUS_POOL_SIZE;
728 item->size = offsetof(struct kdbus_item, str) + m + 1;
729 item->type = KDBUS_ITEM_CONN_NAME;
730 memcpy(item->str, name, m + 1);
731 item = KDBUS_ITEM_NEXT(item);
733 if (b->fake_creds_valid) {
734 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
735 item->type = KDBUS_ITEM_CREDS;
736 item->creds = b->fake_creds;
738 item = KDBUS_ITEM_NEXT(item);
742 item->size = offsetof(struct kdbus_item, str) + l + 1;
743 item->type = KDBUS_ITEM_SECLABEL;
744 memcpy(item->str, b->fake_label, l+1);
747 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
751 if (!b->kdbus_buffer) {
752 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
753 if (b->kdbus_buffer == MAP_FAILED) {
754 b->kdbus_buffer = NULL;
759 /* The higher 32bit of the bus_flags fields are considered
760 * 'incompatible flags'. Refuse them all for now. */
761 if (hello->bus_flags > 0xFFFFFFFFULL)
764 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
767 b->bloom_size = (size_t) hello->bloom.size;
768 b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
770 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
773 b->unique_id = hello->id;
776 b->bus_client = true;
777 b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
778 b->message_version = 2;
779 b->message_endian = BUS_NATIVE_ENDIAN;
781 /* the kernel told us the UUID of the underlying bus */
782 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
784 return bus_start_running(b);
787 int bus_kernel_connect(sd_bus *b) {
789 assert(b->input_fd < 0);
790 assert(b->output_fd < 0);
796 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
800 b->output_fd = b->input_fd;
802 return bus_kernel_take_fd(b);
805 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
806 struct kdbus_cmd_free cmd;
807 struct kdbus_item *d;
813 cmd.offset = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
815 KDBUS_ITEM_FOREACH(d, k, items) {
817 if (d->type == KDBUS_ITEM_FDS)
818 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
819 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
820 safe_close(d->memfd.fd);
823 (void) ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
826 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
831 assert(bus->state == BUS_RUNNING);
833 /* If we can't deliver, we want room for the error message */
834 r = bus_rqueue_make_room(bus);
838 r = bus_message_setup_kmsg(bus, m);
842 /* If this is a synchronous method call, then let's tell the
843 * kernel, so that it can pass CPU time/scheduling to the
844 * destination for the time, if it wants to. If we
845 * synchronously wait for the result anyway, we won't need CPU
848 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
850 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
852 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
853 sd_bus_message *reply;
855 if (errno == EAGAIN || errno == EINTR)
857 else if (errno == ENXIO || errno == ESRCH) {
859 /* ENXIO: unique name not known
860 * ESRCH: well-known name not known */
862 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
863 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
865 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
869 } else if (errno == EADDRNOTAVAIL) {
871 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
873 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
874 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
876 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
882 r = bus_message_new_synthetic_error(
884 BUS_MESSAGE_COOKIE(m),
891 r = bus_seal_synthetic_message(bus, reply);
895 bus->rqueue[bus->rqueue_size++] = reply;
897 } else if (hint_sync_call) {
900 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
903 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
905 r = bus_kernel_make_message(bus, k);
907 close_kdbus_msg(bus, k);
909 /* Anybody can send us invalid messages, let's just drop them. */
910 if (r == -EBADMSG || r == -EPROTOTYPE)
911 log_debug("Ignoring invalid message: %s", strerror(-r));
916 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
917 close_kdbus_msg(bus, k);
924 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
925 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
930 r = sd_bus_message_new_signal(
933 "/org/freedesktop/DBus",
934 "org.freedesktop.DBus",
939 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
943 m->sender = "org.freedesktop.DBus";
945 r = bus_seal_synthetic_message(bus, m);
949 bus->rqueue[bus->rqueue_size++] = m;
955 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
956 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
962 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
965 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
967 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
969 if (isempty(old_owner))
974 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
976 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
979 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
980 char owner[UNIQUE_NAME_MAX];
986 sprintf(owner, ":1.%llu", d->id_change.id);
988 return push_name_owner_changed(
990 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
991 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
994 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
995 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1002 r = bus_message_new_synthetic_error(
1005 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1006 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1007 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1012 m->sender = "org.freedesktop.DBus";
1014 r = bus_seal_synthetic_message(bus, m);
1018 bus->rqueue[bus->rqueue_size++] = m;
1024 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1025 struct kdbus_item *d, *found = NULL;
1027 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1028 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1029 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1030 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1032 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1033 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1035 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1036 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1041 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1043 KDBUS_ITEM_FOREACH(d, k, items) {
1044 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1049 log_debug("Got unknown field from kernel %llu", d->type);
1053 log_debug("Didn't find a kernel message to translate.");
1057 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1060 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1061 struct kdbus_cmd_recv recv = {};
1062 struct kdbus_msg *k;
1067 r = bus_rqueue_make_room(bus);
1071 if (hint_priority) {
1072 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1073 recv.priority = priority;
1076 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1078 if (errno == EAGAIN)
1084 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1085 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1086 r = bus_kernel_make_message(bus, k);
1088 /* Anybody can send us invalid messages, let's just drop them. */
1089 if (r == -EBADMSG || r == -EPROTOTYPE) {
1090 log_debug("Ignoring invalid message: %s", strerror(-r));
1094 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1095 r = bus_kernel_translate_message(bus, k);
1097 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1102 close_kdbus_msg(bus, k);
1104 return r < 0 ? r : 1;
1107 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1108 struct memfd_cache *c;
1115 if (!bus || !bus->is_kernel)
1118 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1120 if (bus->n_memfd_cache <= 0) {
1121 _cleanup_free_ char *g = NULL;
1124 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1126 assert(bus->connection_name);
1128 g = bus_label_escape(bus->connection_name);
1132 r = memfd_create(g, MFD_ALLOW_SEALING);
1142 c = &bus->memfd_cache[--bus->n_memfd_cache];
1145 assert(c->mapped == 0 || c->address);
1147 *address = c->address;
1148 *mapped = c->mapped;
1149 *allocated = c->allocated;
1152 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1157 static void close_and_munmap(int fd, void *address, size_t size) {
1159 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1164 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1165 struct memfd_cache *c;
1166 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1169 assert(mapped == 0 || address);
1171 if (!bus || !bus->is_kernel) {
1172 close_and_munmap(fd, address, mapped);
1176 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1178 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1179 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1181 close_and_munmap(fd, address, mapped);
1185 c = &bus->memfd_cache[bus->n_memfd_cache++];
1187 c->address = address;
1189 /* If overly long, let's return a bit to the OS */
1190 if (mapped > max_mapped) {
1191 assert_se(ftruncate(fd, max_mapped) >= 0);
1192 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1193 c->mapped = c->allocated = max_mapped;
1196 c->allocated = allocated;
1199 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1202 void bus_kernel_flush_memfd(sd_bus *b) {
1207 for (i = 0; i < b->n_memfd_cache; i++)
1208 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1211 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1214 assert(kdbus_flags);
1216 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1217 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1219 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1220 f |= KDBUS_NAME_REPLACE_EXISTING;
1222 if (flags & SD_BUS_NAME_QUEUE)
1223 f |= KDBUS_NAME_QUEUE;
1229 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1234 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1235 m |= KDBUS_ATTACH_CREDS;
1237 if (mask & SD_BUS_CREDS_COMM)
1238 m |= KDBUS_ATTACH_PID_COMM;
1240 if (mask & SD_BUS_CREDS_TID_COMM)
1241 m |= KDBUS_ATTACH_TID_COMM;
1243 if (mask & SD_BUS_CREDS_EXE)
1244 m |= KDBUS_ATTACH_EXE;
1246 if (mask & SD_BUS_CREDS_CMDLINE)
1247 m |= KDBUS_ATTACH_CMDLINE;
1249 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))
1250 m |= KDBUS_ATTACH_CGROUP;
1252 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1253 m |= KDBUS_ATTACH_CAPS;
1255 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1256 m |= KDBUS_ATTACH_SECLABEL;
1258 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1259 m |= KDBUS_ATTACH_AUDIT;
1261 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1262 m |= KDBUS_ATTACH_NAMES;
1264 if (mask & SD_BUS_CREDS_CONNECTION_NAME)
1265 m |= KDBUS_ATTACH_CONN_NAME;
1271 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1272 struct kdbus_cmd_make *make;
1273 struct kdbus_item *n;
1279 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1283 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1284 offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1285 offsetof(struct kdbus_item, str) +
1286 DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1),
1289 make->size = offsetof(struct kdbus_cmd_make, items);
1292 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1293 sizeof(struct kdbus_bloom_parameter);
1294 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1296 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1297 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1299 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1300 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1302 make->size += ALIGN8(n->size);
1304 n = KDBUS_ITEM_NEXT(n);
1305 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1306 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1307 n->type = KDBUS_ITEM_MAKE_NAME;
1308 make->size += ALIGN8(n->size);
1310 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1312 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1320 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1332 static int bus_kernel_translate_access(BusPolicyAccess access) {
1333 assert(access >= 0);
1334 assert(access < _BUS_POLICY_ACCESS_MAX);
1338 case BUS_POLICY_ACCESS_SEE:
1339 return KDBUS_POLICY_SEE;
1341 case BUS_POLICY_ACCESS_TALK:
1342 return KDBUS_POLICY_TALK;
1344 case BUS_POLICY_ACCESS_OWN:
1345 return KDBUS_POLICY_OWN;
1348 assert_not_reached("Unknown policy access");
1352 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1358 switch (policy->type) {
1360 case BUSNAME_POLICY_TYPE_USER: {
1361 const char *user = policy->name;
1364 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1368 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1369 item->policy_access.id = uid;
1373 case BUSNAME_POLICY_TYPE_GROUP: {
1374 const char *group = policy->name;
1377 r = get_group_creds(&group, &gid);
1381 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1382 item->policy_access.id = gid;
1387 assert_not_reached("Unknown policy type");
1390 item->policy_access.access = bus_kernel_translate_access(policy->access);
1395 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1400 len = strlen("/dev/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1409 sprintf(p, "/dev/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1411 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1418 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1419 _cleanup_free_ char *path = NULL;
1420 struct kdbus_cmd_make *make;
1421 struct kdbus_item *n;
1425 fd = bus_kernel_open_bus_fd(bus_name, &path);
1429 size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1430 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(ep_name) + 1);
1432 make = alloca0_align(size, 8);
1434 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1438 n->type = KDBUS_ITEM_MAKE_NAME;
1439 n->size = offsetof(struct kdbus_item, str) + strlen(ep_name) + 1;
1440 strcpy(n->str, ep_name);
1442 if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1450 p = strjoin(dirname(path), "/", ep_name, NULL);
1462 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
1464 struct kdbus_cmd_update *update;
1465 struct kdbus_item *n;
1466 BusEndpointPolicy *po;
1471 size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
1473 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1474 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
1475 size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1478 update = alloca0_align(size, 8);
1479 update->size = size;
1483 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1484 n->type = KDBUS_ITEM_NAME;
1485 n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1;
1486 strcpy(n->str, po->name);
1487 n = KDBUS_ITEM_NEXT(n);
1489 n->type = KDBUS_ITEM_POLICY_ACCESS;
1490 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1492 n->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1493 n->policy_access.access = bus_kernel_translate_access(po->access);
1494 n->policy_access.id = uid;
1496 n = KDBUS_ITEM_NEXT(n);
1499 r = ioctl(fd, KDBUS_CMD_ENDPOINT_UPDATE, update);
1506 int bus_kernel_make_starter(
1511 BusNamePolicy *policy,
1512 BusPolicyAccess world_policy) {
1514 struct kdbus_cmd_hello *hello;
1515 struct kdbus_item *n;
1516 size_t policy_cnt = 0;
1524 LIST_FOREACH(policy, po, policy)
1527 if (world_policy >= 0)
1530 size = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
1531 ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1532 policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1534 hello = alloca0_align(size, 8);
1537 strcpy(n->str, name);
1538 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1539 n->type = KDBUS_ITEM_NAME;
1540 n = KDBUS_ITEM_NEXT(n);
1542 LIST_FOREACH(policy, po, policy) {
1543 n->type = KDBUS_ITEM_POLICY_ACCESS;
1544 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1546 r = bus_kernel_translate_policy(po, n);
1550 n = KDBUS_ITEM_NEXT(n);
1553 if (world_policy >= 0) {
1554 n->type = KDBUS_ITEM_POLICY_ACCESS;
1555 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1556 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1557 n->policy_access.access = bus_kernel_translate_access(world_policy);
1562 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1563 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1564 hello->pool_size = KDBUS_POOL_SIZE;
1565 hello->attach_flags = _KDBUS_ATTACH_ALL;
1567 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1570 /* The higher 32bit of the bus_flags fields are considered
1571 * 'incompatible flags'. Refuse them all for now. */
1572 if (hello->bus_flags > 0xFFFFFFFFULL)
1575 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
1581 int bus_kernel_create_domain(const char *name, char **s) {
1582 struct kdbus_cmd_make *make;
1583 struct kdbus_item *n;
1589 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1593 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1594 offsetof(struct kdbus_item, str) +
1599 strcpy(n->str, name);
1600 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1601 n->type = KDBUS_ITEM_MAKE_NAME;
1603 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1604 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1606 if (ioctl(fd, KDBUS_CMD_DOMAIN_MAKE, make) < 0) {
1611 /* The higher 32bit of the flags field are considered
1612 * 'incompatible flags'. Refuse them all for now. */
1613 if (make->flags > 0xFFFFFFFFULL) {
1621 p = strappend("/dev/kdbus/domain/", name);
1633 int bus_kernel_try_close(sd_bus *bus) {
1635 assert(bus->is_kernel);
1637 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1643 int bus_kernel_drop_one(int fd) {
1644 struct kdbus_cmd_recv recv = {
1645 .flags = KDBUS_RECV_DROP
1650 if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0)