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, bool hint_priority, int64_t priority) {
1043 struct kdbus_cmd_recv recv = {};
1044 struct kdbus_msg *k;
1049 r = bus_rqueue_make_room(bus);
1053 if (hint_priority) {
1054 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1055 recv.priority = priority;
1058 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1060 if (errno == EAGAIN)
1066 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1067 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1068 r = bus_kernel_make_message(bus, k);
1070 /* Anybody can send us invalid messages, let's just drop them. */
1071 if (r == -EBADMSG || r == -EPROTOTYPE) {
1072 log_debug("Ignoring invalid message: %s", strerror(-r));
1076 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1077 r = bus_kernel_translate_message(bus, k);
1079 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1084 close_kdbus_msg(bus, k);
1086 return r < 0 ? r : 1;
1089 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1090 struct memfd_cache *c;
1097 if (!bus || !bus->is_kernel)
1100 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1102 if (bus->n_memfd_cache <= 0) {
1103 _cleanup_free_ char *g = NULL;
1104 struct kdbus_cmd_memfd_make *cmd;
1105 struct kdbus_item *item;
1109 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1111 assert(bus->connection_name);
1113 g = sd_bus_label_escape(bus->connection_name);
1118 sz = ALIGN8(offsetof(struct kdbus_cmd_memfd_make, items)) +
1119 ALIGN8(offsetof(struct kdbus_item, str)) +
1125 item->size = ALIGN8(offsetof(struct kdbus_item, str)) + l + 1;
1126 item->type = KDBUS_ITEM_MEMFD_NAME;
1127 memcpy(item->str, g, l + 1);
1129 r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, cmd);
1139 c = &bus->memfd_cache[--bus->n_memfd_cache];
1142 assert(c->mapped == 0 || c->address);
1144 *address = c->address;
1145 *mapped = c->mapped;
1146 *allocated = c->allocated;
1149 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1154 static void close_and_munmap(int fd, void *address, size_t size) {
1156 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1158 close_nointr_nofail(fd);
1161 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1162 struct memfd_cache *c;
1163 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1166 assert(mapped == 0 || address);
1168 if (!bus || !bus->is_kernel) {
1169 close_and_munmap(fd, address, mapped);
1173 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1175 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1176 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1178 close_and_munmap(fd, address, mapped);
1182 c = &bus->memfd_cache[bus->n_memfd_cache++];
1184 c->address = address;
1186 /* If overly long, let's return a bit to the OS */
1187 if (mapped > max_mapped) {
1188 assert_se(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &max_mapped) >= 0);
1189 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1190 c->mapped = c->allocated = max_mapped;
1193 c->allocated = allocated;
1196 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1199 void bus_kernel_flush_memfd(sd_bus *b) {
1204 for (i = 0; i < b->n_memfd_cache; i++)
1205 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1208 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1211 assert(kdbus_flags);
1213 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1214 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1216 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1217 f |= KDBUS_NAME_REPLACE_EXISTING;
1219 if (flags & SD_BUS_NAME_QUEUE)
1220 f |= KDBUS_NAME_QUEUE;
1226 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1231 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1232 m |= KDBUS_ATTACH_CREDS;
1234 if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1235 m |= KDBUS_ATTACH_COMM;
1237 if (mask & SD_BUS_CREDS_EXE)
1238 m |= KDBUS_ATTACH_EXE;
1240 if (mask & SD_BUS_CREDS_CMDLINE)
1241 m |= KDBUS_ATTACH_CMDLINE;
1243 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))
1244 m |= KDBUS_ATTACH_CGROUP;
1246 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1247 m |= KDBUS_ATTACH_CAPS;
1249 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1250 m |= KDBUS_ATTACH_SECLABEL;
1252 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1253 m |= KDBUS_ATTACH_AUDIT;
1255 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1256 m |= KDBUS_ATTACH_NAMES;
1258 if (mask & SD_BUS_CREDS_CONNECTION_NAME)
1259 m |= KDBUS_ATTACH_CONN_NAME;
1265 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1266 struct kdbus_cmd_make *make;
1267 struct kdbus_item *n;
1273 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1277 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1278 offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1279 offsetof(struct kdbus_item, str) +
1280 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, data64) + sizeof(uint64_t);
1286 n->type = KDBUS_ITEM_BLOOM_SIZE;
1287 n->data64[0] = BLOOM_SIZE;
1288 assert_cc(BLOOM_SIZE % 8 == 0);
1289 make->size += ALIGN8(n->size);
1291 n = KDBUS_ITEM_NEXT(n);
1292 sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name);
1293 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1294 n->type = KDBUS_ITEM_MAKE_NAME;
1295 make->size += ALIGN8(n->size);
1297 make->flags = KDBUS_MAKE_POLICY_OPEN | (world ? KDBUS_MAKE_ACCESS_WORLD : 0);
1299 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1300 close_nointr_nofail(fd);
1304 /* The higher 32bit of the flags field are considered
1305 * 'incompatible flags'. Refuse them all for now. */
1306 if (make->flags > 0xFFFFFFFFULL) {
1307 close_nointr_nofail(fd);
1314 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1316 close_nointr_nofail(fd);
1326 int bus_kernel_create_starter(const char *bus, const char *name) {
1327 struct kdbus_cmd_hello *hello;
1328 struct kdbus_item *n;
1335 p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1336 sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1338 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1342 hello = alloca0(ALIGN8(offsetof(struct kdbus_cmd_hello, items) +
1343 offsetof(struct kdbus_item, str) +
1347 strcpy(n->str, name);
1348 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1349 n->type = KDBUS_ITEM_NAME;
1351 hello->size = ALIGN8(offsetof(struct kdbus_cmd_hello, items) + n->size);
1352 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1353 hello->pool_size = KDBUS_POOL_SIZE;
1355 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1356 close_nointr_nofail(fd);
1360 /* The higher 32bit of both flags fields are considered
1361 * 'incompatible flags'. Refuse them all for now. */
1362 if (hello->bus_flags > 0xFFFFFFFFULL ||
1363 hello->conn_flags > 0xFFFFFFFFULL) {
1364 close_nointr_nofail(fd);
1368 if (hello->bloom_size != BLOOM_SIZE) {
1369 close_nointr_nofail(fd);
1376 int bus_kernel_create_namespace(const char *name, char **s) {
1377 struct kdbus_cmd_make *make;
1378 struct kdbus_item *n;
1384 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1388 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1389 offsetof(struct kdbus_item, str) +
1393 strcpy(n->str, name);
1394 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1395 n->type = KDBUS_ITEM_MAKE_NAME;
1397 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1398 make->flags = KDBUS_MAKE_POLICY_OPEN | KDBUS_MAKE_ACCESS_WORLD;
1400 if (ioctl(fd, KDBUS_CMD_NS_MAKE, make) < 0) {
1401 close_nointr_nofail(fd);
1405 /* The higher 32bit of the flags field are considered
1406 * 'incompatible flags'. Refuse them all for now. */
1407 if (make->flags > 0xFFFFFFFFULL) {
1408 close_nointr_nofail(fd);
1415 p = strappend("/dev/kdbus/ns/", name);
1417 close_nointr_nofail(fd);
1427 int bus_kernel_create_monitor(const char *bus) {
1428 struct kdbus_cmd_hello *hello;
1434 p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1435 sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1437 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1441 hello = alloca0(sizeof(struct kdbus_cmd_hello));
1442 hello->size = sizeof(struct kdbus_cmd_hello);
1443 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1444 hello->pool_size = KDBUS_POOL_SIZE;
1446 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1447 close_nointr_nofail(fd);
1451 /* The higher 32bit of both flags fields are considered
1452 * 'incompatible flags'. Refuse them all for now. */
1453 if (hello->bus_flags > 0xFFFFFFFFULL ||
1454 hello->conn_flags > 0xFFFFFFFFULL) {
1455 close_nointr_nofail(fd);
1462 int bus_kernel_try_close(sd_bus *bus) {
1464 assert(bus->is_kernel);
1466 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)