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 "cgroup-util.h"
41 #define UNIQUE_NAME_MAX (3+DECIMAL_STR_MAX(uint64_t))
43 int bus_kernel_parse_unique_name(const char *s, uint64_t *id) {
49 if (!startswith(s, ":1."))
52 r = safe_atou64(s + 3, id);
59 static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) {
65 /* Note that p can be NULL, which encodes a region full of
66 * zeroes, which is useful to optimize certain padding
69 (*d)->size = offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec);
70 (*d)->type = KDBUS_ITEM_PAYLOAD_VEC;
71 (*d)->vec.address = PTR_TO_UINT64(p);
74 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
77 static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t sz) {
83 (*d)->size = offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd);
84 (*d)->type = KDBUS_ITEM_PAYLOAD_MEMFD;
85 (*d)->memfd.fd = memfd;
86 (*d)->memfd.size = sz;
88 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
91 static void append_destination(struct kdbus_item **d, const char *s, size_t length) {
97 (*d)->size = offsetof(struct kdbus_item, str) + length + 1;
98 (*d)->type = KDBUS_ITEM_DST_NAME;
99 memcpy((*d)->str, s, length + 1);
101 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
104 static void* append_bloom(struct kdbus_item **d, size_t length) {
111 (*d)->size = offsetof(struct kdbus_item, data) + length;
112 (*d)->type = KDBUS_ITEM_BLOOM;
115 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
120 static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) {
126 (*d)->size = offsetof(struct kdbus_item, fds) + sizeof(int) * n_fds;
127 (*d)->type = KDBUS_ITEM_FDS;
128 memcpy((*d)->fds, fds, sizeof(int) * n_fds);
130 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
133 static int bus_message_setup_bloom(sd_bus_message *m, void *bloom) {
140 memset(bloom, 0, BLOOM_SIZE);
142 bloom_add_pair(bloom, "message-type", bus_message_type_to_string(m->header->type));
145 bloom_add_pair(bloom, "interface", m->interface);
147 bloom_add_pair(bloom, "member", m->member);
149 bloom_add_pair(bloom, "path", m->path);
150 bloom_add_pair(bloom, "path-slash-prefix", m->path);
151 bloom_add_prefixes(bloom, "path-slash-prefix", m->path, '/');
154 r = sd_bus_message_rewind(m, true);
158 for (i = 0; i < 64; i++) {
161 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
164 r = sd_bus_message_peek_type(m, &type, NULL);
168 if (type != SD_BUS_TYPE_STRING &&
169 type != SD_BUS_TYPE_OBJECT_PATH &&
170 type != SD_BUS_TYPE_SIGNATURE)
173 r = sd_bus_message_read_basic(m, type, &t);
177 e = stpcpy(buf, "arg");
179 *(e++) = '0' + (char) i;
181 *(e++) = '0' + (char) (i / 10);
182 *(e++) = '0' + (char) (i % 10);
186 bloom_add_pair(bloom, buf, t);
188 strcpy(e, "-dot-prefix");
189 bloom_add_prefixes(bloom, buf, t, '.');
190 strcpy(e, "-slash-prefix");
191 bloom_add_prefixes(bloom, buf, t, '/');
197 static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
198 struct bus_body_part *part;
199 struct kdbus_item *d;
210 /* We put this together only once, if this message is reused
211 * we reuse the earlier-built version */
215 if (m->destination) {
216 r = bus_kernel_parse_unique_name(m->destination, &unique);
224 sz = offsetof(struct kdbus_msg, items);
226 assert_cc(ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec)) ==
227 ALIGN8(offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd)));
229 /* Add in fixed header, fields header and payload */
230 sz += (1 + m->n_body_parts) *
231 ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec));
233 /* Add space for bloom filter */
234 sz += ALIGN8(offsetof(struct kdbus_item, data) + BLOOM_SIZE);
236 /* Add in well-known destination header */
238 dl = strlen(m->destination);
239 sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1);
242 /* Add space for unix fds */
244 sz += ALIGN8(offsetof(struct kdbus_item, fds) + sizeof(int)*m->n_fds);
246 m->kdbus = memalign(8, sz);
252 m->free_kdbus = true;
253 memset(m->kdbus, 0, sz);
256 ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) |
257 ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0);
260 m->destination ? unique : KDBUS_DST_ID_BROADCAST;
261 m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
262 m->kdbus->cookie = m->header->serial;
264 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
265 m->kdbus->cookie_reply = m->reply_cookie;
267 m->kdbus->timeout_ns = m->timeout * NSEC_PER_USEC;
272 append_destination(&d, m->destination, dl);
274 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
276 MESSAGE_FOREACH_PART(part, i, m) {
278 /* If this is padding then simply send a
279 * vector with a NULL data pointer which the
280 * kernel will just pass through. This is the
281 * most efficient way to encode zeroes */
283 append_payload_vec(&d, NULL, part->size);
287 if (part->memfd >= 0 && part->sealed && m->destination) {
288 /* Try to send a memfd, if the part is
289 * sealed and this is not a broadcast. Since we can only */
291 append_payload_memfd(&d, part->memfd, part->size);
295 /* Otherwise let's send a vector to the actual data,
296 * for that we need to map it first. */
297 r = bus_body_part_map(part);
301 append_payload_vec(&d, part->data, part->size);
304 if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
307 p = append_bloom(&d, BLOOM_SIZE);
308 r = bus_message_setup_bloom(m, p);
314 append_fds(&d, m->fds, m->n_fds);
316 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
317 assert(m->kdbus->size <= sz);
326 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
327 sd_bus_message *m = NULL;
328 struct kdbus_item *d;
330 _cleanup_free_ int *fds = NULL;
331 struct bus_header *h = NULL;
332 size_t total, n_bytes = 0, idx = 0;
333 const char *destination = NULL, *seclabel = NULL;
338 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
340 KDBUS_ITEM_FOREACH(d, k, items) {
343 l = d->size - offsetof(struct kdbus_item, data);
347 case KDBUS_ITEM_PAYLOAD_OFF:
349 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
351 if (!bus_header_is_complete(h, d->vec.size))
355 n_bytes += d->vec.size;
358 case KDBUS_ITEM_PAYLOAD_MEMFD:
362 n_bytes += d->memfd.size;
365 case KDBUS_ITEM_FDS: {
370 f = realloc(fds, sizeof(int) * (n_fds + j));
375 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
380 case KDBUS_ITEM_SECLABEL:
389 r = bus_header_message_size(h, &total);
393 if (n_bytes != total)
396 /* on kdbus we only speak native endian gvariant, never dbus1
397 * marshalling or reverse endian */
398 if (h->version != 2 ||
399 h->endian != BUS_NATIVE_ENDIAN)
402 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
406 /* The well-known names list is different from the other
407 credentials. If we asked for it, but nothing is there, this
408 means that the list of well-known names is simply empty, not
409 that we lack any data */
411 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
413 KDBUS_ITEM_FOREACH(d, k, items) {
416 l = d->size - offsetof(struct kdbus_item, data);
420 case KDBUS_ITEM_PAYLOAD_OFF: {
423 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
425 if (idx + d->vec.size > begin_body) {
426 struct bus_body_part *part;
428 /* Contains body material */
430 part = message_append_part(m);
436 /* A -1 offset is NUL padding. */
437 part->is_zero = d->vec.offset == ~0ULL;
439 if (idx >= begin_body) {
441 part->data = (uint8_t *)k + d->vec.offset;
442 part->size = d->vec.size;
445 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
446 part->size = d->vec.size - (begin_body - idx);
456 case KDBUS_ITEM_PAYLOAD_MEMFD: {
457 struct bus_body_part *part;
459 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
464 part = message_append_part(m);
470 part->memfd = d->memfd.fd;
471 part->size = d->memfd.size;
474 idx += d->memfd.size;
478 case KDBUS_ITEM_CREDS:
479 /* UID/GID/PID are always valid */
480 m->creds.uid = (uid_t) d->creds.uid;
481 m->creds.gid = (gid_t) d->creds.gid;
482 m->creds.pid = (pid_t) d->creds.pid;
483 m->creds.mask |= (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID) & bus->creds_mask;
485 /* The PID starttime/TID might be missing
486 * however, when the data is faked by some
487 * data bus proxy and it lacks that
488 * information about the real client since
489 * SO_PEERCRED is used for that */
491 if (d->creds.starttime > 0) {
492 m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
493 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
496 if (d->creds.tid > 0) {
497 m->creds.tid = (pid_t) d->creds.tid;
498 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
502 case KDBUS_ITEM_TIMESTAMP:
504 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
505 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
506 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
507 m->seqnum = d->timestamp.seqnum;
512 case KDBUS_ITEM_PID_COMM:
513 m->creds.comm = d->str;
514 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
517 case KDBUS_ITEM_TID_COMM:
518 m->creds.tid_comm = d->str;
519 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
523 m->creds.exe = d->str;
524 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
527 case KDBUS_ITEM_CMDLINE:
528 m->creds.cmdline = d->str;
529 m->creds.cmdline_size = l;
530 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
533 case KDBUS_ITEM_CGROUP:
534 m->creds.cgroup = d->str;
535 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;
537 if (!bus->cgroup_root) {
538 r = cg_get_root_path(&bus->cgroup_root);
543 m->creds.cgroup_root = bus->cgroup_root;
547 case KDBUS_ITEM_AUDIT:
548 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
549 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
550 m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
553 case KDBUS_ITEM_CAPS:
554 m->creds.capability = d->data;
555 m->creds.capability_size = l;
556 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;
559 case KDBUS_ITEM_DST_NAME:
560 if (!service_name_is_valid(d->str))
563 destination = d->str;
566 case KDBUS_ITEM_NAME:
567 if (!service_name_is_valid(d->name.name))
570 r = strv_extend(&m->creds.well_known_names, d->name.name);
575 case KDBUS_ITEM_CONN_NAME:
576 m->creds.conn_name = d->str;
577 m->creds.mask |= SD_BUS_CREDS_CONNECTION_NAME & bus->creds_mask;
581 case KDBUS_ITEM_SECLABEL:
585 log_debug("Got unknown field from kernel %llu", d->type);
589 r = bus_message_parse_fields(m);
593 /* Override information from the user header with data from the kernel */
594 if (k->src_id == KDBUS_SRC_ID_KERNEL)
595 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
597 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
598 m->sender = m->creds.unique_name = m->sender_buffer;
602 m->destination = destination;
603 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
604 m->destination = NULL;
605 else if (k->dst_id == KDBUS_DST_ID_NAME)
606 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
608 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
609 m->destination = m->destination_buffer;
612 /* We take possession of the kmsg struct now */
614 m->release_kdbus = true;
618 bus->rqueue[bus->rqueue_size++] = m;
624 struct bus_body_part *part;
627 /* Make sure the memfds are not freed twice */
628 MESSAGE_FOREACH_PART(part, i, m)
629 if (part->memfd >= 0)
632 sd_bus_message_unref(m);
638 int bus_kernel_take_fd(sd_bus *b) {
639 struct kdbus_cmd_hello *hello;
640 struct kdbus_item *item;
641 _cleanup_free_ char *g = NULL;
643 size_t l = 0, m = 0, sz;
653 if (b->connection_name) {
654 g = sd_bus_label_escape(b->connection_name);
662 /* If no name is explicitly set, we'll include a hint
663 * indicating the library implementation, a hint which
664 * kind of bus this is and the thread name */
666 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
669 name = b->is_system ? "sd-system" :
670 b->is_user ? "sd-user" : "sd";
672 _cleanup_free_ char *e = NULL;
674 e = sd_bus_label_escape(pr);
678 g = strappend(b->is_system ? "sd-system-" :
679 b->is_user ? "sd-user-" : "sd-",
687 b->connection_name = sd_bus_label_unescape(name);
688 if (!b->connection_name)
694 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
695 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
697 if (b->fake_creds_valid)
698 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
701 l = strlen(b->fake_label);
702 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
707 hello->conn_flags = b->hello_flags;
708 hello->attach_flags = b->attach_flags;
709 hello->pool_size = KDBUS_POOL_SIZE;
713 item->size = offsetof(struct kdbus_item, str) + m + 1;
714 item->type = KDBUS_ITEM_CONN_NAME;
715 memcpy(item->str, name, m + 1);
716 item = KDBUS_ITEM_NEXT(item);
718 if (b->fake_creds_valid) {
719 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
720 item->type = KDBUS_ITEM_CREDS;
721 item->creds = b->fake_creds;
723 item = KDBUS_ITEM_NEXT(item);
727 item->size = offsetof(struct kdbus_item, str) + l + 1;
728 item->type = KDBUS_ITEM_SECLABEL;
729 memcpy(item->str, b->fake_label, l+1);
732 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
736 if (!b->kdbus_buffer) {
737 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
738 if (b->kdbus_buffer == MAP_FAILED) {
739 b->kdbus_buffer = NULL;
744 /* The higher 32bit of both flags fields are considered
745 * 'incompatible flags'. Refuse them all for now. */
746 if (hello->bus_flags > 0xFFFFFFFFULL ||
747 hello->conn_flags > 0xFFFFFFFFULL)
750 if (hello->bloom_size != BLOOM_SIZE)
753 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
756 b->unique_id = hello->id;
759 b->bus_client = true;
760 b->can_fds = !!(hello->conn_flags & KDBUS_HELLO_ACCEPT_FD);
761 b->message_version = 2;
762 b->message_endian = BUS_NATIVE_ENDIAN;
764 /* the kernel told us the UUID of the underlying bus */
765 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
767 return bus_start_running(b);
770 int bus_kernel_connect(sd_bus *b) {
772 assert(b->input_fd < 0);
773 assert(b->output_fd < 0);
779 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
783 b->output_fd = b->input_fd;
785 return bus_kernel_take_fd(b);
788 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
790 struct kdbus_item *d;
795 off = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
796 ioctl(bus->input_fd, KDBUS_CMD_FREE, &off);
798 KDBUS_ITEM_FOREACH(d, k, items) {
800 if (d->type == KDBUS_ITEM_FDS)
801 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
802 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
803 close_nointr_nofail(d->memfd.fd);
807 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
812 assert(bus->state == BUS_RUNNING);
814 /* If we can't deliver, we want room for the error message */
815 r = bus_rqueue_make_room(bus);
819 r = bus_message_setup_kmsg(bus, m);
823 /* If this is a synchronous method call, then let's tell the
824 * kernel, so that it can pass CPU time/scheduling to the
825 * destination for the time, if it wants to. If we
826 * synchronously wait for the result anyway, we won't need CPU
829 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
831 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
833 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
834 sd_bus_message *reply;
836 if (errno == EAGAIN || errno == EINTR)
838 else if (errno == ENXIO || errno == ESRCH) {
840 /* ENXIO: unique name not known
841 * ESRCH: well-known name not known */
843 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
844 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
846 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
850 } else if (errno == EADDRNOTAVAIL) {
852 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
854 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
855 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
857 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
863 r = bus_message_new_synthetic_error(
865 BUS_MESSAGE_COOKIE(m),
872 r = bus_seal_synthetic_message(bus, reply);
876 bus->rqueue[bus->rqueue_size++] = reply;
878 } else if (hint_sync_call) {
881 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
884 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
886 r = bus_kernel_make_message(bus, k);
888 close_kdbus_msg(bus, k);
890 /* Anybody can send us invalid messages, let's just drop them. */
891 if (r == -EBADMSG || r == -EPROTOTYPE)
892 log_debug("Ignoring invalid message: %s", strerror(-r));
897 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
898 close_kdbus_msg(bus, k);
905 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
906 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
911 r = sd_bus_message_new_signal(
913 "/org/freedesktop/DBus",
914 "org.freedesktop.DBus",
920 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
924 m->sender = "org.freedesktop.DBus";
926 r = bus_seal_synthetic_message(bus, m);
930 bus->rqueue[bus->rqueue_size++] = m;
936 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
937 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
943 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
946 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old.id);
948 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
950 if (isempty(old_owner))
955 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new.id);
957 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
960 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
961 char owner[UNIQUE_NAME_MAX];
967 sprintf(owner, ":1.%llu", d->id_change.id);
969 return push_name_owner_changed(
971 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
972 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
975 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
976 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
983 r = bus_message_new_synthetic_error(
986 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
987 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
988 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
993 m->sender = "org.freedesktop.DBus";
995 r = bus_seal_synthetic_message(bus, m);
999 bus->rqueue[bus->rqueue_size++] = m;
1005 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1006 struct kdbus_item *d, *found = NULL;
1008 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1009 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1010 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1011 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1013 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1014 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1016 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1017 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1022 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1024 KDBUS_ITEM_FOREACH(d, k, items) {
1025 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1030 log_debug("Got unknown field from kernel %llu", d->type);
1034 log_debug("Didn't find a kernel message to translate.");
1038 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1041 int bus_kernel_read_message(sd_bus *bus) {
1042 struct kdbus_cmd_recv recv = {};
1043 struct kdbus_msg *k;
1048 r = bus_rqueue_make_room(bus);
1052 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1054 if (errno == EAGAIN)
1060 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1061 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1062 r = bus_kernel_make_message(bus, k);
1064 /* Anybody can send us invalid messages, let's just drop them. */
1065 if (r == -EBADMSG || r == -EPROTOTYPE) {
1066 log_debug("Ignoring invalid message: %s", strerror(-r));
1070 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1071 r = bus_kernel_translate_message(bus, k);
1073 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1078 close_kdbus_msg(bus, k);
1080 return r < 0 ? r : 1;
1083 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1084 struct memfd_cache *c;
1091 if (!bus || !bus->is_kernel)
1094 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1096 if (bus->n_memfd_cache <= 0) {
1097 _cleanup_free_ char *g = NULL;
1098 struct kdbus_cmd_memfd_make *cmd;
1099 struct kdbus_item *item;
1103 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1105 assert(bus->connection_name);
1107 g = sd_bus_label_escape(bus->connection_name);
1112 sz = ALIGN8(offsetof(struct kdbus_cmd_memfd_make, items)) +
1113 ALIGN8(offsetof(struct kdbus_item, str)) +
1119 item->size = ALIGN8(offsetof(struct kdbus_item, str)) + l + 1;
1120 item->type = KDBUS_ITEM_MEMFD_NAME;
1121 memcpy(item->str, g, l + 1);
1123 r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, cmd);
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);
1152 close_nointr_nofail(fd);
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(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &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(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));
1276 make->size = offsetof(struct kdbus_cmd_make, items);
1279 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1280 n->type = KDBUS_ITEM_BLOOM_SIZE;
1281 n->data64[0] = BLOOM_SIZE;
1282 assert_cc(BLOOM_SIZE % 8 == 0);
1283 make->size += ALIGN8(n->size);
1285 n = KDBUS_ITEM_NEXT(n);
1286 sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name);
1287 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1288 n->type = KDBUS_ITEM_MAKE_NAME;
1289 make->size += ALIGN8(n->size);
1291 make->flags = KDBUS_MAKE_POLICY_OPEN | (world ? KDBUS_MAKE_ACCESS_WORLD : 0);
1293 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1294 close_nointr_nofail(fd);
1298 /* The higher 32bit of the flags field are considered
1299 * 'incompatible flags'. Refuse them all for now. */
1300 if (make->flags > 0xFFFFFFFFULL) {
1301 close_nointr_nofail(fd);
1308 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1310 close_nointr_nofail(fd);
1320 int bus_kernel_create_starter(const char *bus, const char *name) {
1321 struct kdbus_cmd_hello *hello;
1322 struct kdbus_item *n;
1329 p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1330 sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1332 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1336 hello = alloca0(ALIGN8(offsetof(struct kdbus_cmd_hello, items) +
1337 offsetof(struct kdbus_item, str) +
1341 strcpy(n->str, name);
1342 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1343 n->type = KDBUS_ITEM_NAME;
1345 hello->size = ALIGN8(offsetof(struct kdbus_cmd_hello, items) + n->size);
1346 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1347 hello->pool_size = KDBUS_POOL_SIZE;
1349 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1350 close_nointr_nofail(fd);
1354 /* The higher 32bit of both flags fields are considered
1355 * 'incompatible flags'. Refuse them all for now. */
1356 if (hello->bus_flags > 0xFFFFFFFFULL ||
1357 hello->conn_flags > 0xFFFFFFFFULL) {
1358 close_nointr_nofail(fd);
1362 if (hello->bloom_size != BLOOM_SIZE) {
1363 close_nointr_nofail(fd);
1370 int bus_kernel_create_namespace(const char *name, char **s) {
1371 struct kdbus_cmd_make *make;
1372 struct kdbus_item *n;
1378 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1382 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1383 offsetof(struct kdbus_item, str) +
1387 strcpy(n->str, name);
1388 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1389 n->type = KDBUS_ITEM_MAKE_NAME;
1391 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1392 make->flags = KDBUS_MAKE_POLICY_OPEN | KDBUS_MAKE_ACCESS_WORLD;
1394 if (ioctl(fd, KDBUS_CMD_NS_MAKE, make) < 0) {
1395 close_nointr_nofail(fd);
1399 /* The higher 32bit of the flags field are considered
1400 * 'incompatible flags'. Refuse them all for now. */
1401 if (make->flags > 0xFFFFFFFFULL) {
1402 close_nointr_nofail(fd);
1409 p = strappend("/dev/kdbus/ns/", name);
1411 close_nointr_nofail(fd);
1421 int bus_kernel_create_monitor(const char *bus) {
1422 struct kdbus_cmd_hello *hello;
1428 p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1429 sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1431 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1435 hello = alloca0(sizeof(struct kdbus_cmd_hello));
1436 hello->size = sizeof(struct kdbus_cmd_hello);
1437 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1438 hello->pool_size = KDBUS_POOL_SIZE;
1440 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1441 close_nointr_nofail(fd);
1445 /* The higher 32bit of both flags fields are considered
1446 * 'incompatible flags'. Refuse them all for now. */
1447 if (hello->bus_flags > 0xFFFFFFFFULL ||
1448 hello->conn_flags > 0xFFFFFFFFULL) {
1449 close_nointr_nofail(fd);
1456 int bus_kernel_try_close(sd_bus *bus) {
1458 assert(bus->is_kernel);
1460 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)