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:
503 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
504 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
505 m->seqnum = d->timestamp.seqnum;
508 case KDBUS_ITEM_PID_COMM:
509 m->creds.comm = d->str;
510 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
513 case KDBUS_ITEM_TID_COMM:
514 m->creds.tid_comm = d->str;
515 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
519 m->creds.exe = d->str;
520 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
523 case KDBUS_ITEM_CMDLINE:
524 m->creds.cmdline = d->str;
525 m->creds.cmdline_size = l;
526 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
529 case KDBUS_ITEM_CGROUP:
530 m->creds.cgroup = d->str;
531 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;
533 if (!bus->cgroup_root) {
534 r = cg_get_root_path(&bus->cgroup_root);
539 m->creds.cgroup_root = bus->cgroup_root;
543 case KDBUS_ITEM_AUDIT:
544 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
545 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
546 m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
549 case KDBUS_ITEM_CAPS:
550 m->creds.capability = d->data;
551 m->creds.capability_size = l;
552 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;
555 case KDBUS_ITEM_DST_NAME:
556 if (!service_name_is_valid(d->str))
559 destination = d->str;
562 case KDBUS_ITEM_NAME:
563 if (!service_name_is_valid(d->name.name))
566 r = strv_extend(&m->creds.well_known_names, d->name.name);
571 case KDBUS_ITEM_CONN_NAME:
572 m->creds.conn_name = d->str;
573 m->creds.mask |= SD_BUS_CREDS_CONNECTION_NAME & bus->creds_mask;
577 case KDBUS_ITEM_SECLABEL:
581 log_debug("Got unknown field from kernel %llu", d->type);
585 r = bus_message_parse_fields(m);
589 /* Override information from the user header with data from the kernel */
590 if (k->src_id == KDBUS_SRC_ID_KERNEL)
591 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
593 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
594 m->sender = m->creds.unique_name = m->sender_buffer;
598 m->destination = destination;
599 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
600 m->destination = NULL;
601 else if (k->dst_id == KDBUS_DST_ID_NAME)
602 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
604 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
605 m->destination = m->destination_buffer;
608 /* We take possession of the kmsg struct now */
610 m->release_kdbus = true;
614 bus->rqueue[bus->rqueue_size++] = m;
620 struct bus_body_part *part;
623 /* Make sure the memfds are not freed twice */
624 MESSAGE_FOREACH_PART(part, i, m)
625 if (part->memfd >= 0)
628 sd_bus_message_unref(m);
634 int bus_kernel_take_fd(sd_bus *b) {
635 struct kdbus_cmd_hello *hello;
636 struct kdbus_item *item;
637 _cleanup_free_ char *g = NULL;
639 size_t l = 0, m = 0, sz;
649 if (b->connection_name) {
650 g = sd_bus_label_escape(b->connection_name);
658 /* If no name is explicitly set, we'll include a hint
659 * indicating the library implementation, a hint which
660 * kind of bus this is and the thread name */
662 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
665 name = b->is_system ? "sd-system" :
666 b->is_user ? "sd-user" : "sd";
668 _cleanup_free_ char *e = NULL;
670 e = sd_bus_label_escape(pr);
674 g = strappend(b->is_system ? "sd-system-" :
675 b->is_user ? "sd-user-" : "sd-",
683 b->connection_name = sd_bus_label_unescape(name);
684 if (!b->connection_name)
690 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
691 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
693 if (b->fake_creds_valid)
694 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
697 l = strlen(b->fake_label);
698 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
703 hello->conn_flags = b->hello_flags;
704 hello->attach_flags = b->attach_flags;
705 hello->pool_size = KDBUS_POOL_SIZE;
709 item->size = offsetof(struct kdbus_item, str) + m + 1;
710 item->type = KDBUS_ITEM_CONN_NAME;
711 memcpy(item->str, name, m + 1);
712 item = KDBUS_ITEM_NEXT(item);
714 if (b->fake_creds_valid) {
715 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
716 item->type = KDBUS_ITEM_CREDS;
717 item->creds = b->fake_creds;
719 item = KDBUS_ITEM_NEXT(item);
723 item->size = offsetof(struct kdbus_item, str) + l + 1;
724 item->type = KDBUS_ITEM_SECLABEL;
725 memcpy(item->str, b->fake_label, l+1);
728 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
732 if (!b->kdbus_buffer) {
733 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
734 if (b->kdbus_buffer == MAP_FAILED) {
735 b->kdbus_buffer = NULL;
740 /* The higher 32bit of both flags fields are considered
741 * 'incompatible flags'. Refuse them all for now. */
742 if (hello->bus_flags > 0xFFFFFFFFULL ||
743 hello->conn_flags > 0xFFFFFFFFULL)
746 if (hello->bloom_size != BLOOM_SIZE)
749 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
752 b->unique_id = hello->id;
755 b->bus_client = true;
756 b->can_fds = !!(hello->conn_flags & KDBUS_HELLO_ACCEPT_FD);
757 b->message_version = 2;
758 b->message_endian = BUS_NATIVE_ENDIAN;
760 /* the kernel told us the UUID of the underlying bus */
761 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
763 return bus_start_running(b);
766 int bus_kernel_connect(sd_bus *b) {
768 assert(b->input_fd < 0);
769 assert(b->output_fd < 0);
775 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
779 b->output_fd = b->input_fd;
781 return bus_kernel_take_fd(b);
784 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
786 struct kdbus_item *d;
791 off = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
792 ioctl(bus->input_fd, KDBUS_CMD_FREE, &off);
794 KDBUS_ITEM_FOREACH(d, k, items) {
796 if (d->type == KDBUS_ITEM_FDS)
797 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
798 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
799 close_nointr_nofail(d->memfd.fd);
803 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
808 assert(bus->state == BUS_RUNNING);
810 /* If we can't deliver, we want room for the error message */
811 r = bus_rqueue_make_room(bus);
815 r = bus_message_setup_kmsg(bus, m);
819 /* If this is a synchronous method call, then let's tell the
820 * kernel, so that it can pass CPU time/scheduling to the
821 * destination for the time, if it wants to. If we
822 * synchronously wait for the result anyway, we won't need CPU
825 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
827 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
829 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
830 sd_bus_message *reply;
832 if (errno == EAGAIN || errno == EINTR)
834 else if (errno == ENXIO || errno == ESRCH) {
836 /* ENXIO: unique name not known
837 * ESRCH: well-known name not known */
839 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
840 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
842 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
846 } else if (errno == EADDRNOTAVAIL) {
848 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
850 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
851 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
853 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
859 r = bus_message_new_synthetic_error(
861 BUS_MESSAGE_COOKIE(m),
868 r = bus_seal_synthetic_message(bus, reply);
872 bus->rqueue[bus->rqueue_size++] = reply;
874 } else if (hint_sync_call) {
877 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
880 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
882 r = bus_kernel_make_message(bus, k);
884 close_kdbus_msg(bus, k);
886 /* Anybody can send us invalid messages, let's just drop them. */
887 if (r == -EBADMSG || r == -EPROTOTYPE)
888 log_debug("Ignoring invalid message: %s", strerror(-r));
893 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
894 close_kdbus_msg(bus, k);
901 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
902 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
907 r = sd_bus_message_new_signal(
909 "/org/freedesktop/DBus",
910 "org.freedesktop.DBus",
916 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
920 m->sender = "org.freedesktop.DBus";
922 r = bus_seal_synthetic_message(bus, m);
926 bus->rqueue[bus->rqueue_size++] = m;
932 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
933 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
939 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
942 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old.id);
944 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
946 if (isempty(old_owner))
951 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new.id);
953 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
956 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
957 char owner[UNIQUE_NAME_MAX];
963 sprintf(owner, ":1.%llu", d->id_change.id);
965 return push_name_owner_changed(
967 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
968 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
971 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
972 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
979 r = bus_message_new_synthetic_error(
982 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
983 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
984 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
989 m->sender = "org.freedesktop.DBus";
991 r = bus_seal_synthetic_message(bus, m);
995 bus->rqueue[bus->rqueue_size++] = m;
1001 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1002 struct kdbus_item *d, *found = NULL;
1004 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1005 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1006 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1007 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1009 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1010 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1012 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1013 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1018 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1020 KDBUS_ITEM_FOREACH(d, k, items) {
1021 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1026 log_debug("Got unknown field from kernel %llu", d->type);
1030 log_debug("Didn't find a kernel message to translate.");
1034 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1037 int bus_kernel_read_message(sd_bus *bus) {
1038 struct kdbus_cmd_recv recv = {};
1039 struct kdbus_msg *k;
1044 r = bus_rqueue_make_room(bus);
1048 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1050 if (errno == EAGAIN)
1056 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1057 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1058 r = bus_kernel_make_message(bus, k);
1060 /* Anybody can send us invalid messages, let's just drop them. */
1061 if (r == -EBADMSG || r == -EPROTOTYPE) {
1062 log_debug("Ignoring invalid message: %s", strerror(-r));
1066 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1067 r = bus_kernel_translate_message(bus, k);
1069 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1074 close_kdbus_msg(bus, k);
1076 return r < 0 ? r : 1;
1079 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1080 struct memfd_cache *c;
1087 if (!bus || !bus->is_kernel)
1090 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1092 if (bus->n_memfd_cache <= 0) {
1093 _cleanup_free_ char *g = NULL;
1094 struct kdbus_cmd_memfd_make *cmd;
1095 struct kdbus_item *item;
1099 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1101 assert(bus->connection_name);
1103 g = sd_bus_label_escape(bus->connection_name);
1108 sz = ALIGN8(offsetof(struct kdbus_cmd_memfd_make, items)) +
1109 ALIGN8(offsetof(struct kdbus_item, str)) +
1115 item->size = ALIGN8(offsetof(struct kdbus_item, str)) + l + 1;
1116 item->type = KDBUS_ITEM_MEMFD_NAME;
1117 memcpy(item->str, g, l + 1);
1119 r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, cmd);
1129 c = &bus->memfd_cache[--bus->n_memfd_cache];
1132 assert(c->mapped == 0 || c->address);
1134 *address = c->address;
1135 *mapped = c->mapped;
1136 *allocated = c->allocated;
1139 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1144 static void close_and_munmap(int fd, void *address, size_t size) {
1146 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1148 close_nointr_nofail(fd);
1151 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1152 struct memfd_cache *c;
1153 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1156 assert(mapped == 0 || address);
1158 if (!bus || !bus->is_kernel) {
1159 close_and_munmap(fd, address, mapped);
1163 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1165 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1166 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1168 close_and_munmap(fd, address, mapped);
1172 c = &bus->memfd_cache[bus->n_memfd_cache++];
1174 c->address = address;
1176 /* If overly long, let's return a bit to the OS */
1177 if (mapped > max_mapped) {
1178 assert_se(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &max_mapped) >= 0);
1179 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1180 c->mapped = c->allocated = max_mapped;
1183 c->allocated = allocated;
1186 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1189 void bus_kernel_flush_memfd(sd_bus *b) {
1194 for (i = 0; i < b->n_memfd_cache; i++)
1195 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1198 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1201 assert(kdbus_flags);
1203 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1204 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1206 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1207 f |= KDBUS_NAME_REPLACE_EXISTING;
1209 if (flags & SD_BUS_NAME_QUEUE)
1210 f |= KDBUS_NAME_QUEUE;
1216 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1221 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1222 m |= KDBUS_ATTACH_CREDS;
1224 if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1225 m |= KDBUS_ATTACH_COMM;
1227 if (mask & SD_BUS_CREDS_EXE)
1228 m |= KDBUS_ATTACH_EXE;
1230 if (mask & SD_BUS_CREDS_CMDLINE)
1231 m |= KDBUS_ATTACH_CMDLINE;
1233 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))
1234 m |= KDBUS_ATTACH_CGROUP;
1236 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1237 m |= KDBUS_ATTACH_CAPS;
1239 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1240 m |= KDBUS_ATTACH_SECLABEL;
1242 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1243 m |= KDBUS_ATTACH_AUDIT;
1245 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1246 m |= KDBUS_ATTACH_NAMES;
1248 if (mask & SD_BUS_CREDS_CONNECTION_NAME)
1249 m |= KDBUS_ATTACH_CONN_NAME;
1255 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1256 struct kdbus_cmd_make *make;
1257 struct kdbus_item *n;
1263 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1267 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1268 offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1269 offsetof(struct kdbus_item, str) +
1270 DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1));
1272 make->size = offsetof(struct kdbus_cmd_make, items);
1275 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1276 n->type = KDBUS_ITEM_BLOOM_SIZE;
1277 n->data64[0] = BLOOM_SIZE;
1278 assert_cc(BLOOM_SIZE % 8 == 0);
1279 make->size += ALIGN8(n->size);
1281 n = KDBUS_ITEM_NEXT(n);
1282 sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name);
1283 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1284 n->type = KDBUS_ITEM_MAKE_NAME;
1285 make->size += ALIGN8(n->size);
1287 make->flags = KDBUS_MAKE_POLICY_OPEN | (world ? KDBUS_MAKE_ACCESS_WORLD : 0);
1289 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1290 close_nointr_nofail(fd);
1294 /* The higher 32bit of the flags field are considered
1295 * 'incompatible flags'. Refuse them all for now. */
1296 if (make->flags > 0xFFFFFFFFULL) {
1297 close_nointr_nofail(fd);
1304 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1306 close_nointr_nofail(fd);
1316 int bus_kernel_create_starter(const char *bus, const char *name) {
1317 struct kdbus_cmd_hello *hello;
1318 struct kdbus_item *n;
1325 p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1326 sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1328 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1332 hello = alloca0(ALIGN8(offsetof(struct kdbus_cmd_hello, items) +
1333 offsetof(struct kdbus_item, str) +
1337 strcpy(n->str, name);
1338 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1339 n->type = KDBUS_ITEM_NAME;
1341 hello->size = ALIGN8(offsetof(struct kdbus_cmd_hello, items) + n->size);
1342 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1343 hello->pool_size = KDBUS_POOL_SIZE;
1345 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1346 close_nointr_nofail(fd);
1350 /* The higher 32bit of both flags fields are considered
1351 * 'incompatible flags'. Refuse them all for now. */
1352 if (hello->bus_flags > 0xFFFFFFFFULL ||
1353 hello->conn_flags > 0xFFFFFFFFULL) {
1354 close_nointr_nofail(fd);
1358 if (hello->bloom_size != BLOOM_SIZE) {
1359 close_nointr_nofail(fd);
1366 int bus_kernel_create_namespace(const char *name, char **s) {
1367 struct kdbus_cmd_make *make;
1368 struct kdbus_item *n;
1374 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1378 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1379 offsetof(struct kdbus_item, str) +
1383 strcpy(n->str, name);
1384 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1385 n->type = KDBUS_ITEM_MAKE_NAME;
1387 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1388 make->flags = KDBUS_MAKE_POLICY_OPEN | KDBUS_MAKE_ACCESS_WORLD;
1390 if (ioctl(fd, KDBUS_CMD_NS_MAKE, make) < 0) {
1391 close_nointr_nofail(fd);
1395 /* The higher 32bit of the flags field are considered
1396 * 'incompatible flags'. Refuse them all for now. */
1397 if (make->flags > 0xFFFFFFFFULL) {
1398 close_nointr_nofail(fd);
1405 p = strappend("/dev/kdbus/ns/", name);
1407 close_nointr_nofail(fd);
1417 int bus_kernel_create_monitor(const char *bus) {
1418 struct kdbus_cmd_hello *hello;
1424 p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1425 sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1427 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1431 hello = alloca0(sizeof(struct kdbus_cmd_hello));
1432 hello->size = sizeof(struct kdbus_cmd_hello);
1433 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1434 hello->pool_size = KDBUS_POOL_SIZE;
1436 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1437 close_nointr_nofail(fd);
1441 /* The higher 32bit of both flags fields are considered
1442 * 'incompatible flags'. Refuse them all for now. */
1443 if (hello->bus_flags > 0xFFFFFFFFULL ||
1444 hello->conn_flags > 0xFFFFFFFFULL) {
1445 close_nointr_nofail(fd);
1452 int bus_kernel_try_close(sd_bus *bus) {
1454 assert(bus->is_kernel);
1456 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)