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 int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
336 sd_bus_message *m = NULL;
337 struct kdbus_item *d;
339 _cleanup_free_ int *fds = NULL;
340 struct bus_header *h = NULL;
341 size_t total, n_bytes = 0, idx = 0;
342 const char *destination = NULL, *seclabel = NULL;
347 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
349 KDBUS_ITEM_FOREACH(d, k, items) {
352 l = d->size - offsetof(struct kdbus_item, data);
356 case KDBUS_ITEM_PAYLOAD_OFF:
358 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
360 if (!bus_header_is_complete(h, d->vec.size))
364 n_bytes += d->vec.size;
367 case KDBUS_ITEM_PAYLOAD_MEMFD:
371 n_bytes += d->memfd.size;
374 case KDBUS_ITEM_FDS: {
379 f = realloc(fds, sizeof(int) * (n_fds + j));
384 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
389 case KDBUS_ITEM_SECLABEL:
398 r = bus_header_message_size(h, &total);
402 if (n_bytes != total)
405 /* on kdbus we only speak native endian gvariant, never dbus1
406 * marshalling or reverse endian */
407 if (h->version != 2 ||
408 h->endian != BUS_NATIVE_ENDIAN)
411 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
415 /* The well-known names list is different from the other
416 credentials. If we asked for it, but nothing is there, this
417 means that the list of well-known names is simply empty, not
418 that we lack any data */
420 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
422 KDBUS_ITEM_FOREACH(d, k, items) {
425 l = d->size - offsetof(struct kdbus_item, data);
429 case KDBUS_ITEM_PAYLOAD_OFF: {
432 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
434 if (idx + d->vec.size > begin_body) {
435 struct bus_body_part *part;
437 /* Contains body material */
439 part = message_append_part(m);
445 /* A -1 offset is NUL padding. */
446 part->is_zero = d->vec.offset == ~0ULL;
448 if (idx >= begin_body) {
450 part->data = (uint8_t *)k + d->vec.offset;
451 part->size = d->vec.size;
454 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
455 part->size = d->vec.size - (begin_body - idx);
465 case KDBUS_ITEM_PAYLOAD_MEMFD: {
466 struct bus_body_part *part;
468 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
473 part = message_append_part(m);
479 part->memfd = d->memfd.fd;
480 part->size = d->memfd.size;
483 idx += d->memfd.size;
487 case KDBUS_ITEM_CREDS:
488 /* UID/GID/PID are always valid */
489 m->creds.uid = (uid_t) d->creds.uid;
490 m->creds.gid = (gid_t) d->creds.gid;
491 m->creds.pid = (pid_t) d->creds.pid;
492 m->creds.mask |= (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID) & bus->creds_mask;
494 /* The PID starttime/TID might be missing
495 * however, when the data is faked by some
496 * data bus proxy and it lacks that
497 * information about the real client since
498 * SO_PEERCRED is used for that */
500 if (d->creds.starttime > 0) {
501 m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
502 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
505 if (d->creds.tid > 0) {
506 m->creds.tid = (pid_t) d->creds.tid;
507 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
511 case KDBUS_ITEM_TIMESTAMP:
513 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
514 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
515 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
516 m->seqnum = d->timestamp.seqnum;
521 case KDBUS_ITEM_PID_COMM:
522 m->creds.comm = d->str;
523 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
526 case KDBUS_ITEM_TID_COMM:
527 m->creds.tid_comm = d->str;
528 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
532 m->creds.exe = d->str;
533 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
536 case KDBUS_ITEM_CMDLINE:
537 m->creds.cmdline = d->str;
538 m->creds.cmdline_size = l;
539 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
542 case KDBUS_ITEM_CGROUP:
543 m->creds.cgroup = d->str;
544 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;
546 r = bus_get_root_path(bus);
550 m->creds.cgroup_root = bus->cgroup_root;
554 case KDBUS_ITEM_AUDIT:
555 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
556 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
557 m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
560 case KDBUS_ITEM_CAPS:
561 m->creds.capability = d->data;
562 m->creds.capability_size = l;
563 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;
566 case KDBUS_ITEM_DST_NAME:
567 if (!service_name_is_valid(d->str))
570 destination = d->str;
573 case KDBUS_ITEM_NAME:
574 if (!service_name_is_valid(d->name.name))
577 r = strv_extend(&m->creds.well_known_names, d->name.name);
582 case KDBUS_ITEM_CONN_NAME:
583 m->creds.conn_name = d->str;
584 m->creds.mask |= SD_BUS_CREDS_CONNECTION_NAME & bus->creds_mask;
588 case KDBUS_ITEM_SECLABEL:
592 log_debug("Got unknown field from kernel %llu", d->type);
596 r = bus_message_parse_fields(m);
600 /* Override information from the user header with data from the kernel */
601 if (k->src_id == KDBUS_SRC_ID_KERNEL)
602 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
604 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
605 m->sender = m->creds.unique_name = m->sender_buffer;
609 m->destination = destination;
610 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
611 m->destination = NULL;
612 else if (k->dst_id == KDBUS_DST_ID_NAME)
613 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
615 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
616 m->destination = m->destination_buffer;
619 /* We take possession of the kmsg struct now */
621 m->release_kdbus = true;
625 bus->rqueue[bus->rqueue_size++] = m;
631 struct bus_body_part *part;
634 /* Make sure the memfds are not freed twice */
635 MESSAGE_FOREACH_PART(part, i, m)
636 if (part->memfd >= 0)
639 sd_bus_message_unref(m);
645 int bus_kernel_take_fd(sd_bus *b) {
646 struct kdbus_cmd_hello *hello;
647 struct kdbus_item *item;
648 _cleanup_free_ char *g = NULL;
650 size_t l = 0, m = 0, sz;
660 if (b->connection_name) {
661 g = bus_label_escape(b->connection_name);
669 /* If no name is explicitly set, we'll include a hint
670 * indicating the library implementation, a hint which
671 * kind of bus this is and the thread name */
673 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
676 name = b->is_system ? "sd-system" :
677 b->is_user ? "sd-user" : "sd";
679 _cleanup_free_ char *e = NULL;
681 e = bus_label_escape(pr);
685 g = strappend(b->is_system ? "sd-system-" :
686 b->is_user ? "sd-user-" : "sd-",
694 b->connection_name = bus_label_unescape(name);
695 if (!b->connection_name)
701 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
702 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
704 if (b->fake_creds_valid)
705 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
708 l = strlen(b->fake_label);
709 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
712 hello = alloca0_align(sz, 8);
714 hello->conn_flags = b->hello_flags;
715 hello->attach_flags = b->attach_flags;
716 hello->pool_size = KDBUS_POOL_SIZE;
720 item->size = offsetof(struct kdbus_item, str) + m + 1;
721 item->type = KDBUS_ITEM_CONN_NAME;
722 memcpy(item->str, name, m + 1);
723 item = KDBUS_ITEM_NEXT(item);
725 if (b->fake_creds_valid) {
726 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
727 item->type = KDBUS_ITEM_CREDS;
728 item->creds = b->fake_creds;
730 item = KDBUS_ITEM_NEXT(item);
734 item->size = offsetof(struct kdbus_item, str) + l + 1;
735 item->type = KDBUS_ITEM_SECLABEL;
736 memcpy(item->str, b->fake_label, l+1);
739 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
743 if (!b->kdbus_buffer) {
744 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
745 if (b->kdbus_buffer == MAP_FAILED) {
746 b->kdbus_buffer = NULL;
751 /* The higher 32bit of both flags fields are considered
752 * 'incompatible flags'. Refuse them all for now. */
753 if (hello->bus_flags > 0xFFFFFFFFULL ||
754 hello->conn_flags > 0xFFFFFFFFULL)
757 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
760 b->bloom_size = (size_t) hello->bloom.size;
761 b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
763 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
766 b->unique_id = hello->id;
769 b->bus_client = true;
770 b->can_fds = !!(hello->conn_flags & KDBUS_HELLO_ACCEPT_FD);
771 b->message_version = 2;
772 b->message_endian = BUS_NATIVE_ENDIAN;
774 /* the kernel told us the UUID of the underlying bus */
775 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
777 return bus_start_running(b);
780 int bus_kernel_connect(sd_bus *b) {
782 assert(b->input_fd < 0);
783 assert(b->output_fd < 0);
789 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
793 b->output_fd = b->input_fd;
795 return bus_kernel_take_fd(b);
798 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
799 uint64_t off _alignas_(8);
800 struct kdbus_item *d;
805 off = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
806 ioctl(bus->input_fd, KDBUS_CMD_FREE, &off);
808 KDBUS_ITEM_FOREACH(d, k, items) {
810 if (d->type == KDBUS_ITEM_FDS)
811 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
812 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
813 safe_close(d->memfd.fd);
817 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
822 assert(bus->state == BUS_RUNNING);
824 /* If we can't deliver, we want room for the error message */
825 r = bus_rqueue_make_room(bus);
829 r = bus_message_setup_kmsg(bus, m);
833 /* If this is a synchronous method call, then let's tell the
834 * kernel, so that it can pass CPU time/scheduling to the
835 * destination for the time, if it wants to. If we
836 * synchronously wait for the result anyway, we won't need CPU
839 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
841 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
843 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
844 sd_bus_message *reply;
846 if (errno == EAGAIN || errno == EINTR)
848 else if (errno == ENXIO || errno == ESRCH) {
850 /* ENXIO: unique name not known
851 * ESRCH: well-known name not known */
853 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
854 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
856 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
860 } else if (errno == EADDRNOTAVAIL) {
862 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
864 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
865 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
867 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
873 r = bus_message_new_synthetic_error(
875 BUS_MESSAGE_COOKIE(m),
882 r = bus_seal_synthetic_message(bus, reply);
886 bus->rqueue[bus->rqueue_size++] = reply;
888 } else if (hint_sync_call) {
891 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
894 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
896 r = bus_kernel_make_message(bus, k);
898 close_kdbus_msg(bus, k);
900 /* Anybody can send us invalid messages, let's just drop them. */
901 if (r == -EBADMSG || r == -EPROTOTYPE)
902 log_debug("Ignoring invalid message: %s", strerror(-r));
907 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
908 close_kdbus_msg(bus, k);
915 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
916 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
921 r = sd_bus_message_new_signal(
924 "/org/freedesktop/DBus",
925 "org.freedesktop.DBus",
930 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
934 m->sender = "org.freedesktop.DBus";
936 r = bus_seal_synthetic_message(bus, m);
940 bus->rqueue[bus->rqueue_size++] = m;
946 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
947 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
953 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
956 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
958 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
960 if (isempty(old_owner))
965 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
967 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
970 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
971 char owner[UNIQUE_NAME_MAX];
977 sprintf(owner, ":1.%llu", d->id_change.id);
979 return push_name_owner_changed(
981 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
982 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
985 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
986 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
993 r = bus_message_new_synthetic_error(
996 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
997 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
998 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1003 m->sender = "org.freedesktop.DBus";
1005 r = bus_seal_synthetic_message(bus, m);
1009 bus->rqueue[bus->rqueue_size++] = m;
1015 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1016 struct kdbus_item *d, *found = NULL;
1018 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1019 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1020 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1021 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1023 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1024 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1026 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1027 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1032 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1034 KDBUS_ITEM_FOREACH(d, k, items) {
1035 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1040 log_debug("Got unknown field from kernel %llu", d->type);
1044 log_debug("Didn't find a kernel message to translate.");
1048 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1051 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1052 struct kdbus_cmd_recv recv = {};
1053 struct kdbus_msg *k;
1058 r = bus_rqueue_make_room(bus);
1062 if (hint_priority) {
1063 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1064 recv.priority = priority;
1067 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1069 if (errno == EAGAIN)
1075 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1076 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1077 r = bus_kernel_make_message(bus, k);
1079 /* Anybody can send us invalid messages, let's just drop them. */
1080 if (r == -EBADMSG || r == -EPROTOTYPE) {
1081 log_debug("Ignoring invalid message: %s", strerror(-r));
1085 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1086 r = bus_kernel_translate_message(bus, k);
1088 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1093 close_kdbus_msg(bus, k);
1095 return r < 0 ? r : 1;
1098 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1099 struct memfd_cache *c;
1106 if (!bus || !bus->is_kernel)
1109 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1111 if (bus->n_memfd_cache <= 0) {
1112 _cleanup_free_ char *g = NULL;
1115 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1117 assert(bus->connection_name);
1119 g = bus_label_escape(bus->connection_name);
1123 r = memfd_create(g, MFD_ALLOW_SEALING);
1133 c = &bus->memfd_cache[--bus->n_memfd_cache];
1136 assert(c->mapped == 0 || c->address);
1138 *address = c->address;
1139 *mapped = c->mapped;
1140 *allocated = c->allocated;
1143 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1148 static void close_and_munmap(int fd, void *address, size_t size) {
1150 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1155 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1156 struct memfd_cache *c;
1157 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1160 assert(mapped == 0 || address);
1162 if (!bus || !bus->is_kernel) {
1163 close_and_munmap(fd, address, mapped);
1167 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1169 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1170 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1172 close_and_munmap(fd, address, mapped);
1176 c = &bus->memfd_cache[bus->n_memfd_cache++];
1178 c->address = address;
1180 /* If overly long, let's return a bit to the OS */
1181 if (mapped > max_mapped) {
1182 assert_se(ftruncate(fd, max_mapped) >= 0);
1183 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1184 c->mapped = c->allocated = max_mapped;
1187 c->allocated = allocated;
1190 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1193 void bus_kernel_flush_memfd(sd_bus *b) {
1198 for (i = 0; i < b->n_memfd_cache; i++)
1199 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1202 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1205 assert(kdbus_flags);
1207 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1208 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1210 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1211 f |= KDBUS_NAME_REPLACE_EXISTING;
1213 if (flags & SD_BUS_NAME_QUEUE)
1214 f |= KDBUS_NAME_QUEUE;
1220 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1225 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1226 m |= KDBUS_ATTACH_CREDS;
1228 if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1229 m |= KDBUS_ATTACH_COMM;
1231 if (mask & SD_BUS_CREDS_EXE)
1232 m |= KDBUS_ATTACH_EXE;
1234 if (mask & SD_BUS_CREDS_CMDLINE)
1235 m |= KDBUS_ATTACH_CMDLINE;
1237 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))
1238 m |= KDBUS_ATTACH_CGROUP;
1240 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1241 m |= KDBUS_ATTACH_CAPS;
1243 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1244 m |= KDBUS_ATTACH_SECLABEL;
1246 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1247 m |= KDBUS_ATTACH_AUDIT;
1249 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1250 m |= KDBUS_ATTACH_NAMES;
1252 if (mask & SD_BUS_CREDS_CONNECTION_NAME)
1253 m |= KDBUS_ATTACH_CONN_NAME;
1259 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1260 struct kdbus_cmd_make *make;
1261 struct kdbus_item *n;
1267 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1271 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1272 offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1273 offsetof(struct kdbus_item, str) +
1274 DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1),
1277 make->size = offsetof(struct kdbus_cmd_make, items);
1280 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1281 sizeof(struct kdbus_bloom_parameter);
1282 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1284 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1285 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1287 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1288 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1290 make->size += ALIGN8(n->size);
1292 n = KDBUS_ITEM_NEXT(n);
1293 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1294 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1295 n->type = KDBUS_ITEM_MAKE_NAME;
1296 make->size += ALIGN8(n->size);
1298 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1300 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1305 /* The higher 32bit of the flags field are considered
1306 * 'incompatible flags'. Refuse them all for now. */
1307 if (make->flags > 0xFFFFFFFFULL) {
1315 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1327 static int bus_kernel_translate_access(BusPolicyAccess access) {
1328 assert(access >= 0);
1329 assert(access < _BUS_POLICY_ACCESS_MAX);
1333 case BUS_POLICY_ACCESS_SEE:
1334 return KDBUS_POLICY_SEE;
1336 case BUS_POLICY_ACCESS_TALK:
1337 return KDBUS_POLICY_TALK;
1339 case BUS_POLICY_ACCESS_OWN:
1340 return KDBUS_POLICY_OWN;
1343 assert_not_reached("Unknown policy access");
1347 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1353 switch (policy->type) {
1355 case BUSNAME_POLICY_TYPE_USER: {
1356 const char *user = policy->name;
1359 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1363 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1364 item->policy_access.id = uid;
1368 case BUSNAME_POLICY_TYPE_GROUP: {
1369 const char *group = policy->name;
1372 r = get_group_creds(&group, &gid);
1376 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1377 item->policy_access.id = gid;
1382 assert_not_reached("Unknown policy type");
1385 item->policy_access.access = bus_kernel_translate_access(policy->access);
1390 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1395 len = strlen("/dev/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1404 sprintf(p, "/dev/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1406 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1413 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1414 _cleanup_free_ char *path = NULL;
1415 struct kdbus_cmd_make *make;
1416 struct kdbus_item *n;
1420 fd = bus_kernel_open_bus_fd(bus_name, &path);
1424 size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1425 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(ep_name) + 1);
1427 make = alloca0_align(size, 8);
1429 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1433 n->type = KDBUS_ITEM_MAKE_NAME;
1434 n->size = offsetof(struct kdbus_item, str) + strlen(ep_name) + 1;
1435 strcpy(n->str, ep_name);
1437 if (ioctl(fd, KDBUS_CMD_EP_MAKE, make) < 0) {
1442 /* The higher 32bit of the flags field are considered
1443 * 'incompatible flags'. Refuse them all for now. */
1444 if (make->flags > 0xFFFFFFFFULL) {
1452 p = strjoin(dirname(path), "/", ep_name, NULL);
1464 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
1466 struct kdbus_cmd_update *update;
1467 struct kdbus_item *n;
1468 BusEndpointPolicy *po;
1473 size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
1475 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1476 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
1477 size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1480 update = alloca0_align(size, 8);
1481 update->size = size;
1485 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1486 n->type = KDBUS_ITEM_NAME;
1487 n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1;
1488 strcpy(n->str, po->name);
1489 n = KDBUS_ITEM_NEXT(n);
1491 n->type = KDBUS_ITEM_POLICY_ACCESS;
1492 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1494 n->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1495 n->policy_access.access = bus_kernel_translate_access(po->access);
1496 n->policy_access.id = uid;
1498 n = KDBUS_ITEM_NEXT(n);
1501 r = ioctl(fd, KDBUS_CMD_EP_UPDATE, update);
1508 int bus_kernel_make_starter(
1513 BusNamePolicy *policy,
1514 BusPolicyAccess world_policy) {
1516 struct kdbus_cmd_hello *hello;
1517 struct kdbus_item *n;
1518 size_t policy_cnt = 0;
1526 LIST_FOREACH(policy, po, policy)
1529 if (world_policy >= 0)
1532 size = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
1533 ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1534 policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1536 hello = alloca0_align(size, 8);
1539 strcpy(n->str, name);
1540 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1541 n->type = KDBUS_ITEM_NAME;
1542 n = KDBUS_ITEM_NEXT(n);
1544 LIST_FOREACH(policy, po, policy) {
1545 n->type = KDBUS_ITEM_POLICY_ACCESS;
1546 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1548 r = bus_kernel_translate_policy(po, n);
1552 n = KDBUS_ITEM_NEXT(n);
1555 if (world_policy >= 0) {
1556 n->type = KDBUS_ITEM_POLICY_ACCESS;
1557 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1558 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1559 n->policy_access.access = bus_kernel_translate_access(world_policy);
1564 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1565 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1566 hello->pool_size = KDBUS_POOL_SIZE;
1567 hello->attach_flags = _KDBUS_ATTACH_ALL;
1569 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1572 /* The higher 32bit of both flags fields are considered
1573 * 'incompatible flags'. Refuse them all for now. */
1574 if (hello->bus_flags > 0xFFFFFFFFULL ||
1575 hello->conn_flags > 0xFFFFFFFFULL)
1578 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
1584 int bus_kernel_create_domain(const char *name, char **s) {
1585 struct kdbus_cmd_make *make;
1586 struct kdbus_item *n;
1592 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1596 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1597 offsetof(struct kdbus_item, str) +
1602 strcpy(n->str, name);
1603 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1604 n->type = KDBUS_ITEM_MAKE_NAME;
1606 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1607 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1609 if (ioctl(fd, KDBUS_CMD_DOMAIN_MAKE, make) < 0) {
1614 /* The higher 32bit of the flags field are considered
1615 * 'incompatible flags'. Refuse them all for now. */
1616 if (make->flags > 0xFFFFFFFFULL) {
1624 p = strappend("/dev/kdbus/domain/", name);
1636 int bus_kernel_try_close(sd_bus *bus) {
1638 assert(bus->is_kernel);
1640 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1646 int bus_kernel_drop_one(int fd) {
1647 struct kdbus_cmd_recv recv = {
1648 .flags = KDBUS_RECV_DROP
1653 if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0)