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 "bus-label.h"
40 #include "cgroup-util.h"
42 #define UNIQUE_NAME_MAX (3+DECIMAL_STR_MAX(uint64_t))
44 int bus_kernel_parse_unique_name(const char *s, uint64_t *id) {
50 if (!startswith(s, ":1."))
53 r = safe_atou64(s + 3, id);
60 static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) {
66 /* Note that p can be NULL, which encodes a region full of
67 * zeroes, which is useful to optimize certain padding
70 (*d)->size = offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec);
71 (*d)->type = KDBUS_ITEM_PAYLOAD_VEC;
72 (*d)->vec.address = PTR_TO_UINT64(p);
75 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
78 static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t sz) {
84 (*d)->size = offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd);
85 (*d)->type = KDBUS_ITEM_PAYLOAD_MEMFD;
86 (*d)->memfd.fd = memfd;
87 (*d)->memfd.size = sz;
89 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
92 static void append_destination(struct kdbus_item **d, const char *s, size_t length) {
98 (*d)->size = offsetof(struct kdbus_item, str) + length + 1;
99 (*d)->type = KDBUS_ITEM_DST_NAME;
100 memcpy((*d)->str, s, length + 1);
102 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
105 static struct kdbus_bloom_filter *append_bloom(struct kdbus_item **d, size_t length) {
106 struct kdbus_item *i;
112 i->size = offsetof(struct kdbus_item, bloom_filter) +
113 offsetof(struct kdbus_bloom_filter, data) +
115 i->type = KDBUS_ITEM_BLOOM_FILTER;
117 *d = (struct kdbus_item *) ((uint8_t*) i + i->size);
119 return &i->bloom_filter;
122 static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) {
128 (*d)->size = offsetof(struct kdbus_item, fds) + sizeof(int) * n_fds;
129 (*d)->type = KDBUS_ITEM_FDS;
130 memcpy((*d)->fds, fds, sizeof(int) * n_fds);
132 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
135 static int bus_message_setup_bloom(sd_bus_message *m, struct kdbus_bloom_filter *bloom) {
144 memzero(data, m->bus->bloom_size);
145 bloom->generation = 0;
147 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "message-type", bus_message_type_to_string(m->header->type));
150 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "interface", m->interface);
152 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "member", m->member);
154 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path", m->path);
155 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path);
156 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path, '/');
159 r = sd_bus_message_rewind(m, true);
163 for (i = 0; i < 64; i++) {
166 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
169 r = sd_bus_message_peek_type(m, &type, NULL);
173 if (type != SD_BUS_TYPE_STRING &&
174 type != SD_BUS_TYPE_OBJECT_PATH &&
175 type != SD_BUS_TYPE_SIGNATURE)
178 r = sd_bus_message_read_basic(m, type, &t);
182 e = stpcpy(buf, "arg");
184 *(e++) = '0' + (char) i;
186 *(e++) = '0' + (char) (i / 10);
187 *(e++) = '0' + (char) (i % 10);
191 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t);
193 strcpy(e, "-dot-prefix");
194 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t, '.');
195 strcpy(e, "-slash-prefix");
196 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t, '/');
202 static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
203 struct bus_body_part *part;
204 struct kdbus_item *d;
215 /* We put this together only once, if this message is reused
216 * we reuse the earlier-built version */
220 if (m->destination) {
221 r = bus_kernel_parse_unique_name(m->destination, &unique);
229 sz = offsetof(struct kdbus_msg, items);
231 assert_cc(ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec)) ==
232 ALIGN8(offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd)));
234 /* Add in fixed header, fields header and payload */
235 sz += (1 + m->n_body_parts) *
236 ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec));
238 /* Add space for bloom filter */
239 sz += ALIGN8(offsetof(struct kdbus_item, bloom_filter) +
240 offsetof(struct kdbus_bloom_filter, data) +
243 /* Add in well-known destination header */
245 dl = strlen(m->destination);
246 sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1);
249 /* Add space for unix fds */
251 sz += ALIGN8(offsetof(struct kdbus_item, fds) + sizeof(int)*m->n_fds);
253 m->kdbus = memalign(8, sz);
259 m->free_kdbus = true;
260 memzero(m->kdbus, sz);
263 ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) |
264 ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0);
267 m->destination ? unique : KDBUS_DST_ID_BROADCAST;
268 m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
269 m->kdbus->cookie = (uint64_t) m->header->serial;
270 m->kdbus->priority = m->priority;
272 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
273 m->kdbus->cookie_reply = m->reply_cookie;
275 m->kdbus->timeout_ns = m->timeout * NSEC_PER_USEC;
280 append_destination(&d, m->destination, dl);
282 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
284 MESSAGE_FOREACH_PART(part, i, m) {
286 /* If this is padding then simply send a
287 * vector with a NULL data pointer which the
288 * kernel will just pass through. This is the
289 * most efficient way to encode zeroes */
291 append_payload_vec(&d, NULL, part->size);
295 if (part->memfd >= 0 && part->sealed && m->destination) {
296 /* Try to send a memfd, if the part is
297 * sealed and this is not a broadcast. Since we can only */
299 append_payload_memfd(&d, part->memfd, part->size);
303 /* Otherwise, let's send a vector to the actual data.
304 * For that, we need to map it first. */
305 r = bus_body_part_map(part);
309 append_payload_vec(&d, part->data, part->size);
312 if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
313 struct kdbus_bloom_filter *bloom;
315 bloom = append_bloom(&d, m->bus->bloom_size);
316 r = bus_message_setup_bloom(m, bloom);
322 append_fds(&d, m->fds, m->n_fds);
324 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
325 assert(m->kdbus->size <= sz);
334 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
335 sd_bus_message *m = NULL;
336 struct kdbus_item *d;
338 _cleanup_free_ int *fds = NULL;
339 struct bus_header *h = NULL;
340 size_t total, n_bytes = 0, idx = 0;
341 const char *destination = NULL, *seclabel = NULL;
346 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
348 KDBUS_ITEM_FOREACH(d, k, items) {
351 l = d->size - offsetof(struct kdbus_item, data);
355 case KDBUS_ITEM_PAYLOAD_OFF:
357 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
359 if (!bus_header_is_complete(h, d->vec.size))
363 n_bytes += d->vec.size;
366 case KDBUS_ITEM_PAYLOAD_MEMFD:
370 n_bytes += d->memfd.size;
373 case KDBUS_ITEM_FDS: {
378 f = realloc(fds, sizeof(int) * (n_fds + j));
383 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
388 case KDBUS_ITEM_SECLABEL:
397 r = bus_header_message_size(h, &total);
401 if (n_bytes != total)
404 /* on kdbus we only speak native endian gvariant, never dbus1
405 * marshalling or reverse endian */
406 if (h->version != 2 ||
407 h->endian != BUS_NATIVE_ENDIAN)
410 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
414 /* The well-known names list is different from the other
415 credentials. If we asked for it, but nothing is there, this
416 means that the list of well-known names is simply empty, not
417 that we lack any data */
419 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
421 KDBUS_ITEM_FOREACH(d, k, items) {
424 l = d->size - offsetof(struct kdbus_item, data);
428 case KDBUS_ITEM_PAYLOAD_OFF: {
431 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
433 if (idx + d->vec.size > begin_body) {
434 struct bus_body_part *part;
436 /* Contains body material */
438 part = message_append_part(m);
444 /* A -1 offset is NUL padding. */
445 part->is_zero = d->vec.offset == ~0ULL;
447 if (idx >= begin_body) {
449 part->data = (uint8_t *)k + d->vec.offset;
450 part->size = d->vec.size;
453 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
454 part->size = d->vec.size - (begin_body - idx);
464 case KDBUS_ITEM_PAYLOAD_MEMFD: {
465 struct bus_body_part *part;
467 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
472 part = message_append_part(m);
478 part->memfd = d->memfd.fd;
479 part->size = d->memfd.size;
482 idx += d->memfd.size;
486 case KDBUS_ITEM_CREDS:
487 /* UID/GID/PID are always valid */
488 m->creds.uid = (uid_t) d->creds.uid;
489 m->creds.gid = (gid_t) d->creds.gid;
490 m->creds.pid = (pid_t) d->creds.pid;
491 m->creds.mask |= (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID) & bus->creds_mask;
493 /* The PID starttime/TID might be missing
494 * however, when the data is faked by some
495 * data bus proxy and it lacks that
496 * information about the real client since
497 * SO_PEERCRED is used for that */
499 if (d->creds.starttime > 0) {
500 m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
501 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
504 if (d->creds.tid > 0) {
505 m->creds.tid = (pid_t) d->creds.tid;
506 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
510 case KDBUS_ITEM_TIMESTAMP:
512 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
513 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
514 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
515 m->seqnum = d->timestamp.seqnum;
520 case KDBUS_ITEM_PID_COMM:
521 m->creds.comm = d->str;
522 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
525 case KDBUS_ITEM_TID_COMM:
526 m->creds.tid_comm = d->str;
527 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
531 m->creds.exe = d->str;
532 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
535 case KDBUS_ITEM_CMDLINE:
536 m->creds.cmdline = d->str;
537 m->creds.cmdline_size = l;
538 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
541 case KDBUS_ITEM_CGROUP:
542 m->creds.cgroup = d->str;
543 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;
545 r = bus_get_root_path(bus);
549 m->creds.cgroup_root = bus->cgroup_root;
553 case KDBUS_ITEM_AUDIT:
554 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
555 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
556 m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
559 case KDBUS_ITEM_CAPS:
560 m->creds.capability = d->data;
561 m->creds.capability_size = l;
562 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;
565 case KDBUS_ITEM_DST_NAME:
566 if (!service_name_is_valid(d->str))
569 destination = d->str;
572 case KDBUS_ITEM_NAME:
573 if (!service_name_is_valid(d->name.name))
576 r = strv_extend(&m->creds.well_known_names, d->name.name);
581 case KDBUS_ITEM_CONN_NAME:
582 m->creds.conn_name = d->str;
583 m->creds.mask |= SD_BUS_CREDS_CONNECTION_NAME & bus->creds_mask;
587 case KDBUS_ITEM_SECLABEL:
591 log_debug("Got unknown field from kernel %llu", d->type);
595 r = bus_message_parse_fields(m);
599 /* Override information from the user header with data from the kernel */
600 if (k->src_id == KDBUS_SRC_ID_KERNEL)
601 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
603 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
604 m->sender = m->creds.unique_name = m->sender_buffer;
608 m->destination = destination;
609 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
610 m->destination = NULL;
611 else if (k->dst_id == KDBUS_DST_ID_NAME)
612 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
614 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
615 m->destination = m->destination_buffer;
618 /* We take possession of the kmsg struct now */
620 m->release_kdbus = true;
624 bus->rqueue[bus->rqueue_size++] = m;
630 struct bus_body_part *part;
633 /* Make sure the memfds are not freed twice */
634 MESSAGE_FOREACH_PART(part, i, m)
635 if (part->memfd >= 0)
638 sd_bus_message_unref(m);
644 int bus_kernel_take_fd(sd_bus *b) {
645 struct kdbus_cmd_hello *hello;
646 struct kdbus_item *item;
647 _cleanup_free_ char *g = NULL;
649 size_t l = 0, m = 0, sz;
659 if (b->connection_name) {
660 g = bus_label_escape(b->connection_name);
668 /* If no name is explicitly set, we'll include a hint
669 * indicating the library implementation, a hint which
670 * kind of bus this is and the thread name */
672 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
675 name = b->is_system ? "sd-system" :
676 b->is_user ? "sd-user" : "sd";
678 _cleanup_free_ char *e = NULL;
680 e = bus_label_escape(pr);
684 g = strappend(b->is_system ? "sd-system-" :
685 b->is_user ? "sd-user-" : "sd-",
693 b->connection_name = bus_label_unescape(name);
694 if (!b->connection_name)
700 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
701 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
703 if (b->fake_creds_valid)
704 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
707 l = strlen(b->fake_label);
708 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
713 hello->conn_flags = b->hello_flags;
714 hello->attach_flags = b->attach_flags;
715 hello->pool_size = KDBUS_POOL_SIZE;
719 item->size = offsetof(struct kdbus_item, str) + m + 1;
720 item->type = KDBUS_ITEM_CONN_NAME;
721 memcpy(item->str, name, m + 1);
722 item = KDBUS_ITEM_NEXT(item);
724 if (b->fake_creds_valid) {
725 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
726 item->type = KDBUS_ITEM_CREDS;
727 item->creds = b->fake_creds;
729 item = KDBUS_ITEM_NEXT(item);
733 item->size = offsetof(struct kdbus_item, str) + l + 1;
734 item->type = KDBUS_ITEM_SECLABEL;
735 memcpy(item->str, b->fake_label, l+1);
738 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
742 if (!b->kdbus_buffer) {
743 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
744 if (b->kdbus_buffer == MAP_FAILED) {
745 b->kdbus_buffer = NULL;
750 /* The higher 32bit of both flags fields are considered
751 * 'incompatible flags'. Refuse them all for now. */
752 if (hello->bus_flags > 0xFFFFFFFFULL ||
753 hello->conn_flags > 0xFFFFFFFFULL)
756 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
759 b->bloom_size = (size_t) hello->bloom.size;
760 b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
762 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
765 b->unique_id = hello->id;
768 b->bus_client = true;
769 b->can_fds = !!(hello->conn_flags & KDBUS_HELLO_ACCEPT_FD);
770 b->message_version = 2;
771 b->message_endian = BUS_NATIVE_ENDIAN;
773 /* the kernel told us the UUID of the underlying bus */
774 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
776 return bus_start_running(b);
779 int bus_kernel_connect(sd_bus *b) {
781 assert(b->input_fd < 0);
782 assert(b->output_fd < 0);
788 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
792 b->output_fd = b->input_fd;
794 return bus_kernel_take_fd(b);
797 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
799 struct kdbus_item *d;
804 off = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
805 ioctl(bus->input_fd, KDBUS_CMD_FREE, &off);
807 KDBUS_ITEM_FOREACH(d, k, items) {
809 if (d->type == KDBUS_ITEM_FDS)
810 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
811 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
812 safe_close(d->memfd.fd);
816 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
821 assert(bus->state == BUS_RUNNING);
823 /* If we can't deliver, we want room for the error message */
824 r = bus_rqueue_make_room(bus);
828 r = bus_message_setup_kmsg(bus, m);
832 /* If this is a synchronous method call, then let's tell the
833 * kernel, so that it can pass CPU time/scheduling to the
834 * destination for the time, if it wants to. If we
835 * synchronously wait for the result anyway, we won't need CPU
838 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
840 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
842 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
843 sd_bus_message *reply;
845 if (errno == EAGAIN || errno == EINTR)
847 else if (errno == ENXIO || errno == ESRCH) {
849 /* ENXIO: unique name not known
850 * ESRCH: well-known name not known */
852 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
853 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
855 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
859 } else if (errno == EADDRNOTAVAIL) {
861 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
863 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
864 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
866 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
872 r = bus_message_new_synthetic_error(
874 BUS_MESSAGE_COOKIE(m),
881 r = bus_seal_synthetic_message(bus, reply);
885 bus->rqueue[bus->rqueue_size++] = reply;
887 } else if (hint_sync_call) {
890 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
893 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
895 r = bus_kernel_make_message(bus, k);
897 close_kdbus_msg(bus, k);
899 /* Anybody can send us invalid messages, let's just drop them. */
900 if (r == -EBADMSG || r == -EPROTOTYPE)
901 log_debug("Ignoring invalid message: %s", strerror(-r));
906 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
907 close_kdbus_msg(bus, k);
914 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
915 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
920 r = sd_bus_message_new_signal(
923 "/org/freedesktop/DBus",
924 "org.freedesktop.DBus",
929 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
933 m->sender = "org.freedesktop.DBus";
935 r = bus_seal_synthetic_message(bus, m);
939 bus->rqueue[bus->rqueue_size++] = m;
945 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
946 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
952 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
955 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old.id);
957 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
959 if (isempty(old_owner))
964 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new.id);
966 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
969 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
970 char owner[UNIQUE_NAME_MAX];
976 sprintf(owner, ":1.%llu", d->id_change.id);
978 return push_name_owner_changed(
980 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
981 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
984 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
985 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
992 r = bus_message_new_synthetic_error(
995 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
996 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
997 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1002 m->sender = "org.freedesktop.DBus";
1004 r = bus_seal_synthetic_message(bus, m);
1008 bus->rqueue[bus->rqueue_size++] = m;
1014 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1015 struct kdbus_item *d, *found = NULL;
1017 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1018 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1019 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1020 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1022 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1023 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1025 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1026 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1031 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1033 KDBUS_ITEM_FOREACH(d, k, items) {
1034 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1039 log_debug("Got unknown field from kernel %llu", d->type);
1043 log_debug("Didn't find a kernel message to translate.");
1047 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1050 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1051 struct kdbus_cmd_recv recv = {};
1052 struct kdbus_msg *k;
1057 r = bus_rqueue_make_room(bus);
1061 if (hint_priority) {
1062 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1063 recv.priority = priority;
1066 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1068 if (errno == EAGAIN)
1074 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1075 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1076 r = bus_kernel_make_message(bus, k);
1078 /* Anybody can send us invalid messages, let's just drop them. */
1079 if (r == -EBADMSG || r == -EPROTOTYPE) {
1080 log_debug("Ignoring invalid message: %s", strerror(-r));
1084 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1085 r = bus_kernel_translate_message(bus, k);
1087 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1092 close_kdbus_msg(bus, k);
1094 return r < 0 ? r : 1;
1097 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1098 struct memfd_cache *c;
1105 if (!bus || !bus->is_kernel)
1108 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1110 if (bus->n_memfd_cache <= 0) {
1111 _cleanup_free_ char *g = NULL;
1114 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1116 assert(bus->connection_name);
1118 g = bus_label_escape(bus->connection_name);
1122 r = memfd_create(g, MFD_ALLOW_SEALING);
1132 c = &bus->memfd_cache[--bus->n_memfd_cache];
1135 assert(c->mapped == 0 || c->address);
1137 *address = c->address;
1138 *mapped = c->mapped;
1139 *allocated = c->allocated;
1142 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1147 static void close_and_munmap(int fd, void *address, size_t size) {
1149 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1154 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1155 struct memfd_cache *c;
1156 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1159 assert(mapped == 0 || address);
1161 if (!bus || !bus->is_kernel) {
1162 close_and_munmap(fd, address, mapped);
1166 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1168 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1169 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1171 close_and_munmap(fd, address, mapped);
1175 c = &bus->memfd_cache[bus->n_memfd_cache++];
1177 c->address = address;
1179 /* If overly long, let's return a bit to the OS */
1180 if (mapped > max_mapped) {
1181 assert_se(ftruncate(fd, max_mapped) >= 0);
1182 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1183 c->mapped = c->allocated = max_mapped;
1186 c->allocated = allocated;
1189 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1192 void bus_kernel_flush_memfd(sd_bus *b) {
1197 for (i = 0; i < b->n_memfd_cache; i++)
1198 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1201 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1204 assert(kdbus_flags);
1206 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1207 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1209 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1210 f |= KDBUS_NAME_REPLACE_EXISTING;
1212 if (flags & SD_BUS_NAME_QUEUE)
1213 f |= KDBUS_NAME_QUEUE;
1219 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1224 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1225 m |= KDBUS_ATTACH_CREDS;
1227 if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1228 m |= KDBUS_ATTACH_COMM;
1230 if (mask & SD_BUS_CREDS_EXE)
1231 m |= KDBUS_ATTACH_EXE;
1233 if (mask & SD_BUS_CREDS_CMDLINE)
1234 m |= KDBUS_ATTACH_CMDLINE;
1236 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))
1237 m |= KDBUS_ATTACH_CGROUP;
1239 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1240 m |= KDBUS_ATTACH_CAPS;
1242 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1243 m |= KDBUS_ATTACH_SECLABEL;
1245 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1246 m |= KDBUS_ATTACH_AUDIT;
1248 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1249 m |= KDBUS_ATTACH_NAMES;
1251 if (mask & SD_BUS_CREDS_CONNECTION_NAME)
1252 m |= KDBUS_ATTACH_CONN_NAME;
1258 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1259 struct kdbus_cmd_make *make;
1260 struct kdbus_item *n;
1266 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1270 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1271 offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1272 offsetof(struct kdbus_item, str) +
1273 DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1));
1275 make->size = offsetof(struct kdbus_cmd_make, items);
1278 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1279 sizeof(struct kdbus_bloom_parameter);
1280 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1282 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1283 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1285 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1286 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1288 make->size += ALIGN8(n->size);
1290 n = KDBUS_ITEM_NEXT(n);
1291 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1292 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1293 n->type = KDBUS_ITEM_MAKE_NAME;
1294 make->size += ALIGN8(n->size);
1296 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1298 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1303 /* The higher 32bit of the flags field are considered
1304 * 'incompatible flags'. Refuse them all for now. */
1305 if (make->flags > 0xFFFFFFFFULL) {
1313 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1325 static int bus_kernel_translate_access(BusNamePolicyAccess access) {
1326 assert(access >= 0);
1327 assert(access < _BUSNAME_POLICY_ACCESS_MAX);
1331 case BUSNAME_POLICY_ACCESS_SEE:
1332 return KDBUS_POLICY_SEE;
1334 case BUSNAME_POLICY_ACCESS_TALK:
1335 return KDBUS_POLICY_TALK;
1337 case BUSNAME_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_make_starter(
1416 BusNamePolicy *policy,
1417 BusNamePolicyAccess world_policy) {
1419 struct kdbus_cmd_hello *hello;
1420 struct kdbus_item *n;
1421 size_t policy_cnt = 0;
1429 LIST_FOREACH(policy, po, policy)
1432 if (world_policy >= 0)
1435 size = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
1436 ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1437 policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1439 hello = alloca0(size);
1442 strcpy(n->str, name);
1443 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1444 n->type = KDBUS_ITEM_NAME;
1445 n = KDBUS_ITEM_NEXT(n);
1447 LIST_FOREACH(policy, po, policy) {
1448 n->type = KDBUS_ITEM_POLICY_ACCESS;
1449 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1451 r = bus_kernel_translate_policy(po, n);
1455 n = KDBUS_ITEM_NEXT(n);
1458 if (world_policy >= 0) {
1459 n->type = KDBUS_ITEM_POLICY_ACCESS;
1460 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1461 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1462 n->policy_access.access = bus_kernel_translate_access(world_policy);
1467 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1468 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1469 hello->pool_size = KDBUS_POOL_SIZE;
1470 hello->attach_flags = _KDBUS_ATTACH_ALL;
1472 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1475 /* The higher 32bit of both flags fields are considered
1476 * 'incompatible flags'. Refuse them all for now. */
1477 if (hello->bus_flags > 0xFFFFFFFFULL ||
1478 hello->conn_flags > 0xFFFFFFFFULL)
1481 if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
1487 int bus_kernel_create_domain(const char *name, char **s) {
1488 struct kdbus_cmd_make *make;
1489 struct kdbus_item *n;
1495 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1499 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1500 offsetof(struct kdbus_item, str) +
1504 strcpy(n->str, name);
1505 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1506 n->type = KDBUS_ITEM_MAKE_NAME;
1508 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1509 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1511 if (ioctl(fd, KDBUS_CMD_DOMAIN_MAKE, make) < 0) {
1516 /* The higher 32bit of the flags field are considered
1517 * 'incompatible flags'. Refuse them all for now. */
1518 if (make->flags > 0xFFFFFFFFULL) {
1526 p = strappend("/dev/kdbus/domain/", name);
1538 int bus_kernel_try_close(sd_bus *bus) {
1540 assert(bus->is_kernel);
1542 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1548 int bus_kernel_drop_one(int fd) {
1549 struct kdbus_cmd_recv recv = {
1550 .flags = KDBUS_RECV_DROP
1555 if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0)