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;
263 m->kdbus->priority = m->priority;
265 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
266 m->kdbus->cookie_reply = m->reply_cookie;
268 m->kdbus->timeout_ns = m->timeout * NSEC_PER_USEC;
273 append_destination(&d, m->destination, dl);
275 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
277 MESSAGE_FOREACH_PART(part, i, m) {
279 /* If this is padding then simply send a
280 * vector with a NULL data pointer which the
281 * kernel will just pass through. This is the
282 * most efficient way to encode zeroes */
284 append_payload_vec(&d, NULL, part->size);
288 if (part->memfd >= 0 && part->sealed && m->destination) {
289 /* Try to send a memfd, if the part is
290 * sealed and this is not a broadcast. Since we can only */
292 append_payload_memfd(&d, part->memfd, part->size);
296 /* Otherwise let's send a vector to the actual data,
297 * for that we need to map it first. */
298 r = bus_body_part_map(part);
302 append_payload_vec(&d, part->data, part->size);
305 if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
308 p = append_bloom(&d, BLOOM_SIZE);
309 r = bus_message_setup_bloom(m, p);
315 append_fds(&d, m->fds, m->n_fds);
317 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
318 assert(m->kdbus->size <= sz);
327 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
328 sd_bus_message *m = NULL;
329 struct kdbus_item *d;
331 _cleanup_free_ int *fds = NULL;
332 struct bus_header *h = NULL;
333 size_t total, n_bytes = 0, idx = 0;
334 const char *destination = NULL, *seclabel = NULL;
339 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
341 KDBUS_ITEM_FOREACH(d, k, items) {
344 l = d->size - offsetof(struct kdbus_item, data);
348 case KDBUS_ITEM_PAYLOAD_OFF:
350 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
352 if (!bus_header_is_complete(h, d->vec.size))
356 n_bytes += d->vec.size;
359 case KDBUS_ITEM_PAYLOAD_MEMFD:
363 n_bytes += d->memfd.size;
366 case KDBUS_ITEM_FDS: {
371 f = realloc(fds, sizeof(int) * (n_fds + j));
376 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
381 case KDBUS_ITEM_SECLABEL:
390 r = bus_header_message_size(h, &total);
394 if (n_bytes != total)
397 /* on kdbus we only speak native endian gvariant, never dbus1
398 * marshalling or reverse endian */
399 if (h->version != 2 ||
400 h->endian != BUS_NATIVE_ENDIAN)
403 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
407 /* The well-known names list is different from the other
408 credentials. If we asked for it, but nothing is there, this
409 means that the list of well-known names is simply empty, not
410 that we lack any data */
412 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
414 KDBUS_ITEM_FOREACH(d, k, items) {
417 l = d->size - offsetof(struct kdbus_item, data);
421 case KDBUS_ITEM_PAYLOAD_OFF: {
424 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
426 if (idx + d->vec.size > begin_body) {
427 struct bus_body_part *part;
429 /* Contains body material */
431 part = message_append_part(m);
437 /* A -1 offset is NUL padding. */
438 part->is_zero = d->vec.offset == ~0ULL;
440 if (idx >= begin_body) {
442 part->data = (uint8_t *)k + d->vec.offset;
443 part->size = d->vec.size;
446 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
447 part->size = d->vec.size - (begin_body - idx);
457 case KDBUS_ITEM_PAYLOAD_MEMFD: {
458 struct bus_body_part *part;
460 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
465 part = message_append_part(m);
471 part->memfd = d->memfd.fd;
472 part->size = d->memfd.size;
475 idx += d->memfd.size;
479 case KDBUS_ITEM_CREDS:
480 /* UID/GID/PID are always valid */
481 m->creds.uid = (uid_t) d->creds.uid;
482 m->creds.gid = (gid_t) d->creds.gid;
483 m->creds.pid = (pid_t) d->creds.pid;
484 m->creds.mask |= (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID) & bus->creds_mask;
486 /* The PID starttime/TID might be missing
487 * however, when the data is faked by some
488 * data bus proxy and it lacks that
489 * information about the real client since
490 * SO_PEERCRED is used for that */
492 if (d->creds.starttime > 0) {
493 m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
494 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
497 if (d->creds.tid > 0) {
498 m->creds.tid = (pid_t) d->creds.tid;
499 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
503 case KDBUS_ITEM_TIMESTAMP:
505 if (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
506 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
507 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
508 m->seqnum = d->timestamp.seqnum;
513 case KDBUS_ITEM_PID_COMM:
514 m->creds.comm = d->str;
515 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
518 case KDBUS_ITEM_TID_COMM:
519 m->creds.tid_comm = d->str;
520 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
524 m->creds.exe = d->str;
525 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
528 case KDBUS_ITEM_CMDLINE:
529 m->creds.cmdline = d->str;
530 m->creds.cmdline_size = l;
531 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
534 case KDBUS_ITEM_CGROUP:
535 m->creds.cgroup = d->str;
536 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;
538 if (!bus->cgroup_root) {
539 r = cg_get_root_path(&bus->cgroup_root);
544 m->creds.cgroup_root = bus->cgroup_root;
548 case KDBUS_ITEM_AUDIT:
549 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
550 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
551 m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
554 case KDBUS_ITEM_CAPS:
555 m->creds.capability = d->data;
556 m->creds.capability_size = l;
557 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;
560 case KDBUS_ITEM_DST_NAME:
561 if (!service_name_is_valid(d->str))
564 destination = d->str;
567 case KDBUS_ITEM_NAME:
568 if (!service_name_is_valid(d->name.name))
571 r = strv_extend(&m->creds.well_known_names, d->name.name);
576 case KDBUS_ITEM_CONN_NAME:
577 m->creds.conn_name = d->str;
578 m->creds.mask |= SD_BUS_CREDS_CONNECTION_NAME & bus->creds_mask;
582 case KDBUS_ITEM_SECLABEL:
586 log_debug("Got unknown field from kernel %llu", d->type);
590 r = bus_message_parse_fields(m);
594 /* Override information from the user header with data from the kernel */
595 if (k->src_id == KDBUS_SRC_ID_KERNEL)
596 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
598 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
599 m->sender = m->creds.unique_name = m->sender_buffer;
603 m->destination = destination;
604 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
605 m->destination = NULL;
606 else if (k->dst_id == KDBUS_DST_ID_NAME)
607 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
609 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
610 m->destination = m->destination_buffer;
613 /* We take possession of the kmsg struct now */
615 m->release_kdbus = true;
619 bus->rqueue[bus->rqueue_size++] = m;
625 struct bus_body_part *part;
628 /* Make sure the memfds are not freed twice */
629 MESSAGE_FOREACH_PART(part, i, m)
630 if (part->memfd >= 0)
633 sd_bus_message_unref(m);
639 int bus_kernel_take_fd(sd_bus *b) {
640 struct kdbus_cmd_hello *hello;
641 struct kdbus_item *item;
642 _cleanup_free_ char *g = NULL;
644 size_t l = 0, m = 0, sz;
654 if (b->connection_name) {
655 g = sd_bus_label_escape(b->connection_name);
663 /* If no name is explicitly set, we'll include a hint
664 * indicating the library implementation, a hint which
665 * kind of bus this is and the thread name */
667 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
670 name = b->is_system ? "sd-system" :
671 b->is_user ? "sd-user" : "sd";
673 _cleanup_free_ char *e = NULL;
675 e = sd_bus_label_escape(pr);
679 g = strappend(b->is_system ? "sd-system-" :
680 b->is_user ? "sd-user-" : "sd-",
688 b->connection_name = sd_bus_label_unescape(name);
689 if (!b->connection_name)
695 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
696 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
698 if (b->fake_creds_valid)
699 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
702 l = strlen(b->fake_label);
703 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
708 hello->conn_flags = b->hello_flags;
709 hello->attach_flags = b->attach_flags;
710 hello->pool_size = KDBUS_POOL_SIZE;
714 item->size = offsetof(struct kdbus_item, str) + m + 1;
715 item->type = KDBUS_ITEM_CONN_NAME;
716 memcpy(item->str, name, m + 1);
717 item = KDBUS_ITEM_NEXT(item);
719 if (b->fake_creds_valid) {
720 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
721 item->type = KDBUS_ITEM_CREDS;
722 item->creds = b->fake_creds;
724 item = KDBUS_ITEM_NEXT(item);
728 item->size = offsetof(struct kdbus_item, str) + l + 1;
729 item->type = KDBUS_ITEM_SECLABEL;
730 memcpy(item->str, b->fake_label, l+1);
733 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
737 if (!b->kdbus_buffer) {
738 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
739 if (b->kdbus_buffer == MAP_FAILED) {
740 b->kdbus_buffer = NULL;
745 /* The higher 32bit of both flags fields are considered
746 * 'incompatible flags'. Refuse them all for now. */
747 if (hello->bus_flags > 0xFFFFFFFFULL ||
748 hello->conn_flags > 0xFFFFFFFFULL)
751 if (hello->bloom_size != BLOOM_SIZE)
754 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
757 b->unique_id = hello->id;
760 b->bus_client = true;
761 b->can_fds = !!(hello->conn_flags & KDBUS_HELLO_ACCEPT_FD);
762 b->message_version = 2;
763 b->message_endian = BUS_NATIVE_ENDIAN;
765 /* the kernel told us the UUID of the underlying bus */
766 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
768 return bus_start_running(b);
771 int bus_kernel_connect(sd_bus *b) {
773 assert(b->input_fd < 0);
774 assert(b->output_fd < 0);
780 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
784 b->output_fd = b->input_fd;
786 return bus_kernel_take_fd(b);
789 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
791 struct kdbus_item *d;
796 off = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
797 ioctl(bus->input_fd, KDBUS_CMD_FREE, &off);
799 KDBUS_ITEM_FOREACH(d, k, items) {
801 if (d->type == KDBUS_ITEM_FDS)
802 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
803 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
804 close_nointr_nofail(d->memfd.fd);
808 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
813 assert(bus->state == BUS_RUNNING);
815 /* If we can't deliver, we want room for the error message */
816 r = bus_rqueue_make_room(bus);
820 r = bus_message_setup_kmsg(bus, m);
824 /* If this is a synchronous method call, then let's tell the
825 * kernel, so that it can pass CPU time/scheduling to the
826 * destination for the time, if it wants to. If we
827 * synchronously wait for the result anyway, we won't need CPU
830 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
832 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
834 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
835 sd_bus_message *reply;
837 if (errno == EAGAIN || errno == EINTR)
839 else if (errno == ENXIO || errno == ESRCH) {
841 /* ENXIO: unique name not known
842 * ESRCH: well-known name not known */
844 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
845 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
847 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
851 } else if (errno == EADDRNOTAVAIL) {
853 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
855 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
856 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
858 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
864 r = bus_message_new_synthetic_error(
866 BUS_MESSAGE_COOKIE(m),
873 r = bus_seal_synthetic_message(bus, reply);
877 bus->rqueue[bus->rqueue_size++] = reply;
879 } else if (hint_sync_call) {
882 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
885 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
887 r = bus_kernel_make_message(bus, k);
889 close_kdbus_msg(bus, k);
891 /* Anybody can send us invalid messages, let's just drop them. */
892 if (r == -EBADMSG || r == -EPROTOTYPE)
893 log_debug("Ignoring invalid message: %s", strerror(-r));
898 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
899 close_kdbus_msg(bus, k);
906 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
907 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
912 r = sd_bus_message_new_signal(
914 "/org/freedesktop/DBus",
915 "org.freedesktop.DBus",
921 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
925 m->sender = "org.freedesktop.DBus";
927 r = bus_seal_synthetic_message(bus, m);
931 bus->rqueue[bus->rqueue_size++] = m;
937 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
938 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
944 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
947 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old.id);
949 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
951 if (isempty(old_owner))
956 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new.id);
958 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
961 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
962 char owner[UNIQUE_NAME_MAX];
968 sprintf(owner, ":1.%llu", d->id_change.id);
970 return push_name_owner_changed(
972 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
973 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
976 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
977 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
984 r = bus_message_new_synthetic_error(
987 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
988 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
989 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
994 m->sender = "org.freedesktop.DBus";
996 r = bus_seal_synthetic_message(bus, m);
1000 bus->rqueue[bus->rqueue_size++] = m;
1006 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1007 struct kdbus_item *d, *found = NULL;
1009 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1010 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1011 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1012 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1014 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1015 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1017 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1018 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1023 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1025 KDBUS_ITEM_FOREACH(d, k, items) {
1026 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1031 log_debug("Got unknown field from kernel %llu", d->type);
1035 log_debug("Didn't find a kernel message to translate.");
1039 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1042 int bus_kernel_read_message(sd_bus *bus) {
1043 struct kdbus_cmd_recv recv = {};
1044 struct kdbus_msg *k;
1049 r = bus_rqueue_make_room(bus);
1053 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1055 if (errno == EAGAIN)
1061 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1062 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1063 r = bus_kernel_make_message(bus, k);
1065 /* Anybody can send us invalid messages, let's just drop them. */
1066 if (r == -EBADMSG || r == -EPROTOTYPE) {
1067 log_debug("Ignoring invalid message: %s", strerror(-r));
1071 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1072 r = bus_kernel_translate_message(bus, k);
1074 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1079 close_kdbus_msg(bus, k);
1081 return r < 0 ? r : 1;
1084 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1085 struct memfd_cache *c;
1092 if (!bus || !bus->is_kernel)
1095 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1097 if (bus->n_memfd_cache <= 0) {
1098 _cleanup_free_ char *g = NULL;
1099 struct kdbus_cmd_memfd_make *cmd;
1100 struct kdbus_item *item;
1104 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1106 assert(bus->connection_name);
1108 g = sd_bus_label_escape(bus->connection_name);
1113 sz = ALIGN8(offsetof(struct kdbus_cmd_memfd_make, items)) +
1114 ALIGN8(offsetof(struct kdbus_item, str)) +
1120 item->size = ALIGN8(offsetof(struct kdbus_item, str)) + l + 1;
1121 item->type = KDBUS_ITEM_MEMFD_NAME;
1122 memcpy(item->str, g, l + 1);
1124 r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, cmd);
1134 c = &bus->memfd_cache[--bus->n_memfd_cache];
1137 assert(c->mapped == 0 || c->address);
1139 *address = c->address;
1140 *mapped = c->mapped;
1141 *allocated = c->allocated;
1144 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1149 static void close_and_munmap(int fd, void *address, size_t size) {
1151 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1153 close_nointr_nofail(fd);
1156 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1157 struct memfd_cache *c;
1158 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1161 assert(mapped == 0 || address);
1163 if (!bus || !bus->is_kernel) {
1164 close_and_munmap(fd, address, mapped);
1168 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1170 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1171 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1173 close_and_munmap(fd, address, mapped);
1177 c = &bus->memfd_cache[bus->n_memfd_cache++];
1179 c->address = address;
1181 /* If overly long, let's return a bit to the OS */
1182 if (mapped > max_mapped) {
1183 assert_se(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &max_mapped) >= 0);
1184 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1185 c->mapped = c->allocated = max_mapped;
1188 c->allocated = allocated;
1191 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1194 void bus_kernel_flush_memfd(sd_bus *b) {
1199 for (i = 0; i < b->n_memfd_cache; i++)
1200 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1203 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1206 assert(kdbus_flags);
1208 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1209 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1211 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1212 f |= KDBUS_NAME_REPLACE_EXISTING;
1214 if (flags & SD_BUS_NAME_QUEUE)
1215 f |= KDBUS_NAME_QUEUE;
1221 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1226 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1227 m |= KDBUS_ATTACH_CREDS;
1229 if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1230 m |= KDBUS_ATTACH_COMM;
1232 if (mask & SD_BUS_CREDS_EXE)
1233 m |= KDBUS_ATTACH_EXE;
1235 if (mask & SD_BUS_CREDS_CMDLINE)
1236 m |= KDBUS_ATTACH_CMDLINE;
1238 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))
1239 m |= KDBUS_ATTACH_CGROUP;
1241 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1242 m |= KDBUS_ATTACH_CAPS;
1244 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1245 m |= KDBUS_ATTACH_SECLABEL;
1247 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1248 m |= KDBUS_ATTACH_AUDIT;
1250 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1251 m |= KDBUS_ATTACH_NAMES;
1253 if (mask & SD_BUS_CREDS_CONNECTION_NAME)
1254 m |= KDBUS_ATTACH_CONN_NAME;
1260 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1261 struct kdbus_cmd_make *make;
1262 struct kdbus_item *n;
1268 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1272 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1273 offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1274 offsetof(struct kdbus_item, str) +
1275 DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1));
1277 make->size = offsetof(struct kdbus_cmd_make, items);
1280 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1281 n->type = KDBUS_ITEM_BLOOM_SIZE;
1282 n->data64[0] = BLOOM_SIZE;
1283 assert_cc(BLOOM_SIZE % 8 == 0);
1284 make->size += ALIGN8(n->size);
1286 n = KDBUS_ITEM_NEXT(n);
1287 sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name);
1288 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1289 n->type = KDBUS_ITEM_MAKE_NAME;
1290 make->size += ALIGN8(n->size);
1292 make->flags = KDBUS_MAKE_POLICY_OPEN | (world ? KDBUS_MAKE_ACCESS_WORLD : 0);
1294 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1295 close_nointr_nofail(fd);
1299 /* The higher 32bit of the flags field are considered
1300 * 'incompatible flags'. Refuse them all for now. */
1301 if (make->flags > 0xFFFFFFFFULL) {
1302 close_nointr_nofail(fd);
1309 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1311 close_nointr_nofail(fd);
1321 int bus_kernel_create_starter(const char *bus, const char *name) {
1322 struct kdbus_cmd_hello *hello;
1323 struct kdbus_item *n;
1330 p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1331 sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1333 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1337 hello = alloca0(ALIGN8(offsetof(struct kdbus_cmd_hello, items) +
1338 offsetof(struct kdbus_item, str) +
1342 strcpy(n->str, name);
1343 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1344 n->type = KDBUS_ITEM_NAME;
1346 hello->size = ALIGN8(offsetof(struct kdbus_cmd_hello, items) + n->size);
1347 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1348 hello->pool_size = KDBUS_POOL_SIZE;
1350 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1351 close_nointr_nofail(fd);
1355 /* The higher 32bit of both flags fields are considered
1356 * 'incompatible flags'. Refuse them all for now. */
1357 if (hello->bus_flags > 0xFFFFFFFFULL ||
1358 hello->conn_flags > 0xFFFFFFFFULL) {
1359 close_nointr_nofail(fd);
1363 if (hello->bloom_size != BLOOM_SIZE) {
1364 close_nointr_nofail(fd);
1371 int bus_kernel_create_namespace(const char *name, char **s) {
1372 struct kdbus_cmd_make *make;
1373 struct kdbus_item *n;
1379 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1383 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1384 offsetof(struct kdbus_item, str) +
1388 strcpy(n->str, name);
1389 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1390 n->type = KDBUS_ITEM_MAKE_NAME;
1392 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1393 make->flags = KDBUS_MAKE_POLICY_OPEN | KDBUS_MAKE_ACCESS_WORLD;
1395 if (ioctl(fd, KDBUS_CMD_NS_MAKE, make) < 0) {
1396 close_nointr_nofail(fd);
1400 /* The higher 32bit of the flags field are considered
1401 * 'incompatible flags'. Refuse them all for now. */
1402 if (make->flags > 0xFFFFFFFFULL) {
1403 close_nointr_nofail(fd);
1410 p = strappend("/dev/kdbus/ns/", name);
1412 close_nointr_nofail(fd);
1422 int bus_kernel_create_monitor(const char *bus) {
1423 struct kdbus_cmd_hello *hello;
1429 p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1430 sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1432 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1436 hello = alloca0(sizeof(struct kdbus_cmd_hello));
1437 hello->size = sizeof(struct kdbus_cmd_hello);
1438 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1439 hello->pool_size = KDBUS_POOL_SIZE;
1441 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1442 close_nointr_nofail(fd);
1446 /* The higher 32bit of both flags fields are considered
1447 * 'incompatible flags'. Refuse them all for now. */
1448 if (hello->bus_flags > 0xFFFFFFFFULL ||
1449 hello->conn_flags > 0xFFFFFFFFULL) {
1450 close_nointr_nofail(fd);
1457 int bus_kernel_try_close(sd_bus *bus) {
1459 assert(bus->is_kernel);
1461 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)