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>
29 #include <sys/prctl.h>
34 #include "bus-internal.h"
35 #include "bus-message.h"
36 #include "bus-kernel.h"
37 #include "bus-bloom.h"
39 #include "bus-label.h"
40 #include "cgroup-util.h"
42 #define UNIQUE_NAME_MAX (3+DECIMAL_STR_MAX(uint64_t))
44 int bus_kernel_parse_unique_name(const char *s, uint64_t *id) {
50 if (!startswith(s, ":1."))
53 r = safe_atou64(s + 3, id);
60 static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) {
66 /* Note that p can be NULL, which encodes a region full of
67 * zeroes, which is useful to optimize certain padding
70 (*d)->size = offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec);
71 (*d)->type = KDBUS_ITEM_PAYLOAD_VEC;
72 (*d)->vec.address = PTR_TO_UINT64(p);
75 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
78 static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t sz) {
84 (*d)->size = offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd);
85 (*d)->type = KDBUS_ITEM_PAYLOAD_MEMFD;
86 (*d)->memfd.fd = memfd;
87 (*d)->memfd.size = sz;
89 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
92 static void append_destination(struct kdbus_item **d, const char *s, size_t length) {
98 (*d)->size = offsetof(struct kdbus_item, str) + length + 1;
99 (*d)->type = KDBUS_ITEM_DST_NAME;
100 memcpy((*d)->str, s, length + 1);
102 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
105 static struct kdbus_bloom_filter *append_bloom(struct kdbus_item **d, size_t length) {
106 struct kdbus_item *i;
112 i->size = offsetof(struct kdbus_item, bloom_filter) +
113 offsetof(struct kdbus_bloom_filter, data) +
115 i->type = KDBUS_ITEM_BLOOM_FILTER;
117 *d = (struct kdbus_item *) ((uint8_t*) i + i->size);
119 return &i->bloom_filter;
122 static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) {
128 (*d)->size = offsetof(struct kdbus_item, fds) + sizeof(int) * n_fds;
129 (*d)->type = KDBUS_ITEM_FDS;
130 memcpy((*d)->fds, fds, sizeof(int) * n_fds);
132 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
135 static int bus_message_setup_bloom(sd_bus_message *m, struct kdbus_bloom_filter *bloom) {
144 memzero(data, m->bus->bloom_size);
145 bloom->generation = 0;
147 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "message-type", bus_message_type_to_string(m->header->type));
150 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "interface", m->interface);
152 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "member", m->member);
154 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path", m->path);
155 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path);
156 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path, '/');
159 r = sd_bus_message_rewind(m, true);
163 for (i = 0; i < 64; i++) {
166 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
169 r = sd_bus_message_peek_type(m, &type, NULL);
173 if (type != SD_BUS_TYPE_STRING &&
174 type != SD_BUS_TYPE_OBJECT_PATH &&
175 type != SD_BUS_TYPE_SIGNATURE)
178 r = sd_bus_message_read_basic(m, type, &t);
182 e = stpcpy(buf, "arg");
184 *(e++) = '0' + (char) i;
186 *(e++) = '0' + (char) (i / 10);
187 *(e++) = '0' + (char) (i % 10);
191 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t);
193 strcpy(e, "-dot-prefix");
194 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t, '.');
195 strcpy(e, "-slash-prefix");
196 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t, '/');
202 static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
203 struct bus_body_part *part;
204 struct kdbus_item *d;
215 /* We put this together only once, if this message is reused
216 * we reuse the earlier-built version */
220 if (m->destination) {
221 r = bus_kernel_parse_unique_name(m->destination, &unique);
229 sz = offsetof(struct kdbus_msg, items);
231 assert_cc(ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec)) ==
232 ALIGN8(offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd)));
234 /* Add in fixed header, fields header and payload */
235 sz += (1 + m->n_body_parts) *
236 ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec));
238 /* Add space for bloom filter */
239 sz += ALIGN8(offsetof(struct kdbus_item, bloom_filter) +
240 offsetof(struct kdbus_bloom_filter, data) +
243 /* Add in well-known destination header */
245 dl = strlen(m->destination);
246 sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1);
249 /* Add space for unix fds */
251 sz += ALIGN8(offsetof(struct kdbus_item, fds) + sizeof(int)*m->n_fds);
253 m->kdbus = memalign(8, sz);
259 m->free_kdbus = true;
260 memzero(m->kdbus, sz);
263 ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) |
264 ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0);
267 m->destination ? unique : KDBUS_DST_ID_BROADCAST;
268 m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
269 m->kdbus->cookie = (uint64_t) m->header->serial;
270 m->kdbus->priority = m->priority;
272 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
273 m->kdbus->cookie_reply = m->reply_cookie;
275 m->kdbus->timeout_ns = m->timeout * NSEC_PER_USEC;
280 append_destination(&d, m->destination, dl);
282 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
284 MESSAGE_FOREACH_PART(part, i, m) {
286 /* If this is padding then simply send a
287 * vector with a NULL data pointer which the
288 * kernel will just pass through. This is the
289 * most efficient way to encode zeroes */
291 append_payload_vec(&d, NULL, part->size);
295 if (part->memfd >= 0 && part->sealed && m->destination) {
296 /* Try to send a memfd, if the part is
297 * sealed and this is not a broadcast. Since we can only */
299 append_payload_memfd(&d, part->memfd, part->size);
303 /* Otherwise, let's send a vector to the actual data.
304 * For that, we need to map it first. */
305 r = bus_body_part_map(part);
309 append_payload_vec(&d, part->data, part->size);
312 if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
313 struct kdbus_bloom_filter *bloom;
315 bloom = append_bloom(&d, m->bus->bloom_size);
316 r = bus_message_setup_bloom(m, bloom);
322 append_fds(&d, m->fds, m->n_fds);
324 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
325 assert(m->kdbus->size <= sz);
334 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
335 sd_bus_message *m = NULL;
336 struct kdbus_item *d;
338 _cleanup_free_ int *fds = NULL;
339 struct bus_header *h = NULL;
340 size_t total, n_bytes = 0, idx = 0;
341 const char *destination = NULL, *seclabel = NULL;
346 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
348 KDBUS_ITEM_FOREACH(d, k, items) {
351 l = d->size - offsetof(struct kdbus_item, data);
355 case KDBUS_ITEM_PAYLOAD_OFF:
357 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
359 if (!bus_header_is_complete(h, d->vec.size))
363 n_bytes += d->vec.size;
366 case KDBUS_ITEM_PAYLOAD_MEMFD:
370 n_bytes += d->memfd.size;
373 case KDBUS_ITEM_FDS: {
378 f = realloc(fds, sizeof(int) * (n_fds + j));
383 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
388 case KDBUS_ITEM_SECLABEL:
397 r = bus_header_message_size(h, &total);
401 if (n_bytes != total)
404 /* on kdbus we only speak native endian gvariant, never dbus1
405 * marshalling or reverse endian */
406 if (h->version != 2 ||
407 h->endian != BUS_NATIVE_ENDIAN)
410 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
414 /* The well-known names list is different from the other
415 credentials. If we asked for it, but nothing is there, this
416 means that the list of well-known names is simply empty, not
417 that we lack any data */
419 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
421 KDBUS_ITEM_FOREACH(d, k, items) {
424 l = d->size - offsetof(struct kdbus_item, data);
428 case KDBUS_ITEM_PAYLOAD_OFF: {
431 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
433 if (idx + d->vec.size > begin_body) {
434 struct bus_body_part *part;
436 /* Contains body material */
438 part = message_append_part(m);
444 /* A -1 offset is NUL padding. */
445 part->is_zero = d->vec.offset == ~0ULL;
447 if (idx >= begin_body) {
449 part->data = (uint8_t *)k + d->vec.offset;
450 part->size = d->vec.size;
453 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
454 part->size = d->vec.size - (begin_body - idx);
464 case KDBUS_ITEM_PAYLOAD_MEMFD: {
465 struct bus_body_part *part;
467 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
472 part = message_append_part(m);
478 part->memfd = d->memfd.fd;
479 part->size = d->memfd.size;
482 idx += d->memfd.size;
486 case KDBUS_ITEM_CREDS:
487 /* UID/GID/PID are always valid */
488 m->creds.uid = (uid_t) d->creds.uid;
489 m->creds.gid = (gid_t) d->creds.gid;
490 m->creds.pid = (pid_t) d->creds.pid;
491 m->creds.mask |= (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID) & bus->creds_mask;
493 /* The PID starttime/TID might be missing
494 * however, when the data is faked by some
495 * data bus proxy and it lacks that
496 * information about the real client since
497 * SO_PEERCRED is used for that */
499 if (d->creds.starttime > 0) {
500 m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
501 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
504 if (d->creds.tid > 0) {
505 m->creds.tid = (pid_t) d->creds.tid;
506 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
510 case KDBUS_ITEM_TIMESTAMP:
512 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
513 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
514 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
515 m->seqnum = d->timestamp.seqnum;
520 case KDBUS_ITEM_PID_COMM:
521 m->creds.comm = d->str;
522 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
525 case KDBUS_ITEM_TID_COMM:
526 m->creds.tid_comm = d->str;
527 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
531 m->creds.exe = d->str;
532 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
535 case KDBUS_ITEM_CMDLINE:
536 m->creds.cmdline = d->str;
537 m->creds.cmdline_size = l;
538 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
541 case KDBUS_ITEM_CGROUP:
542 m->creds.cgroup = d->str;
543 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;
545 if (!bus->cgroup_root) {
546 r = cg_get_root_path(&bus->cgroup_root);
551 m->creds.cgroup_root = bus->cgroup_root;
555 case KDBUS_ITEM_AUDIT:
556 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
557 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
558 m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
561 case KDBUS_ITEM_CAPS:
562 m->creds.capability = d->data;
563 m->creds.capability_size = l;
564 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;
567 case KDBUS_ITEM_DST_NAME:
568 if (!service_name_is_valid(d->str))
571 destination = d->str;
574 case KDBUS_ITEM_NAME:
575 if (!service_name_is_valid(d->name.name))
578 r = strv_extend(&m->creds.well_known_names, d->name.name);
583 case KDBUS_ITEM_CONN_NAME:
584 m->creds.conn_name = d->str;
585 m->creds.mask |= SD_BUS_CREDS_CONNECTION_NAME & bus->creds_mask;
589 case KDBUS_ITEM_SECLABEL:
593 log_debug("Got unknown field from kernel %llu", d->type);
597 r = bus_message_parse_fields(m);
601 /* Override information from the user header with data from the kernel */
602 if (k->src_id == KDBUS_SRC_ID_KERNEL)
603 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
605 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
606 m->sender = m->creds.unique_name = m->sender_buffer;
610 m->destination = destination;
611 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
612 m->destination = NULL;
613 else if (k->dst_id == KDBUS_DST_ID_NAME)
614 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
616 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
617 m->destination = m->destination_buffer;
620 /* We take possession of the kmsg struct now */
622 m->release_kdbus = true;
626 bus->rqueue[bus->rqueue_size++] = m;
632 struct bus_body_part *part;
635 /* Make sure the memfds are not freed twice */
636 MESSAGE_FOREACH_PART(part, i, m)
637 if (part->memfd >= 0)
640 sd_bus_message_unref(m);
646 int bus_kernel_take_fd(sd_bus *b) {
647 struct kdbus_cmd_hello *hello;
648 struct kdbus_item *item;
649 _cleanup_free_ char *g = NULL;
651 size_t l = 0, m = 0, sz;
661 if (b->connection_name) {
662 g = bus_label_escape(b->connection_name);
670 /* If no name is explicitly set, we'll include a hint
671 * indicating the library implementation, a hint which
672 * kind of bus this is and the thread name */
674 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
677 name = b->is_system ? "sd-system" :
678 b->is_user ? "sd-user" : "sd";
680 _cleanup_free_ char *e = NULL;
682 e = bus_label_escape(pr);
686 g = strappend(b->is_system ? "sd-system-" :
687 b->is_user ? "sd-user-" : "sd-",
695 b->connection_name = bus_label_unescape(name);
696 if (!b->connection_name)
702 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
703 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
705 if (b->fake_creds_valid)
706 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
709 l = strlen(b->fake_label);
710 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
715 hello->conn_flags = b->hello_flags;
716 hello->attach_flags = b->attach_flags;
717 hello->pool_size = KDBUS_POOL_SIZE;
721 item->size = offsetof(struct kdbus_item, str) + m + 1;
722 item->type = KDBUS_ITEM_CONN_NAME;
723 memcpy(item->str, name, m + 1);
724 item = KDBUS_ITEM_NEXT(item);
726 if (b->fake_creds_valid) {
727 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
728 item->type = KDBUS_ITEM_CREDS;
729 item->creds = b->fake_creds;
731 item = KDBUS_ITEM_NEXT(item);
735 item->size = offsetof(struct kdbus_item, str) + l + 1;
736 item->type = KDBUS_ITEM_SECLABEL;
737 memcpy(item->str, b->fake_label, l+1);
740 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
744 if (!b->kdbus_buffer) {
745 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
746 if (b->kdbus_buffer == MAP_FAILED) {
747 b->kdbus_buffer = NULL;
752 /* The higher 32bit of both flags fields are considered
753 * 'incompatible flags'. Refuse them all for now. */
754 if (hello->bus_flags > 0xFFFFFFFFULL ||
755 hello->conn_flags > 0xFFFFFFFFULL)
758 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
761 b->bloom_size = (size_t) hello->bloom.size;
762 b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
764 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
767 b->unique_id = hello->id;
770 b->bus_client = true;
771 b->can_fds = !!(hello->conn_flags & KDBUS_HELLO_ACCEPT_FD);
772 b->message_version = 2;
773 b->message_endian = BUS_NATIVE_ENDIAN;
775 /* the kernel told us the UUID of the underlying bus */
776 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
778 return bus_start_running(b);
781 int bus_kernel_connect(sd_bus *b) {
783 assert(b->input_fd < 0);
784 assert(b->output_fd < 0);
790 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
794 b->output_fd = b->input_fd;
796 return bus_kernel_take_fd(b);
799 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
801 struct kdbus_item *d;
806 off = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
807 ioctl(bus->input_fd, KDBUS_CMD_FREE, &off);
809 KDBUS_ITEM_FOREACH(d, k, items) {
811 if (d->type == KDBUS_ITEM_FDS)
812 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
813 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
814 safe_close(d->memfd.fd);
818 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
823 assert(bus->state == BUS_RUNNING);
825 /* If we can't deliver, we want room for the error message */
826 r = bus_rqueue_make_room(bus);
830 r = bus_message_setup_kmsg(bus, m);
834 /* If this is a synchronous method call, then let's tell the
835 * kernel, so that it can pass CPU time/scheduling to the
836 * destination for the time, if it wants to. If we
837 * synchronously wait for the result anyway, we won't need CPU
840 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
842 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
844 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
845 sd_bus_message *reply;
847 if (errno == EAGAIN || errno == EINTR)
849 else if (errno == ENXIO || errno == ESRCH) {
851 /* ENXIO: unique name not known
852 * ESRCH: well-known name not known */
854 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
855 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
857 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
861 } else if (errno == EADDRNOTAVAIL) {
863 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
865 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
866 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
868 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
874 r = bus_message_new_synthetic_error(
876 BUS_MESSAGE_COOKIE(m),
883 r = bus_seal_synthetic_message(bus, reply);
887 bus->rqueue[bus->rqueue_size++] = reply;
889 } else if (hint_sync_call) {
892 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
895 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
897 r = bus_kernel_make_message(bus, k);
899 close_kdbus_msg(bus, k);
901 /* Anybody can send us invalid messages, let's just drop them. */
902 if (r == -EBADMSG || r == -EPROTOTYPE)
903 log_debug("Ignoring invalid message: %s", strerror(-r));
908 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
909 close_kdbus_msg(bus, k);
916 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
917 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
922 r = sd_bus_message_new_signal(
925 "/org/freedesktop/DBus",
926 "org.freedesktop.DBus",
931 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
935 m->sender = "org.freedesktop.DBus";
937 r = bus_seal_synthetic_message(bus, m);
941 bus->rqueue[bus->rqueue_size++] = m;
947 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
948 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
954 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
957 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old.id);
959 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
961 if (isempty(old_owner))
966 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new.id);
968 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
971 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
972 char owner[UNIQUE_NAME_MAX];
978 sprintf(owner, ":1.%llu", d->id_change.id);
980 return push_name_owner_changed(
982 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
983 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
986 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
987 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
994 r = bus_message_new_synthetic_error(
997 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
998 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
999 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1004 m->sender = "org.freedesktop.DBus";
1006 r = bus_seal_synthetic_message(bus, m);
1010 bus->rqueue[bus->rqueue_size++] = m;
1016 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1017 struct kdbus_item *d, *found = NULL;
1019 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1020 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1021 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1022 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1024 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1025 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1027 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1028 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1033 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1035 KDBUS_ITEM_FOREACH(d, k, items) {
1036 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1041 log_debug("Got unknown field from kernel %llu", d->type);
1045 log_debug("Didn't find a kernel message to translate.");
1049 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1052 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1053 struct kdbus_cmd_recv recv = {};
1054 struct kdbus_msg *k;
1059 r = bus_rqueue_make_room(bus);
1063 if (hint_priority) {
1064 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1065 recv.priority = priority;
1068 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1070 if (errno == EAGAIN)
1076 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1077 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1078 r = bus_kernel_make_message(bus, k);
1080 /* Anybody can send us invalid messages, let's just drop them. */
1081 if (r == -EBADMSG || r == -EPROTOTYPE) {
1082 log_debug("Ignoring invalid message: %s", strerror(-r));
1086 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1087 r = bus_kernel_translate_message(bus, k);
1089 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1094 close_kdbus_msg(bus, k);
1096 return r < 0 ? r : 1;
1099 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1100 struct memfd_cache *c;
1107 if (!bus || !bus->is_kernel)
1110 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1112 if (bus->n_memfd_cache <= 0) {
1113 _cleanup_free_ char *g = NULL;
1114 struct kdbus_cmd_memfd_make *cmd;
1115 struct kdbus_item *item;
1119 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1121 assert(bus->connection_name);
1123 g = bus_label_escape(bus->connection_name);
1128 sz = ALIGN8(offsetof(struct kdbus_cmd_memfd_make, items)) +
1129 ALIGN8(offsetof(struct kdbus_item, str)) +
1135 item->size = ALIGN8(offsetof(struct kdbus_item, str)) + l + 1;
1136 item->type = KDBUS_ITEM_MEMFD_NAME;
1137 memcpy(item->str, g, l + 1);
1139 r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, cmd);
1149 c = &bus->memfd_cache[--bus->n_memfd_cache];
1152 assert(c->mapped == 0 || c->address);
1154 *address = c->address;
1155 *mapped = c->mapped;
1156 *allocated = c->allocated;
1159 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1164 static void close_and_munmap(int fd, void *address, size_t size) {
1166 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1171 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1172 struct memfd_cache *c;
1173 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1176 assert(mapped == 0 || address);
1178 if (!bus || !bus->is_kernel) {
1179 close_and_munmap(fd, address, mapped);
1183 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1185 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1186 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1188 close_and_munmap(fd, address, mapped);
1192 c = &bus->memfd_cache[bus->n_memfd_cache++];
1194 c->address = address;
1196 /* If overly long, let's return a bit to the OS */
1197 if (mapped > max_mapped) {
1198 assert_se(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &max_mapped) >= 0);
1199 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1200 c->mapped = c->allocated = max_mapped;
1203 c->allocated = allocated;
1206 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1209 void bus_kernel_flush_memfd(sd_bus *b) {
1214 for (i = 0; i < b->n_memfd_cache; i++)
1215 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1218 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1221 assert(kdbus_flags);
1223 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1224 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1226 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1227 f |= KDBUS_NAME_REPLACE_EXISTING;
1229 if (flags & SD_BUS_NAME_QUEUE)
1230 f |= KDBUS_NAME_QUEUE;
1236 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1241 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1242 m |= KDBUS_ATTACH_CREDS;
1244 if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1245 m |= KDBUS_ATTACH_COMM;
1247 if (mask & SD_BUS_CREDS_EXE)
1248 m |= KDBUS_ATTACH_EXE;
1250 if (mask & SD_BUS_CREDS_CMDLINE)
1251 m |= KDBUS_ATTACH_CMDLINE;
1253 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))
1254 m |= KDBUS_ATTACH_CGROUP;
1256 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1257 m |= KDBUS_ATTACH_CAPS;
1259 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1260 m |= KDBUS_ATTACH_SECLABEL;
1262 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1263 m |= KDBUS_ATTACH_AUDIT;
1265 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1266 m |= KDBUS_ATTACH_NAMES;
1268 if (mask & SD_BUS_CREDS_CONNECTION_NAME)
1269 m |= KDBUS_ATTACH_CONN_NAME;
1275 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1276 struct kdbus_cmd_make *make;
1277 struct kdbus_item *n;
1283 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1287 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1288 offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1289 offsetof(struct kdbus_item, str) +
1290 DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1));
1292 make->size = offsetof(struct kdbus_cmd_make, items);
1295 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1296 sizeof(struct kdbus_bloom_parameter);
1297 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1299 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1300 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1302 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1303 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1305 make->size += ALIGN8(n->size);
1307 n = KDBUS_ITEM_NEXT(n);
1308 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1309 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1310 n->type = KDBUS_ITEM_MAKE_NAME;
1311 make->size += ALIGN8(n->size);
1313 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1315 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1320 /* The higher 32bit of the flags field are considered
1321 * 'incompatible flags'. Refuse them all for now. */
1322 if (make->flags > 0xFFFFFFFFULL) {
1330 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1342 static int bus_kernel_translate_access(BusNamePolicyAccess access) {
1343 assert(access >= 0);
1344 assert(access < _BUSNAME_POLICY_ACCESS_MAX);
1348 case BUSNAME_POLICY_ACCESS_SEE:
1349 return KDBUS_POLICY_SEE;
1351 case BUSNAME_POLICY_ACCESS_TALK:
1352 return KDBUS_POLICY_TALK;
1354 case BUSNAME_POLICY_ACCESS_OWN:
1355 return KDBUS_POLICY_OWN;
1358 assert_not_reached("Unknown policy access");
1362 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1368 switch (policy->type) {
1370 case BUSNAME_POLICY_TYPE_USER: {
1371 const char *user = policy->name;
1374 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1378 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1379 item->policy_access.id = uid;
1383 case BUSNAME_POLICY_TYPE_GROUP: {
1384 const char *group = policy->name;
1387 r = get_group_creds(&group, &gid);
1391 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1392 item->policy_access.id = gid;
1397 assert_not_reached("Unknown policy type");
1400 item->policy_access.access = bus_kernel_translate_access(policy->access);
1405 int bus_kernel_open_bus_fd(const char *bus) {
1409 p = alloca(strlen("/dev/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1);
1410 sprintf(p, "/dev/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1412 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1419 int bus_kernel_make_starter(
1424 BusNamePolicy *policy,
1425 BusNamePolicyAccess world_policy) {
1427 struct kdbus_cmd_hello *hello;
1428 struct kdbus_item *n;
1429 size_t policy_cnt = 0;
1437 LIST_FOREACH(policy, po, policy)
1440 if (world_policy >= 0)
1443 size = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
1444 ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1445 policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1447 hello = alloca0(size);
1450 strcpy(n->str, name);
1451 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1452 n->type = KDBUS_ITEM_NAME;
1453 n = KDBUS_ITEM_NEXT(n);
1455 LIST_FOREACH(policy, po, policy) {
1456 n->type = KDBUS_ITEM_POLICY_ACCESS;
1457 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1459 r = bus_kernel_translate_policy(po, n);
1463 n = KDBUS_ITEM_NEXT(n);
1466 if (world_policy >= 0) {
1467 n->type = KDBUS_ITEM_POLICY_ACCESS;
1468 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1469 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1470 n->policy_access.access = bus_kernel_translate_access(world_policy);
1475 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1476 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1477 hello->pool_size = KDBUS_POOL_SIZE;
1478 hello->attach_flags = _KDBUS_ATTACH_ALL;
1480 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1483 /* The higher 32bit of both flags fields are considered
1484 * 'incompatible flags'. Refuse them all for now. */
1485 if (hello->bus_flags > 0xFFFFFFFFULL ||
1486 hello->conn_flags > 0xFFFFFFFFULL)
1489 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
1495 int bus_kernel_create_domain(const char *name, char **s) {
1496 struct kdbus_cmd_make *make;
1497 struct kdbus_item *n;
1503 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1507 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1508 offsetof(struct kdbus_item, str) +
1512 strcpy(n->str, name);
1513 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1514 n->type = KDBUS_ITEM_MAKE_NAME;
1516 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1517 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1519 if (ioctl(fd, KDBUS_CMD_DOMAIN_MAKE, make) < 0) {
1524 /* The higher 32bit of the flags field are considered
1525 * 'incompatible flags'. Refuse them all for now. */
1526 if (make->flags > 0xFFFFFFFFULL) {
1534 p = strappend("/dev/kdbus/domain/", name);
1546 int bus_kernel_create_monitor(const char *bus) {
1547 struct kdbus_cmd_hello *hello;
1552 fd = bus_kernel_open_bus_fd(bus);
1556 hello = alloca0(sizeof(struct kdbus_cmd_hello));
1557 hello->size = sizeof(struct kdbus_cmd_hello);
1558 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1559 hello->pool_size = KDBUS_POOL_SIZE;
1561 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1566 /* The higher 32bit of both flags fields are considered
1567 * 'incompatible flags'. Refuse them all for now. */
1568 if (hello->bus_flags > 0xFFFFFFFFULL ||
1569 hello->conn_flags > 0xFFFFFFFFULL) {
1577 int bus_kernel_try_close(sd_bus *bus) {
1579 assert(bus->is_kernel);
1581 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1587 int bus_kernel_drop_one(int fd) {
1588 struct kdbus_cmd_recv recv = {
1589 .flags = KDBUS_RECV_DROP
1594 if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0)