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;
276 m->kdbus->timeout_ns = m->timeout * NSEC_PER_USEC;
281 append_destination(&d, m->destination, dl);
283 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
285 MESSAGE_FOREACH_PART(part, i, m) {
287 /* If this is padding then simply send a
288 * vector with a NULL data pointer which the
289 * kernel will just pass through. This is the
290 * most efficient way to encode zeroes */
292 append_payload_vec(&d, NULL, part->size);
296 if (part->memfd >= 0 && part->sealed && m->destination) {
297 /* Try to send a memfd, if the part is
298 * sealed and this is not a broadcast. Since we can only */
300 append_payload_memfd(&d, part->memfd, part->size);
304 /* Otherwise, let's send a vector to the actual data.
305 * For that, we need to map it first. */
306 r = bus_body_part_map(part);
310 append_payload_vec(&d, part->data, part->size);
313 if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
314 struct kdbus_bloom_filter *bloom;
316 bloom = append_bloom(&d, m->bus->bloom_size);
317 r = bus_message_setup_bloom(m, bloom);
323 append_fds(&d, m->fds, m->n_fds);
325 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
326 assert(m->kdbus->size <= sz);
335 static void unset_memfds(struct sd_bus_message *m) {
336 struct bus_body_part *part;
341 /* Make sure the memfds are not freed twice */
342 MESSAGE_FOREACH_PART(part, i, m)
343 if (part->memfd >= 0)
347 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
348 sd_bus_message *m = NULL;
349 struct kdbus_item *d;
351 _cleanup_free_ int *fds = NULL;
352 struct bus_header *h = NULL;
353 size_t total, n_bytes = 0, idx = 0;
354 const char *destination = NULL, *seclabel = NULL;
359 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
361 KDBUS_ITEM_FOREACH(d, k, items) {
364 l = d->size - offsetof(struct kdbus_item, data);
368 case KDBUS_ITEM_PAYLOAD_OFF:
370 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
372 if (!bus_header_is_complete(h, d->vec.size))
376 n_bytes += d->vec.size;
379 case KDBUS_ITEM_PAYLOAD_MEMFD:
383 n_bytes += d->memfd.size;
386 case KDBUS_ITEM_FDS: {
391 f = realloc(fds, sizeof(int) * (n_fds + j));
396 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
401 case KDBUS_ITEM_SECLABEL:
410 r = bus_header_message_size(h, &total);
414 if (n_bytes != total)
417 /* on kdbus we only speak native endian gvariant, never dbus1
418 * marshalling or reverse endian */
419 if (h->version != 2 ||
420 h->endian != BUS_NATIVE_ENDIAN)
423 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
427 /* The well-known names list is different from the other
428 credentials. If we asked for it, but nothing is there, this
429 means that the list of well-known names is simply empty, not
430 that we lack any data */
432 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
434 KDBUS_ITEM_FOREACH(d, k, items) {
437 l = d->size - offsetof(struct kdbus_item, data);
441 case KDBUS_ITEM_PAYLOAD_OFF: {
444 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
446 if (idx + d->vec.size > begin_body) {
447 struct bus_body_part *part;
449 /* Contains body material */
451 part = message_append_part(m);
457 /* A -1 offset is NUL padding. */
458 part->is_zero = d->vec.offset == ~0ULL;
460 if (idx >= begin_body) {
462 part->data = (uint8_t *)k + d->vec.offset;
463 part->size = d->vec.size;
466 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
467 part->size = d->vec.size - (begin_body - idx);
477 case KDBUS_ITEM_PAYLOAD_MEMFD: {
478 struct bus_body_part *part;
480 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
485 part = message_append_part(m);
491 part->memfd = d->memfd.fd;
492 part->size = d->memfd.size;
495 idx += d->memfd.size;
499 case KDBUS_ITEM_CREDS:
500 /* UID/GID/PID are always valid */
501 m->creds.uid = (uid_t) d->creds.uid;
502 m->creds.gid = (gid_t) d->creds.gid;
503 m->creds.pid = (pid_t) d->creds.pid;
504 m->creds.mask |= (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID) & bus->creds_mask;
506 /* The PID starttime/TID might be missing
507 * however, when the data is faked by some
508 * data bus proxy and it lacks that
509 * information about the real client since
510 * SO_PEERCRED is used for that */
512 if (d->creds.starttime > 0) {
513 m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
514 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
517 if (d->creds.tid > 0) {
518 m->creds.tid = (pid_t) d->creds.tid;
519 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
523 case KDBUS_ITEM_TIMESTAMP:
525 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
526 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
527 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
528 m->seqnum = d->timestamp.seqnum;
533 case KDBUS_ITEM_PID_COMM:
534 m->creds.comm = d->str;
535 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
538 case KDBUS_ITEM_TID_COMM:
539 m->creds.tid_comm = d->str;
540 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
544 m->creds.exe = d->str;
545 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
548 case KDBUS_ITEM_CMDLINE:
549 m->creds.cmdline = d->str;
550 m->creds.cmdline_size = l;
551 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
554 case KDBUS_ITEM_CGROUP:
555 m->creds.cgroup = d->str;
556 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;
558 r = bus_get_root_path(bus);
562 m->creds.cgroup_root = bus->cgroup_root;
566 case KDBUS_ITEM_AUDIT:
567 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
568 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
569 m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
572 case KDBUS_ITEM_CAPS:
573 m->creds.capability = d->data;
574 m->creds.capability_size = l;
575 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;
578 case KDBUS_ITEM_DST_NAME:
579 if (!service_name_is_valid(d->str))
582 destination = d->str;
585 case KDBUS_ITEM_NAME:
586 if (!service_name_is_valid(d->name.name))
589 r = strv_extend(&m->creds.well_known_names, d->name.name);
594 case KDBUS_ITEM_CONN_NAME:
595 m->creds.conn_name = d->str;
596 m->creds.mask |= SD_BUS_CREDS_CONNECTION_NAME & bus->creds_mask;
600 case KDBUS_ITEM_SECLABEL:
604 log_debug("Got unknown field from kernel %llu", d->type);
608 r = bus_message_parse_fields(m);
612 /* Override information from the user header with data from the kernel */
613 if (k->src_id == KDBUS_SRC_ID_KERNEL)
614 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
616 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
617 m->sender = m->creds.unique_name = m->sender_buffer;
621 m->destination = destination;
622 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
623 m->destination = NULL;
624 else if (k->dst_id == KDBUS_DST_ID_NAME)
625 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
627 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
628 m->destination = m->destination_buffer;
631 /* We take possession of the kmsg struct now */
633 m->release_kdbus = true;
637 bus->rqueue[bus->rqueue_size++] = m;
643 sd_bus_message_unref(m);
648 int bus_kernel_take_fd(sd_bus *b) {
649 struct kdbus_cmd_hello *hello;
650 struct kdbus_item *item;
651 _cleanup_free_ char *g = NULL;
653 size_t l = 0, m = 0, sz;
663 if (b->connection_name) {
664 g = bus_label_escape(b->connection_name);
672 /* If no name is explicitly set, we'll include a hint
673 * indicating the library implementation, a hint which
674 * kind of bus this is and the thread name */
676 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
679 name = b->is_system ? "sd-system" :
680 b->is_user ? "sd-user" : "sd";
682 _cleanup_free_ char *e = NULL;
684 e = bus_label_escape(pr);
688 g = strappend(b->is_system ? "sd-system-" :
689 b->is_user ? "sd-user-" : "sd-",
697 b->connection_name = bus_label_unescape(name);
698 if (!b->connection_name)
704 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
705 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
707 if (b->fake_creds_valid)
708 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
711 l = strlen(b->fake_label);
712 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
715 hello = alloca0_align(sz, 8);
717 hello->conn_flags = b->hello_flags;
718 hello->attach_flags = b->attach_flags;
719 hello->pool_size = KDBUS_POOL_SIZE;
723 item->size = offsetof(struct kdbus_item, str) + m + 1;
724 item->type = KDBUS_ITEM_CONN_NAME;
725 memcpy(item->str, name, m + 1);
726 item = KDBUS_ITEM_NEXT(item);
728 if (b->fake_creds_valid) {
729 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
730 item->type = KDBUS_ITEM_CREDS;
731 item->creds = b->fake_creds;
733 item = KDBUS_ITEM_NEXT(item);
737 item->size = offsetof(struct kdbus_item, str) + l + 1;
738 item->type = KDBUS_ITEM_SECLABEL;
739 memcpy(item->str, b->fake_label, l+1);
742 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
746 if (!b->kdbus_buffer) {
747 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
748 if (b->kdbus_buffer == MAP_FAILED) {
749 b->kdbus_buffer = NULL;
754 /* The higher 32bit of both flags fields are considered
755 * 'incompatible flags'. Refuse them all for now. */
756 if (hello->bus_flags > 0xFFFFFFFFULL ||
757 hello->conn_flags > 0xFFFFFFFFULL)
760 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
763 b->bloom_size = (size_t) hello->bloom.size;
764 b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
766 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
769 b->unique_id = hello->id;
772 b->bus_client = true;
773 b->can_fds = !!(hello->conn_flags & KDBUS_HELLO_ACCEPT_FD);
774 b->message_version = 2;
775 b->message_endian = BUS_NATIVE_ENDIAN;
777 /* the kernel told us the UUID of the underlying bus */
778 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
780 return bus_start_running(b);
783 int bus_kernel_connect(sd_bus *b) {
785 assert(b->input_fd < 0);
786 assert(b->output_fd < 0);
792 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
796 b->output_fd = b->input_fd;
798 return bus_kernel_take_fd(b);
801 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
802 struct kdbus_cmd_free cmd;
803 uint64_t off _alignas_(8);
804 struct kdbus_item *d;
810 cmd.offset = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
812 ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
814 KDBUS_ITEM_FOREACH(d, k, items) {
816 if (d->type == KDBUS_ITEM_FDS)
817 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
818 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
819 safe_close(d->memfd.fd);
823 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
828 assert(bus->state == BUS_RUNNING);
830 /* If we can't deliver, we want room for the error message */
831 r = bus_rqueue_make_room(bus);
835 r = bus_message_setup_kmsg(bus, m);
839 /* If this is a synchronous method call, then let's tell the
840 * kernel, so that it can pass CPU time/scheduling to the
841 * destination for the time, if it wants to. If we
842 * synchronously wait for the result anyway, we won't need CPU
845 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
847 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
849 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
850 sd_bus_message *reply;
852 if (errno == EAGAIN || errno == EINTR)
854 else if (errno == ENXIO || errno == ESRCH) {
856 /* ENXIO: unique name not known
857 * ESRCH: well-known name not known */
859 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
860 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
862 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
866 } else if (errno == EADDRNOTAVAIL) {
868 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
870 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
871 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
873 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
879 r = bus_message_new_synthetic_error(
881 BUS_MESSAGE_COOKIE(m),
888 r = bus_seal_synthetic_message(bus, reply);
892 bus->rqueue[bus->rqueue_size++] = reply;
894 } else if (hint_sync_call) {
897 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
900 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
902 r = bus_kernel_make_message(bus, k);
904 close_kdbus_msg(bus, k);
906 /* Anybody can send us invalid messages, let's just drop them. */
907 if (r == -EBADMSG || r == -EPROTOTYPE)
908 log_debug("Ignoring invalid message: %s", strerror(-r));
913 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
914 close_kdbus_msg(bus, k);
921 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
922 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
927 r = sd_bus_message_new_signal(
930 "/org/freedesktop/DBus",
931 "org.freedesktop.DBus",
936 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
940 m->sender = "org.freedesktop.DBus";
942 r = bus_seal_synthetic_message(bus, m);
946 bus->rqueue[bus->rqueue_size++] = m;
952 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
953 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
959 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
962 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
964 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
966 if (isempty(old_owner))
971 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
973 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
976 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
977 char owner[UNIQUE_NAME_MAX];
983 sprintf(owner, ":1.%llu", d->id_change.id);
985 return push_name_owner_changed(
987 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
988 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
991 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
992 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
999 r = bus_message_new_synthetic_error(
1002 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1003 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1004 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1009 m->sender = "org.freedesktop.DBus";
1011 r = bus_seal_synthetic_message(bus, m);
1015 bus->rqueue[bus->rqueue_size++] = m;
1021 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1022 struct kdbus_item *d, *found = NULL;
1024 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1025 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1026 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1027 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1029 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1030 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1032 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1033 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1038 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1040 KDBUS_ITEM_FOREACH(d, k, items) {
1041 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1046 log_debug("Got unknown field from kernel %llu", d->type);
1050 log_debug("Didn't find a kernel message to translate.");
1054 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1057 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1058 struct kdbus_cmd_recv recv = {};
1059 struct kdbus_msg *k;
1064 r = bus_rqueue_make_room(bus);
1068 if (hint_priority) {
1069 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1070 recv.priority = priority;
1073 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1075 if (errno == EAGAIN)
1081 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1082 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1083 r = bus_kernel_make_message(bus, k);
1085 /* Anybody can send us invalid messages, let's just drop them. */
1086 if (r == -EBADMSG || r == -EPROTOTYPE) {
1087 log_debug("Ignoring invalid message: %s", strerror(-r));
1091 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1092 r = bus_kernel_translate_message(bus, k);
1094 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1099 close_kdbus_msg(bus, k);
1101 return r < 0 ? r : 1;
1104 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1105 struct memfd_cache *c;
1112 if (!bus || !bus->is_kernel)
1115 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1117 if (bus->n_memfd_cache <= 0) {
1118 _cleanup_free_ char *g = NULL;
1121 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1123 assert(bus->connection_name);
1125 g = bus_label_escape(bus->connection_name);
1129 r = memfd_create(g, MFD_ALLOW_SEALING);
1139 c = &bus->memfd_cache[--bus->n_memfd_cache];
1142 assert(c->mapped == 0 || c->address);
1144 *address = c->address;
1145 *mapped = c->mapped;
1146 *allocated = c->allocated;
1149 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1154 static void close_and_munmap(int fd, void *address, size_t size) {
1156 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1161 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1162 struct memfd_cache *c;
1163 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1166 assert(mapped == 0 || address);
1168 if (!bus || !bus->is_kernel) {
1169 close_and_munmap(fd, address, mapped);
1173 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1175 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1176 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1178 close_and_munmap(fd, address, mapped);
1182 c = &bus->memfd_cache[bus->n_memfd_cache++];
1184 c->address = address;
1186 /* If overly long, let's return a bit to the OS */
1187 if (mapped > max_mapped) {
1188 assert_se(ftruncate(fd, max_mapped) >= 0);
1189 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1190 c->mapped = c->allocated = max_mapped;
1193 c->allocated = allocated;
1196 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1199 void bus_kernel_flush_memfd(sd_bus *b) {
1204 for (i = 0; i < b->n_memfd_cache; i++)
1205 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1208 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1211 assert(kdbus_flags);
1213 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1214 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1216 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1217 f |= KDBUS_NAME_REPLACE_EXISTING;
1219 if (flags & SD_BUS_NAME_QUEUE)
1220 f |= KDBUS_NAME_QUEUE;
1226 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1231 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1232 m |= KDBUS_ATTACH_CREDS;
1234 if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1235 m |= KDBUS_ATTACH_COMM;
1237 if (mask & SD_BUS_CREDS_EXE)
1238 m |= KDBUS_ATTACH_EXE;
1240 if (mask & SD_BUS_CREDS_CMDLINE)
1241 m |= KDBUS_ATTACH_CMDLINE;
1243 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))
1244 m |= KDBUS_ATTACH_CGROUP;
1246 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1247 m |= KDBUS_ATTACH_CAPS;
1249 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1250 m |= KDBUS_ATTACH_SECLABEL;
1252 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1253 m |= KDBUS_ATTACH_AUDIT;
1255 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1256 m |= KDBUS_ATTACH_NAMES;
1258 if (mask & SD_BUS_CREDS_CONNECTION_NAME)
1259 m |= KDBUS_ATTACH_CONN_NAME;
1265 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1266 struct kdbus_cmd_make *make;
1267 struct kdbus_item *n;
1273 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1277 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1278 offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1279 offsetof(struct kdbus_item, str) +
1280 DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1),
1283 make->size = offsetof(struct kdbus_cmd_make, items);
1286 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1287 sizeof(struct kdbus_bloom_parameter);
1288 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1290 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1291 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1293 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1294 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1296 make->size += ALIGN8(n->size);
1298 n = KDBUS_ITEM_NEXT(n);
1299 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1300 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1301 n->type = KDBUS_ITEM_MAKE_NAME;
1302 make->size += ALIGN8(n->size);
1304 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1306 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1311 /* The higher 32bit of the flags field are considered
1312 * 'incompatible flags'. Refuse them all for now. */
1313 if (make->flags > 0xFFFFFFFFULL) {
1321 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1333 static int bus_kernel_translate_access(BusPolicyAccess access) {
1334 assert(access >= 0);
1335 assert(access < _BUS_POLICY_ACCESS_MAX);
1339 case BUS_POLICY_ACCESS_SEE:
1340 return KDBUS_POLICY_SEE;
1342 case BUS_POLICY_ACCESS_TALK:
1343 return KDBUS_POLICY_TALK;
1345 case BUS_POLICY_ACCESS_OWN:
1346 return KDBUS_POLICY_OWN;
1349 assert_not_reached("Unknown policy access");
1353 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1359 switch (policy->type) {
1361 case BUSNAME_POLICY_TYPE_USER: {
1362 const char *user = policy->name;
1365 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1369 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1370 item->policy_access.id = uid;
1374 case BUSNAME_POLICY_TYPE_GROUP: {
1375 const char *group = policy->name;
1378 r = get_group_creds(&group, &gid);
1382 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1383 item->policy_access.id = gid;
1388 assert_not_reached("Unknown policy type");
1391 item->policy_access.access = bus_kernel_translate_access(policy->access);
1396 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1401 len = 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_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1420 _cleanup_free_ char *path = NULL;
1421 struct kdbus_cmd_make *make;
1422 struct kdbus_item *n;
1426 fd = bus_kernel_open_bus_fd(bus_name, &path);
1430 size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1431 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(ep_name) + 1);
1433 make = alloca0_align(size, 8);
1435 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1439 n->type = KDBUS_ITEM_MAKE_NAME;
1440 n->size = offsetof(struct kdbus_item, str) + strlen(ep_name) + 1;
1441 strcpy(n->str, ep_name);
1443 if (ioctl(fd, KDBUS_CMD_EP_MAKE, make) < 0) {
1448 /* The higher 32bit of the flags field are considered
1449 * 'incompatible flags'. Refuse them all for now. */
1450 if (make->flags > 0xFFFFFFFFULL) {
1458 p = strjoin(dirname(path), "/", ep_name, NULL);
1470 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
1472 struct kdbus_cmd_update *update;
1473 struct kdbus_item *n;
1474 BusEndpointPolicy *po;
1479 size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
1481 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1482 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
1483 size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1486 update = alloca0_align(size, 8);
1487 update->size = size;
1491 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1492 n->type = KDBUS_ITEM_NAME;
1493 n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1;
1494 strcpy(n->str, po->name);
1495 n = KDBUS_ITEM_NEXT(n);
1497 n->type = KDBUS_ITEM_POLICY_ACCESS;
1498 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1500 n->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1501 n->policy_access.access = bus_kernel_translate_access(po->access);
1502 n->policy_access.id = uid;
1504 n = KDBUS_ITEM_NEXT(n);
1507 r = ioctl(fd, KDBUS_CMD_EP_UPDATE, update);
1514 int bus_kernel_make_starter(
1519 BusNamePolicy *policy,
1520 BusPolicyAccess world_policy) {
1522 struct kdbus_cmd_hello *hello;
1523 struct kdbus_item *n;
1524 size_t policy_cnt = 0;
1532 LIST_FOREACH(policy, po, policy)
1535 if (world_policy >= 0)
1538 size = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
1539 ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1540 policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1542 hello = alloca0_align(size, 8);
1545 strcpy(n->str, name);
1546 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1547 n->type = KDBUS_ITEM_NAME;
1548 n = KDBUS_ITEM_NEXT(n);
1550 LIST_FOREACH(policy, po, policy) {
1551 n->type = KDBUS_ITEM_POLICY_ACCESS;
1552 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1554 r = bus_kernel_translate_policy(po, n);
1558 n = KDBUS_ITEM_NEXT(n);
1561 if (world_policy >= 0) {
1562 n->type = KDBUS_ITEM_POLICY_ACCESS;
1563 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1564 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1565 n->policy_access.access = bus_kernel_translate_access(world_policy);
1570 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1571 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1572 hello->pool_size = KDBUS_POOL_SIZE;
1573 hello->attach_flags = _KDBUS_ATTACH_ALL;
1575 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1578 /* The higher 32bit of both flags fields are considered
1579 * 'incompatible flags'. Refuse them all for now. */
1580 if (hello->bus_flags > 0xFFFFFFFFULL ||
1581 hello->conn_flags > 0xFFFFFFFFULL)
1584 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
1590 int bus_kernel_create_domain(const char *name, char **s) {
1591 struct kdbus_cmd_make *make;
1592 struct kdbus_item *n;
1598 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1602 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1603 offsetof(struct kdbus_item, str) +
1608 strcpy(n->str, name);
1609 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1610 n->type = KDBUS_ITEM_MAKE_NAME;
1612 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1613 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1615 if (ioctl(fd, KDBUS_CMD_DOMAIN_MAKE, make) < 0) {
1620 /* The higher 32bit of the flags field are considered
1621 * 'incompatible flags'. Refuse them all for now. */
1622 if (make->flags > 0xFFFFFFFFULL) {
1630 p = strappend("/dev/kdbus/domain/", name);
1642 int bus_kernel_try_close(sd_bus *bus) {
1644 assert(bus->is_kernel);
1646 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1652 int bus_kernel_drop_one(int fd) {
1653 struct kdbus_cmd_recv recv = {
1654 .flags = KDBUS_RECV_DROP
1659 if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0)