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;
278 assert_se(clock_gettime(CLOCK_MONOTONIC_COARSE, &now) == 0);
279 m->kdbus->timeout_ns = now.tv_sec * NSEC_PER_SEC + now.tv_nsec +
280 m->timeout * NSEC_PER_USEC;
286 append_destination(&d, m->destination, dl);
288 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
290 MESSAGE_FOREACH_PART(part, i, m) {
292 /* If this is padding then simply send a
293 * vector with a NULL data pointer which the
294 * kernel will just pass through. This is the
295 * most efficient way to encode zeroes */
297 append_payload_vec(&d, NULL, part->size);
301 if (part->memfd >= 0 && part->sealed && m->destination) {
302 /* Try to send a memfd, if the part is
303 * sealed and this is not a broadcast. Since we can only */
305 append_payload_memfd(&d, part->memfd, part->size);
309 /* Otherwise, let's send a vector to the actual data.
310 * For that, we need to map it first. */
311 r = bus_body_part_map(part);
315 append_payload_vec(&d, part->data, part->size);
318 if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
319 struct kdbus_bloom_filter *bloom;
321 bloom = append_bloom(&d, m->bus->bloom_size);
322 r = bus_message_setup_bloom(m, bloom);
328 append_fds(&d, m->fds, m->n_fds);
330 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
331 assert(m->kdbus->size <= sz);
340 static void unset_memfds(struct sd_bus_message *m) {
341 struct bus_body_part *part;
346 /* Make sure the memfds are not freed twice */
347 MESSAGE_FOREACH_PART(part, i, m)
348 if (part->memfd >= 0)
352 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
353 sd_bus_message *m = NULL;
354 struct kdbus_item *d;
356 _cleanup_free_ int *fds = NULL;
357 struct bus_header *h = NULL;
358 size_t total, n_bytes = 0, idx = 0;
359 const char *destination = NULL, *seclabel = NULL;
364 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
366 KDBUS_ITEM_FOREACH(d, k, items) {
369 l = d->size - offsetof(struct kdbus_item, data);
373 case KDBUS_ITEM_PAYLOAD_OFF:
375 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
377 if (!bus_header_is_complete(h, d->vec.size))
381 n_bytes += d->vec.size;
384 case KDBUS_ITEM_PAYLOAD_MEMFD:
388 n_bytes += d->memfd.size;
391 case KDBUS_ITEM_FDS: {
396 f = realloc(fds, sizeof(int) * (n_fds + j));
401 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
406 case KDBUS_ITEM_SECLABEL:
415 r = bus_header_message_size(h, &total);
419 if (n_bytes != total)
422 /* on kdbus we only speak native endian gvariant, never dbus1
423 * marshalling or reverse endian */
424 if (h->version != 2 ||
425 h->endian != BUS_NATIVE_ENDIAN)
428 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
432 /* The well-known names list is different from the other
433 credentials. If we asked for it, but nothing is there, this
434 means that the list of well-known names is simply empty, not
435 that we lack any data */
437 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
439 KDBUS_ITEM_FOREACH(d, k, items) {
442 l = d->size - offsetof(struct kdbus_item, data);
446 case KDBUS_ITEM_PAYLOAD_OFF: {
449 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
451 if (idx + d->vec.size > begin_body) {
452 struct bus_body_part *part;
454 /* Contains body material */
456 part = message_append_part(m);
462 /* A -1 offset is NUL padding. */
463 part->is_zero = d->vec.offset == ~0ULL;
465 if (idx >= begin_body) {
467 part->data = (uint8_t *)k + d->vec.offset;
468 part->size = d->vec.size;
471 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
472 part->size = d->vec.size - (begin_body - idx);
482 case KDBUS_ITEM_PAYLOAD_MEMFD: {
483 struct bus_body_part *part;
485 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
490 part = message_append_part(m);
496 part->memfd = d->memfd.fd;
497 part->size = d->memfd.size;
500 idx += d->memfd.size;
504 case KDBUS_ITEM_CREDS:
505 /* UID/GID/PID are always valid */
506 m->creds.uid = (uid_t) d->creds.uid;
507 m->creds.gid = (gid_t) d->creds.gid;
508 m->creds.pid = (pid_t) d->creds.pid;
509 m->creds.mask |= (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID) & bus->creds_mask;
511 /* The PID starttime/TID might be missing
512 * however, when the data is faked by some
513 * data bus proxy and it lacks that
514 * information about the real client since
515 * SO_PEERCRED is used for that */
517 if (d->creds.starttime > 0) {
518 m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
519 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
522 if (d->creds.tid > 0) {
523 m->creds.tid = (pid_t) d->creds.tid;
524 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
528 case KDBUS_ITEM_TIMESTAMP:
530 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
531 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
532 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
533 m->seqnum = d->timestamp.seqnum;
538 case KDBUS_ITEM_PID_COMM:
539 m->creds.comm = d->str;
540 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
543 case KDBUS_ITEM_TID_COMM:
544 m->creds.tid_comm = d->str;
545 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
549 m->creds.exe = d->str;
550 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
553 case KDBUS_ITEM_CMDLINE:
554 m->creds.cmdline = d->str;
555 m->creds.cmdline_size = l;
556 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
559 case KDBUS_ITEM_CGROUP:
560 m->creds.cgroup = d->str;
561 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;
563 r = bus_get_root_path(bus);
567 m->creds.cgroup_root = bus->cgroup_root;
571 case KDBUS_ITEM_AUDIT:
572 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
573 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
574 m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
577 case KDBUS_ITEM_CAPS:
578 m->creds.capability = (uint8_t *) d->caps.caps;
579 m->creds.capability_size = d->size - offsetof(struct kdbus_item, caps.caps);
580 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;
583 case KDBUS_ITEM_DST_NAME:
584 if (!service_name_is_valid(d->str))
587 destination = d->str;
590 case KDBUS_ITEM_NAME:
591 if (!service_name_is_valid(d->name.name))
594 r = strv_extend(&m->creds.well_known_names, d->name.name);
599 case KDBUS_ITEM_CONN_NAME:
600 m->creds.conn_name = d->str;
601 m->creds.mask |= SD_BUS_CREDS_CONNECTION_NAME & bus->creds_mask;
605 case KDBUS_ITEM_SECLABEL:
609 log_debug("Got unknown field from kernel %llu", d->type);
613 r = bus_message_parse_fields(m);
617 /* Override information from the user header with data from the kernel */
618 if (k->src_id == KDBUS_SRC_ID_KERNEL)
619 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
621 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
622 m->sender = m->creds.unique_name = m->sender_buffer;
626 m->destination = destination;
627 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
628 m->destination = NULL;
629 else if (k->dst_id == KDBUS_DST_ID_NAME)
630 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
632 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
633 m->destination = m->destination_buffer;
636 /* We take possession of the kmsg struct now */
638 m->release_kdbus = true;
642 bus->rqueue[bus->rqueue_size++] = m;
648 sd_bus_message_unref(m);
653 int bus_kernel_take_fd(sd_bus *b) {
654 struct kdbus_cmd_hello *hello;
655 struct kdbus_item *item;
656 _cleanup_free_ char *g = NULL;
658 size_t l = 0, m = 0, sz;
668 if (b->connection_name) {
669 g = bus_label_escape(b->connection_name);
677 /* If no name is explicitly set, we'll include a hint
678 * indicating the library implementation, a hint which
679 * kind of bus this is and the thread name */
681 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
684 name = b->is_system ? "sd-system" :
685 b->is_user ? "sd-user" : "sd";
687 _cleanup_free_ char *e = NULL;
689 e = bus_label_escape(pr);
693 g = strappend(b->is_system ? "sd-system-" :
694 b->is_user ? "sd-user-" : "sd-",
702 b->connection_name = bus_label_unescape(name);
703 if (!b->connection_name)
709 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
710 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
712 if (b->fake_creds_valid)
713 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
716 l = strlen(b->fake_label);
717 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
720 hello = alloca0_align(sz, 8);
722 hello->flags = b->hello_flags;
723 hello->attach_flags = b->attach_flags;
724 hello->pool_size = KDBUS_POOL_SIZE;
728 item->size = offsetof(struct kdbus_item, str) + m + 1;
729 item->type = KDBUS_ITEM_CONN_NAME;
730 memcpy(item->str, name, m + 1);
731 item = KDBUS_ITEM_NEXT(item);
733 if (b->fake_creds_valid) {
734 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
735 item->type = KDBUS_ITEM_CREDS;
736 item->creds = b->fake_creds;
738 item = KDBUS_ITEM_NEXT(item);
742 item->size = offsetof(struct kdbus_item, str) + l + 1;
743 item->type = KDBUS_ITEM_SECLABEL;
744 memcpy(item->str, b->fake_label, l+1);
747 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
751 if (!b->kdbus_buffer) {
752 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
753 if (b->kdbus_buffer == MAP_FAILED) {
754 b->kdbus_buffer = NULL;
759 /* The higher 32bit of the bus_flags fields are considered
760 * 'incompatible flags'. Refuse them all for now. */
761 if (hello->bus_flags > 0xFFFFFFFFULL)
764 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
767 b->bloom_size = (size_t) hello->bloom.size;
768 b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
770 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
773 b->unique_id = hello->id;
776 b->bus_client = true;
777 b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
778 b->message_version = 2;
779 b->message_endian = BUS_NATIVE_ENDIAN;
781 /* the kernel told us the UUID of the underlying bus */
782 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
784 return bus_start_running(b);
787 int bus_kernel_connect(sd_bus *b) {
789 assert(b->input_fd < 0);
790 assert(b->output_fd < 0);
796 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
800 b->output_fd = b->input_fd;
802 return bus_kernel_take_fd(b);
805 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
806 struct kdbus_cmd_free cmd;
807 struct kdbus_item *d;
813 cmd.offset = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
815 KDBUS_ITEM_FOREACH(d, k, items) {
817 if (d->type == KDBUS_ITEM_FDS)
818 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
819 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
820 safe_close(d->memfd.fd);
823 (void) ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
826 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
831 assert(bus->state == BUS_RUNNING);
833 /* If we can't deliver, we want room for the error message */
834 r = bus_rqueue_make_room(bus);
838 r = bus_message_setup_kmsg(bus, m);
842 /* If this is a synchronous method call, then let's tell the
843 * kernel, so that it can pass CPU time/scheduling to the
844 * destination for the time, if it wants to. If we
845 * synchronously wait for the result anyway, we won't need CPU
848 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
850 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
852 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
853 sd_bus_message *reply;
855 if (errno == EAGAIN || errno == EINTR)
857 else if (errno == ENXIO || errno == ESRCH) {
859 /* ENXIO: unique name not known
860 * ESRCH: well-known name not known */
862 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
863 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
865 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
869 } else if (errno == EADDRNOTAVAIL) {
871 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
873 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
874 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
876 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
882 r = bus_message_new_synthetic_error(
884 BUS_MESSAGE_COOKIE(m),
891 r = bus_seal_synthetic_message(bus, reply);
895 bus->rqueue[bus->rqueue_size++] = reply;
897 } else if (hint_sync_call) {
900 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
903 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
905 r = bus_kernel_make_message(bus, k);
907 close_kdbus_msg(bus, k);
909 /* Anybody can send us invalid messages, let's just drop them. */
910 if (r == -EBADMSG || r == -EPROTOTYPE)
911 log_debug("Ignoring invalid message: %s", strerror(-r));
916 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
917 close_kdbus_msg(bus, k);
924 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
925 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
930 r = sd_bus_message_new_signal(
933 "/org/freedesktop/DBus",
934 "org.freedesktop.DBus",
939 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
943 m->sender = "org.freedesktop.DBus";
945 r = bus_seal_synthetic_message(bus, m);
949 bus->rqueue[bus->rqueue_size++] = m;
955 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
956 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
962 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
965 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
967 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
969 if (isempty(old_owner))
974 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
976 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
979 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
980 char owner[UNIQUE_NAME_MAX];
986 sprintf(owner, ":1.%llu", d->id_change.id);
988 return push_name_owner_changed(
990 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
991 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
994 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
995 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1002 r = bus_message_new_synthetic_error(
1005 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1006 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1007 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1012 m->sender = "org.freedesktop.DBus";
1014 r = bus_seal_synthetic_message(bus, m);
1018 bus->rqueue[bus->rqueue_size++] = m;
1024 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1025 struct kdbus_item *d, *found = NULL;
1027 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1028 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1029 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1030 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1032 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1033 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1035 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1036 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1041 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1043 KDBUS_ITEM_FOREACH(d, k, items) {
1044 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1049 log_debug("Got unknown field from kernel %llu", d->type);
1053 log_debug("Didn't find a kernel message to translate.");
1057 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1060 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1061 struct kdbus_cmd_recv recv = {};
1062 struct kdbus_msg *k;
1067 r = bus_rqueue_make_room(bus);
1071 if (hint_priority) {
1072 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1073 recv.priority = priority;
1076 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1078 if (errno == EAGAIN)
1084 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1085 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1086 r = bus_kernel_make_message(bus, k);
1088 /* Anybody can send us invalid messages, let's just drop them. */
1089 if (r == -EBADMSG || r == -EPROTOTYPE) {
1090 log_debug("Ignoring invalid message: %s", strerror(-r));
1094 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1095 r = bus_kernel_translate_message(bus, k);
1097 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1102 close_kdbus_msg(bus, k);
1104 return r < 0 ? r : 1;
1107 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1108 struct memfd_cache *c;
1115 if (!bus || !bus->is_kernel)
1118 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1120 if (bus->n_memfd_cache <= 0) {
1123 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1125 r = memfd_new(bus->connection_name);
1135 c = &bus->memfd_cache[--bus->n_memfd_cache];
1138 assert(c->mapped == 0 || c->address);
1140 *address = c->address;
1141 *mapped = c->mapped;
1142 *allocated = c->allocated;
1145 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1150 static void close_and_munmap(int fd, void *address, size_t size) {
1152 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1157 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1158 struct memfd_cache *c;
1159 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1162 assert(mapped == 0 || address);
1164 if (!bus || !bus->is_kernel) {
1165 close_and_munmap(fd, address, mapped);
1169 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1171 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1172 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1174 close_and_munmap(fd, address, mapped);
1178 c = &bus->memfd_cache[bus->n_memfd_cache++];
1180 c->address = address;
1182 /* If overly long, let's return a bit to the OS */
1183 if (mapped > max_mapped) {
1184 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1185 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1186 c->mapped = c->allocated = max_mapped;
1189 c->allocated = allocated;
1192 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1195 void bus_kernel_flush_memfd(sd_bus *b) {
1200 for (i = 0; i < b->n_memfd_cache; i++)
1201 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1204 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1207 assert(kdbus_flags);
1209 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1210 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1212 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1213 f |= KDBUS_NAME_REPLACE_EXISTING;
1215 if (flags & SD_BUS_NAME_QUEUE)
1216 f |= KDBUS_NAME_QUEUE;
1222 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1227 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1228 m |= KDBUS_ATTACH_CREDS;
1230 if (mask & SD_BUS_CREDS_COMM)
1231 m |= KDBUS_ATTACH_PID_COMM;
1233 if (mask & SD_BUS_CREDS_TID_COMM)
1234 m |= KDBUS_ATTACH_TID_COMM;
1236 if (mask & SD_BUS_CREDS_EXE)
1237 m |= KDBUS_ATTACH_EXE;
1239 if (mask & SD_BUS_CREDS_CMDLINE)
1240 m |= KDBUS_ATTACH_CMDLINE;
1242 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))
1243 m |= KDBUS_ATTACH_CGROUP;
1245 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1246 m |= KDBUS_ATTACH_CAPS;
1248 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1249 m |= KDBUS_ATTACH_SECLABEL;
1251 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1252 m |= KDBUS_ATTACH_AUDIT;
1254 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1255 m |= KDBUS_ATTACH_NAMES;
1257 if (mask & SD_BUS_CREDS_CONNECTION_NAME)
1258 m |= KDBUS_ATTACH_CONN_NAME;
1264 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1265 struct kdbus_cmd_make *make;
1266 struct kdbus_item *n;
1272 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1276 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1277 offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1278 offsetof(struct kdbus_item, str) +
1279 DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1),
1282 make->size = offsetof(struct kdbus_cmd_make, items);
1285 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1286 sizeof(struct kdbus_bloom_parameter);
1287 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1289 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1290 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1292 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1293 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1295 make->size += ALIGN8(n->size);
1297 n = KDBUS_ITEM_NEXT(n);
1298 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1299 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1300 n->type = KDBUS_ITEM_MAKE_NAME;
1301 make->size += ALIGN8(n->size);
1303 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1305 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1313 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1325 static int bus_kernel_translate_access(BusPolicyAccess access) {
1326 assert(access >= 0);
1327 assert(access < _BUS_POLICY_ACCESS_MAX);
1331 case BUS_POLICY_ACCESS_SEE:
1332 return KDBUS_POLICY_SEE;
1334 case BUS_POLICY_ACCESS_TALK:
1335 return KDBUS_POLICY_TALK;
1337 case BUS_POLICY_ACCESS_OWN:
1338 return KDBUS_POLICY_OWN;
1341 assert_not_reached("Unknown policy access");
1345 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1351 switch (policy->type) {
1353 case BUSNAME_POLICY_TYPE_USER: {
1354 const char *user = policy->name;
1357 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1361 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1362 item->policy_access.id = uid;
1366 case BUSNAME_POLICY_TYPE_GROUP: {
1367 const char *group = policy->name;
1370 r = get_group_creds(&group, &gid);
1374 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1375 item->policy_access.id = gid;
1380 assert_not_reached("Unknown policy type");
1383 item->policy_access.access = bus_kernel_translate_access(policy->access);
1388 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1393 len = strlen("/dev/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1402 sprintf(p, "/dev/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1404 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1411 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1412 _cleanup_free_ char *path = NULL;
1413 struct kdbus_cmd_make *make;
1414 struct kdbus_item *n;
1418 fd = bus_kernel_open_bus_fd(bus_name, &path);
1422 size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1423 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(ep_name) + 1);
1425 make = alloca0_align(size, 8);
1427 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1431 n->type = KDBUS_ITEM_MAKE_NAME;
1432 n->size = offsetof(struct kdbus_item, str) + strlen(ep_name) + 1;
1433 strcpy(n->str, ep_name);
1435 if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1443 p = strjoin(dirname(path), "/", ep_name, NULL);
1455 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
1457 struct kdbus_cmd_update *update;
1458 struct kdbus_item *n;
1459 BusEndpointPolicy *po;
1464 size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
1466 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1467 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
1468 size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1471 update = alloca0_align(size, 8);
1472 update->size = size;
1476 HASHMAP_FOREACH(po, ep->policy_hash, i) {
1477 n->type = KDBUS_ITEM_NAME;
1478 n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1;
1479 strcpy(n->str, po->name);
1480 n = KDBUS_ITEM_NEXT(n);
1482 n->type = KDBUS_ITEM_POLICY_ACCESS;
1483 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1485 n->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1486 n->policy_access.access = bus_kernel_translate_access(po->access);
1487 n->policy_access.id = uid;
1489 n = KDBUS_ITEM_NEXT(n);
1492 r = ioctl(fd, KDBUS_CMD_ENDPOINT_UPDATE, update);
1499 int bus_kernel_make_starter(
1504 BusNamePolicy *policy,
1505 BusPolicyAccess world_policy) {
1507 struct kdbus_cmd_hello *hello;
1508 struct kdbus_item *n;
1509 size_t policy_cnt = 0;
1517 LIST_FOREACH(policy, po, policy)
1520 if (world_policy >= 0)
1523 size = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
1524 ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1525 policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1527 hello = alloca0_align(size, 8);
1530 strcpy(n->str, name);
1531 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1532 n->type = KDBUS_ITEM_NAME;
1533 n = KDBUS_ITEM_NEXT(n);
1535 LIST_FOREACH(policy, po, policy) {
1536 n->type = KDBUS_ITEM_POLICY_ACCESS;
1537 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1539 r = bus_kernel_translate_policy(po, n);
1543 n = KDBUS_ITEM_NEXT(n);
1546 if (world_policy >= 0) {
1547 n->type = KDBUS_ITEM_POLICY_ACCESS;
1548 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1549 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1550 n->policy_access.access = bus_kernel_translate_access(world_policy);
1555 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1556 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1557 hello->pool_size = KDBUS_POOL_SIZE;
1558 hello->attach_flags = _KDBUS_ATTACH_ALL;
1560 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1563 /* The higher 32bit of the bus_flags fields are considered
1564 * 'incompatible flags'. Refuse them all for now. */
1565 if (hello->bus_flags > 0xFFFFFFFFULL)
1568 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
1574 int bus_kernel_create_domain(const char *name, char **s) {
1575 struct kdbus_cmd_make *make;
1576 struct kdbus_item *n;
1582 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1586 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1587 offsetof(struct kdbus_item, str) +
1592 strcpy(n->str, name);
1593 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1594 n->type = KDBUS_ITEM_MAKE_NAME;
1596 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1597 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1599 if (ioctl(fd, KDBUS_CMD_DOMAIN_MAKE, make) < 0) {
1604 /* The higher 32bit of the flags field are considered
1605 * 'incompatible flags'. Refuse them all for now. */
1606 if (make->flags > 0xFFFFFFFFULL) {
1614 p = strappend("/dev/kdbus/domain/", name);
1626 int bus_kernel_try_close(sd_bus *bus) {
1628 assert(bus->is_kernel);
1630 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1636 int bus_kernel_drop_one(int fd) {
1637 struct kdbus_cmd_recv recv = {
1638 .flags = KDBUS_RECV_DROP
1643 if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0)