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_CREDS:
517 /* UID/GID/PID are always valid */
518 m->creds.uid = (uid_t) d->creds.uid;
519 m->creds.gid = (gid_t) d->creds.gid;
520 m->creds.pid = (pid_t) d->creds.pid;
521 m->creds.mask |= (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID) & bus->creds_mask;
523 /* The PID starttime/TID might be missing
524 * however, when the data is faked by some
525 * data bus proxy and it lacks that
526 * information about the real client since
527 * SO_PEERCRED is used for that */
529 if (d->creds.starttime > 0) {
530 m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
531 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
534 if (d->creds.tid > 0) {
535 m->creds.tid = (pid_t) d->creds.tid;
536 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
540 case KDBUS_ITEM_TIMESTAMP:
542 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
543 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
544 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
545 m->seqnum = d->timestamp.seqnum;
550 case KDBUS_ITEM_PID_COMM:
551 m->creds.comm = d->str;
552 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
555 case KDBUS_ITEM_TID_COMM:
556 m->creds.tid_comm = d->str;
557 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
561 m->creds.exe = d->str;
562 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
565 case KDBUS_ITEM_CMDLINE:
566 m->creds.cmdline = d->str;
567 m->creds.cmdline_size = l;
568 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
571 case KDBUS_ITEM_CGROUP:
572 m->creds.cgroup = d->str;
573 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;
575 r = bus_get_root_path(bus);
579 m->creds.cgroup_root = bus->cgroup_root;
583 case KDBUS_ITEM_AUDIT:
584 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
585 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
586 m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
589 case KDBUS_ITEM_CAPS:
590 m->creds.capability = (uint8_t *) d->caps.caps;
591 m->creds.capability_size = d->size - offsetof(struct kdbus_item, caps.caps);
592 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;
595 case KDBUS_ITEM_DST_NAME:
596 if (!service_name_is_valid(d->str))
599 destination = d->str;
602 case KDBUS_ITEM_OWNED_NAME:
603 if (!service_name_is_valid(d->name.name))
606 r = strv_extend(&m->creds.well_known_names, d->name.name);
611 case KDBUS_ITEM_CONN_DESCRIPTION:
612 m->creds.description = d->str;
613 m->creds.mask |= SD_BUS_CREDS_DESCRIPTION & bus->creds_mask;
617 case KDBUS_ITEM_SECLABEL:
621 log_debug("Got unknown field from kernel %llu", d->type);
625 r = bus_message_parse_fields(m);
629 /* Override information from the user header with data from the kernel */
630 if (k->src_id == KDBUS_SRC_ID_KERNEL)
631 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
633 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
634 m->sender = m->creds.unique_name = m->sender_buffer;
638 m->destination = destination;
639 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
640 m->destination = NULL;
641 else if (k->dst_id == KDBUS_DST_ID_NAME)
642 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
644 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
645 m->destination = m->destination_buffer;
648 /* We take possession of the kmsg struct now */
650 m->release_kdbus = true;
654 bus->rqueue[bus->rqueue_size++] = m;
660 sd_bus_message_unref(m);
665 int bus_kernel_take_fd(sd_bus *b) {
666 struct kdbus_cmd_hello *hello;
667 struct kdbus_item *item;
668 _cleanup_free_ char *g = NULL;
670 size_t l = 0, m = 0, sz;
680 if (b->description) {
681 g = bus_label_escape(b->description);
689 /* If no name is explicitly set, we'll include a hint
690 * indicating the library implementation, a hint which
691 * kind of bus this is and the thread name */
693 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
696 name = b->is_system ? "sd-system" :
697 b->is_user ? "sd-user" : "sd";
699 _cleanup_free_ char *e = NULL;
701 e = bus_label_escape(pr);
705 g = strappend(b->is_system ? "sd-system-" :
706 b->is_user ? "sd-user-" : "sd-",
714 b->description = bus_label_unescape(name);
721 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
722 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
724 if (b->fake_creds_valid)
725 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
728 l = strlen(b->fake_label);
729 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
732 hello = alloca0_align(sz, 8);
734 hello->flags = b->hello_flags;
735 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
736 hello->attach_flags_recv = b->attach_flags;
737 hello->pool_size = KDBUS_POOL_SIZE;
741 item->size = offsetof(struct kdbus_item, str) + m + 1;
742 item->type = KDBUS_ITEM_CONN_DESCRIPTION;
743 memcpy(item->str, name, m + 1);
744 item = KDBUS_ITEM_NEXT(item);
746 if (b->fake_creds_valid) {
747 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
748 item->type = KDBUS_ITEM_CREDS;
749 item->creds = b->fake_creds;
751 item = KDBUS_ITEM_NEXT(item);
755 item->size = offsetof(struct kdbus_item, str) + l + 1;
756 item->type = KDBUS_ITEM_SECLABEL;
757 memcpy(item->str, b->fake_label, l+1);
760 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
764 if (!b->kdbus_buffer) {
765 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
766 if (b->kdbus_buffer == MAP_FAILED) {
767 b->kdbus_buffer = NULL;
772 /* The higher 32bit of the bus_flags fields are considered
773 * 'incompatible flags'. Refuse them all for now. */
774 if (hello->bus_flags > 0xFFFFFFFFULL)
777 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
780 b->bloom_size = (size_t) hello->bloom.size;
781 b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
783 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
786 b->unique_id = hello->id;
789 b->bus_client = true;
790 b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
791 b->message_version = 2;
792 b->message_endian = BUS_NATIVE_ENDIAN;
794 /* the kernel told us the UUID of the underlying bus */
795 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
797 return bus_start_running(b);
800 int bus_kernel_connect(sd_bus *b) {
802 assert(b->input_fd < 0);
803 assert(b->output_fd < 0);
809 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
813 b->output_fd = b->input_fd;
815 return bus_kernel_take_fd(b);
818 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
819 struct kdbus_cmd_free cmd;
820 struct kdbus_item *d;
826 cmd.offset = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
828 KDBUS_ITEM_FOREACH(d, k, items) {
830 if (d->type == KDBUS_ITEM_FDS)
831 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
832 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
833 safe_close(d->memfd.fd);
836 (void) ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
839 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
844 assert(bus->state == BUS_RUNNING);
846 /* If we can't deliver, we want room for the error message */
847 r = bus_rqueue_make_room(bus);
851 r = bus_message_setup_kmsg(bus, m);
855 /* If this is a synchronous method call, then let's tell the
856 * kernel, so that it can pass CPU time/scheduling to the
857 * destination for the time, if it wants to. If we
858 * synchronously wait for the result anyway, we won't need CPU
861 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
863 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
865 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
866 sd_bus_message *reply;
868 if (errno == EAGAIN || errno == EINTR)
870 else if (errno == ENXIO || errno == ESRCH) {
872 /* ENXIO: unique name not known
873 * ESRCH: well-known name not known */
875 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
876 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
878 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
882 } else if (errno == EADDRNOTAVAIL) {
884 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
886 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
887 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
889 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
895 r = bus_message_new_synthetic_error(
897 BUS_MESSAGE_COOKIE(m),
904 r = bus_seal_synthetic_message(bus, reply);
908 bus->rqueue[bus->rqueue_size++] = reply;
910 } else if (hint_sync_call) {
913 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
916 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
918 r = bus_kernel_make_message(bus, k);
920 close_kdbus_msg(bus, k);
922 /* Anybody can send us invalid messages, let's just drop them. */
923 if (r == -EBADMSG || r == -EPROTOTYPE)
924 log_debug("Ignoring invalid message: %s", strerror(-r));
929 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
930 close_kdbus_msg(bus, k);
937 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
938 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
943 r = sd_bus_message_new_signal(
946 "/org/freedesktop/DBus",
947 "org.freedesktop.DBus",
952 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
956 m->sender = "org.freedesktop.DBus";
958 r = bus_seal_synthetic_message(bus, m);
962 bus->rqueue[bus->rqueue_size++] = m;
968 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
969 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
975 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
978 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
980 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
982 if (isempty(old_owner))
987 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
989 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
992 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
993 char owner[UNIQUE_NAME_MAX];
999 sprintf(owner, ":1.%llu", d->id_change.id);
1001 return push_name_owner_changed(
1003 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1004 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
1007 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1008 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1015 r = bus_message_new_synthetic_error(
1018 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1019 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1020 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1025 m->sender = "org.freedesktop.DBus";
1027 r = bus_seal_synthetic_message(bus, m);
1031 bus->rqueue[bus->rqueue_size++] = m;
1037 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1038 struct kdbus_item *d, *found = NULL;
1040 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1041 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1042 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1043 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1045 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1046 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1048 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1049 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1054 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1056 KDBUS_ITEM_FOREACH(d, k, items) {
1057 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1062 log_debug("Got unknown field from kernel %llu", d->type);
1066 log_debug("Didn't find a kernel message to translate.");
1070 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1073 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1074 struct kdbus_cmd_recv recv = {};
1075 struct kdbus_msg *k;
1080 r = bus_rqueue_make_room(bus);
1084 if (hint_priority) {
1085 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1086 recv.priority = priority;
1089 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1091 if (errno == EAGAIN)
1097 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1098 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1099 r = bus_kernel_make_message(bus, k);
1101 /* Anybody can send us invalid messages, let's just drop them. */
1102 if (r == -EBADMSG || r == -EPROTOTYPE) {
1103 log_debug("Ignoring invalid message: %s", strerror(-r));
1107 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1108 r = bus_kernel_translate_message(bus, k);
1110 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1115 close_kdbus_msg(bus, k);
1117 return r < 0 ? r : 1;
1120 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1121 struct memfd_cache *c;
1128 if (!bus || !bus->is_kernel)
1131 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1133 if (bus->n_memfd_cache <= 0) {
1136 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1138 r = memfd_new(bus->description);
1148 c = &bus->memfd_cache[--bus->n_memfd_cache];
1151 assert(c->mapped == 0 || c->address);
1153 *address = c->address;
1154 *mapped = c->mapped;
1155 *allocated = c->allocated;
1158 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1163 static void close_and_munmap(int fd, void *address, size_t size) {
1165 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1170 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1171 struct memfd_cache *c;
1172 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1175 assert(mapped == 0 || address);
1177 if (!bus || !bus->is_kernel) {
1178 close_and_munmap(fd, address, mapped);
1182 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1184 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1185 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1187 close_and_munmap(fd, address, mapped);
1191 c = &bus->memfd_cache[bus->n_memfd_cache++];
1193 c->address = address;
1195 /* If overly long, let's return a bit to the OS */
1196 if (mapped > max_mapped) {
1197 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1198 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1199 c->mapped = c->allocated = max_mapped;
1202 c->allocated = allocated;
1205 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1208 void bus_kernel_flush_memfd(sd_bus *b) {
1213 for (i = 0; i < b->n_memfd_cache; i++)
1214 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1217 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1220 assert(kdbus_flags);
1222 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1223 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1225 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1226 f |= KDBUS_NAME_REPLACE_EXISTING;
1228 if (flags & SD_BUS_NAME_QUEUE)
1229 f |= KDBUS_NAME_QUEUE;
1235 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1240 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1241 m |= KDBUS_ATTACH_CREDS;
1243 if (mask & SD_BUS_CREDS_COMM)
1244 m |= KDBUS_ATTACH_PID_COMM;
1246 if (mask & SD_BUS_CREDS_TID_COMM)
1247 m |= KDBUS_ATTACH_TID_COMM;
1249 if (mask & SD_BUS_CREDS_EXE)
1250 m |= KDBUS_ATTACH_EXE;
1252 if (mask & SD_BUS_CREDS_CMDLINE)
1253 m |= KDBUS_ATTACH_CMDLINE;
1255 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))
1256 m |= KDBUS_ATTACH_CGROUP;
1258 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1259 m |= KDBUS_ATTACH_CAPS;
1261 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1262 m |= KDBUS_ATTACH_SECLABEL;
1264 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1265 m |= KDBUS_ATTACH_AUDIT;
1267 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1268 m |= KDBUS_ATTACH_NAMES;
1270 if (mask & SD_BUS_CREDS_DESCRIPTION)
1271 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1277 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1278 struct kdbus_cmd_make *make;
1279 struct kdbus_item *n;
1285 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1289 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1290 offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1291 offsetof(struct kdbus_item, str) +
1292 DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1),
1295 make->size = offsetof(struct kdbus_cmd_make, items);
1298 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1299 sizeof(struct kdbus_bloom_parameter);
1300 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1302 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1303 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1305 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1306 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1308 make->size += ALIGN8(n->size);
1310 n = KDBUS_ITEM_NEXT(n);
1311 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1312 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1313 n->type = KDBUS_ITEM_MAKE_NAME;
1314 make->size += ALIGN8(n->size);
1316 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1318 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1326 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1338 static int bus_kernel_translate_access(BusPolicyAccess access) {
1339 assert(access >= 0);
1340 assert(access < _BUS_POLICY_ACCESS_MAX);
1344 case BUS_POLICY_ACCESS_SEE:
1345 return KDBUS_POLICY_SEE;
1347 case BUS_POLICY_ACCESS_TALK:
1348 return KDBUS_POLICY_TALK;
1350 case BUS_POLICY_ACCESS_OWN:
1351 return KDBUS_POLICY_OWN;
1354 assert_not_reached("Unknown policy access");
1358 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1364 switch (policy->type) {
1366 case BUSNAME_POLICY_TYPE_USER: {
1367 const char *user = policy->name;
1370 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1374 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1375 item->policy_access.id = uid;
1379 case BUSNAME_POLICY_TYPE_GROUP: {
1380 const char *group = policy->name;
1383 r = get_group_creds(&group, &gid);
1387 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1388 item->policy_access.id = gid;
1393 assert_not_reached("Unknown policy type");
1396 item->policy_access.access = bus_kernel_translate_access(policy->access);
1401 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1406 len = strlen("/dev/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1415 sprintf(p, "/dev/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1417 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1424 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1425 _cleanup_free_ char *path = NULL;
1426 struct kdbus_cmd_make *make;
1427 struct kdbus_item *n;
1431 fd = bus_kernel_open_bus_fd(bus_name, &path);
1435 size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1436 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(ep_name) + 1);
1438 make = alloca0_align(size, 8);
1440 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1444 n->type = KDBUS_ITEM_MAKE_NAME;
1445 n->size = offsetof(struct kdbus_item, str) + strlen(ep_name) + 1;
1446 strcpy(n->str, ep_name);
1448 if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1456 p = strjoin(dirname(path), "/", ep_name, NULL);
1468 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
1470 struct kdbus_cmd_update *update;
1471 struct kdbus_item *n;
1472 BusEndpointPolicy *po;
1477 size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
1479 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1480 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
1481 size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1484 update = alloca0_align(size, 8);
1485 update->size = size;
1489 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1490 n->type = KDBUS_ITEM_NAME;
1491 n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1;
1492 strcpy(n->str, po->name);
1493 n = KDBUS_ITEM_NEXT(n);
1495 n->type = KDBUS_ITEM_POLICY_ACCESS;
1496 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1498 n->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1499 n->policy_access.access = bus_kernel_translate_access(po->access);
1500 n->policy_access.id = uid;
1502 n = KDBUS_ITEM_NEXT(n);
1505 r = ioctl(fd, KDBUS_CMD_ENDPOINT_UPDATE, update);
1512 int bus_kernel_make_starter(
1517 BusNamePolicy *policy,
1518 BusPolicyAccess world_policy) {
1520 struct kdbus_cmd_hello *hello;
1521 struct kdbus_item *n;
1522 size_t policy_cnt = 0;
1530 LIST_FOREACH(policy, po, policy)
1533 if (world_policy >= 0)
1536 size = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
1537 ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1538 policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1540 hello = alloca0_align(size, 8);
1543 strcpy(n->str, name);
1544 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1545 n->type = KDBUS_ITEM_NAME;
1546 n = KDBUS_ITEM_NEXT(n);
1548 LIST_FOREACH(policy, po, policy) {
1549 n->type = KDBUS_ITEM_POLICY_ACCESS;
1550 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1552 r = bus_kernel_translate_policy(po, n);
1556 n = KDBUS_ITEM_NEXT(n);
1559 if (world_policy >= 0) {
1560 n->type = KDBUS_ITEM_POLICY_ACCESS;
1561 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1562 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1563 n->policy_access.access = bus_kernel_translate_access(world_policy);
1568 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1569 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1570 hello->pool_size = KDBUS_POOL_SIZE;
1571 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
1572 hello->attach_flags_recv = _KDBUS_ATTACH_ALL;
1574 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1577 /* The higher 32bit of the bus_flags fields are considered
1578 * 'incompatible flags'. Refuse them all for now. */
1579 if (hello->bus_flags > 0xFFFFFFFFULL)
1582 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
1588 int bus_kernel_create_domain(const char *name, char **s) {
1589 struct kdbus_cmd_make *make;
1590 struct kdbus_item *n;
1596 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1600 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1601 offsetof(struct kdbus_item, str) +
1606 strcpy(n->str, name);
1607 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1608 n->type = KDBUS_ITEM_MAKE_NAME;
1610 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1611 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1613 if (ioctl(fd, KDBUS_CMD_DOMAIN_MAKE, make) < 0) {
1618 /* The higher 32bit of the flags field are considered
1619 * 'incompatible flags'. Refuse them all for now. */
1620 if (make->flags > 0xFFFFFFFFULL) {
1628 p = strappend("/dev/kdbus/domain/", name);
1640 int bus_kernel_try_close(sd_bus *bus) {
1642 assert(bus->is_kernel);
1644 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1650 int bus_kernel_drop_one(int fd) {
1651 struct kdbus_cmd_recv recv = {
1652 .flags = KDBUS_RECV_DROP
1657 if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0)