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>
33 #include "bus-internal.h"
34 #include "bus-message.h"
35 #include "bus-kernel.h"
36 #include "bus-bloom.h"
38 #include "cgroup-util.h"
40 #define UNIQUE_NAME_MAX (3+DECIMAL_STR_MAX(uint64_t))
42 int bus_kernel_parse_unique_name(const char *s, uint64_t *id) {
48 if (!startswith(s, ":1."))
51 r = safe_atou64(s + 3, id);
58 static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) {
64 /* Note that p can be NULL, which encodes a region full of
65 * zeroes, which is useful to optimize certain padding
68 (*d)->size = offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec);
69 (*d)->type = KDBUS_ITEM_PAYLOAD_VEC;
70 (*d)->vec.address = PTR_TO_UINT64(p);
73 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
76 static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t sz) {
82 (*d)->size = offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd);
83 (*d)->type = KDBUS_ITEM_PAYLOAD_MEMFD;
84 (*d)->memfd.fd = memfd;
85 (*d)->memfd.size = sz;
87 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
90 static void append_destination(struct kdbus_item **d, const char *s, size_t length) {
96 (*d)->size = offsetof(struct kdbus_item, str) + length + 1;
97 (*d)->type = KDBUS_ITEM_DST_NAME;
98 memcpy((*d)->str, s, length + 1);
100 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
103 static void* append_bloom(struct kdbus_item **d, size_t length) {
110 (*d)->size = offsetof(struct kdbus_item, data) + length;
111 (*d)->type = KDBUS_ITEM_BLOOM;
114 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
119 static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) {
125 (*d)->size = offsetof(struct kdbus_item, fds) + sizeof(int) * n_fds;
126 (*d)->type = KDBUS_ITEM_FDS;
127 memcpy((*d)->fds, fds, sizeof(int) * n_fds);
129 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
132 static int bus_message_setup_bloom(sd_bus_message *m, void *bloom) {
139 memset(bloom, 0, BLOOM_SIZE);
141 bloom_add_pair(bloom, "message-type", bus_message_type_to_string(m->header->type));
144 bloom_add_pair(bloom, "interface", m->interface);
146 bloom_add_pair(bloom, "member", m->member);
148 bloom_add_pair(bloom, "path", m->path);
149 bloom_add_pair(bloom, "path-slash-prefix", m->path);
150 bloom_add_prefixes(bloom, "path-slash-prefix", m->path, '/');
153 r = sd_bus_message_rewind(m, true);
157 for (i = 0; i < 64; i++) {
160 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
163 r = sd_bus_message_peek_type(m, &type, NULL);
167 if (type != SD_BUS_TYPE_STRING &&
168 type != SD_BUS_TYPE_OBJECT_PATH &&
169 type != SD_BUS_TYPE_SIGNATURE)
172 r = sd_bus_message_read_basic(m, type, &t);
176 e = stpcpy(buf, "arg");
180 *(e++) = '0' + (i / 10);
181 *(e++) = '0' + (i % 10);
185 bloom_add_pair(bloom, buf, t);
187 strcpy(e, "-dot-prefix");
188 bloom_add_prefixes(bloom, buf, t, '.');
189 strcpy(e, "-slash-prefix");
190 bloom_add_prefixes(bloom, buf, t, '/');
196 static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
197 struct bus_body_part *part;
198 struct kdbus_item *d;
212 if (m->destination) {
213 r = bus_kernel_parse_unique_name(m->destination, &unique);
221 sz = offsetof(struct kdbus_msg, items);
223 assert_cc(ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec)) ==
224 ALIGN8(offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd)));
226 /* Add in fixed header, fields header and payload */
227 sz += (1 + m->n_body_parts) *
228 ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec));
230 /* Add space for bloom filter */
231 sz += ALIGN8(offsetof(struct kdbus_item, data) + BLOOM_SIZE);
233 /* Add in well-known destination header */
235 dl = strlen(m->destination);
236 sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1);
239 /* Add space for unix fds */
241 sz += ALIGN8(offsetof(struct kdbus_item, fds) + sizeof(int)*m->n_fds);
243 m->kdbus = memalign(8, sz);
249 m->free_kdbus = true;
250 memset(m->kdbus, 0, sz);
253 ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) |
254 ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0);
257 m->destination ? unique : KDBUS_DST_ID_BROADCAST;
258 m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
259 m->kdbus->cookie = m->header->serial;
261 m->kdbus->timeout_ns = m->timeout * NSEC_PER_USEC;
266 append_destination(&d, m->destination, dl);
268 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
270 MESSAGE_FOREACH_PART(part, i, m) {
272 /* If this is padding then simply send a
273 * vector with a NULL data pointer which the
274 * kernel will just pass through. This is the
275 * most efficient way to encode zeroes */
277 append_payload_vec(&d, NULL, part->size);
281 if (part->memfd >= 0 && part->sealed && m->destination) {
282 /* Try to send a memfd, if the part is
283 * sealed and this is not a broadcast. Since we can only */
285 append_payload_memfd(&d, part->memfd, part->size);
289 /* Otherwise let's send a vector to the actual data,
290 * for that we need to map it first. */
291 r = bus_body_part_map(part);
295 append_payload_vec(&d, part->data, part->size);
298 if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
301 p = append_bloom(&d, BLOOM_SIZE);
302 r = bus_message_setup_bloom(m, p);
308 append_fds(&d, m->fds, m->n_fds);
310 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
311 assert(m->kdbus->size <= sz);
320 int bus_kernel_take_fd(sd_bus *b) {
321 struct kdbus_cmd_hello *hello;
322 struct kdbus_item *item;
333 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items));
335 if (b->fake_creds_valid)
336 sz += ALIGN8(offsetof(struct kdbus_item, creds)) + sizeof(struct kdbus_creds);
339 l = strlen(b->fake_label);
340 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
345 hello->conn_flags = b->hello_flags;
346 hello->attach_flags = b->attach_flags;
347 hello->pool_size = KDBUS_POOL_SIZE;
351 if (b->fake_creds_valid) {
352 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
353 item->type = KDBUS_ITEM_CREDS;
354 item->creds = b->fake_creds;
356 item = KDBUS_ITEM_NEXT(item);
360 item->size = offsetof(struct kdbus_item, str) + l + 1;
361 memcpy(item->str, b->fake_label, l+1);
364 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
368 if (!b->kdbus_buffer) {
369 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
370 if (b->kdbus_buffer == MAP_FAILED) {
371 b->kdbus_buffer = NULL;
376 /* The higher 32bit of both flags fields are considered
377 * 'incompatible flags'. Refuse them all for now. */
378 if (hello->bus_flags > 0xFFFFFFFFULL ||
379 hello->conn_flags > 0xFFFFFFFFULL)
382 if (hello->bloom_size != BLOOM_SIZE)
385 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
388 b->unique_id = hello->id;
391 b->bus_client = true;
392 b->can_fds = !!(hello->conn_flags & KDBUS_HELLO_ACCEPT_FD);
393 b->message_version = 2;
394 b->message_endian = BUS_NATIVE_ENDIAN;
396 /* the kernel told us the UUID of the underlying bus */
397 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
399 return bus_start_running(b);
402 int bus_kernel_connect(sd_bus *b) {
404 assert(b->input_fd < 0);
405 assert(b->output_fd < 0);
411 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
415 b->output_fd = b->input_fd;
417 return bus_kernel_take_fd(b);
420 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m) {
425 assert(bus->state == BUS_RUNNING);
427 /* If we can't deliver, we want room for the error message */
428 r = bus_rqueue_make_room(bus);
432 r = bus_message_setup_kmsg(bus, m);
436 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
438 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
439 sd_bus_message *reply;
441 if (errno == EAGAIN || errno == EINTR)
443 else if (errno == ENXIO || errno == ESRCH) {
445 /* ENXIO: unique name not known
446 * ESRCH: well-known name not known */
448 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
449 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
451 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
455 } else if (errno == EADDRNOTAVAIL) {
457 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
459 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
460 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
462 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
468 r = bus_message_new_synthetic_error(
470 BUS_MESSAGE_SERIAL(m),
477 r = bus_seal_synthetic_message(bus, reply);
481 bus->rqueue[bus->rqueue_size++] = reply;
489 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
491 struct kdbus_item *d;
496 off = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
497 ioctl(bus->input_fd, KDBUS_CMD_FREE, &off);
499 KDBUS_ITEM_FOREACH(d, k, items) {
501 if (d->type == KDBUS_ITEM_FDS)
502 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
503 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
504 close_nointr_nofail(d->memfd.fd);
508 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
509 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
514 r = sd_bus_message_new_signal(
516 "/org/freedesktop/DBus",
517 "org.freedesktop.DBus",
523 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
527 m->sender = "org.freedesktop.DBus";
529 r = bus_seal_synthetic_message(bus, m);
533 bus->rqueue[bus->rqueue_size++] = m;
539 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
540 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
546 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
549 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old.id);
551 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
553 if (isempty(old_owner))
558 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new.id);
560 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
563 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
564 char owner[UNIQUE_NAME_MAX];
570 sprintf(owner, ":1.%llu", d->id_change.id);
572 return push_name_owner_changed(
574 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
575 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
578 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
579 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
586 r = bus_message_new_synthetic_error(
589 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
590 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
591 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
596 m->sender = "org.freedesktop.DBus";
598 r = bus_seal_synthetic_message(bus, m);
602 bus->rqueue[bus->rqueue_size++] = m;
608 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
609 struct kdbus_item *d, *found = NULL;
611 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
612 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
613 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
614 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
616 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
617 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
619 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
620 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
625 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
627 KDBUS_ITEM_FOREACH(d, k, items) {
628 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
633 log_debug("Got unknown field from kernel %llu", d->type);
637 log_debug("Didn't find a kernel message to translate.");
641 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
644 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
645 sd_bus_message *m = NULL;
646 struct kdbus_item *d;
648 _cleanup_free_ int *fds = NULL;
649 struct bus_header *h = NULL;
650 size_t total, n_bytes = 0, idx = 0;
651 const char *destination = NULL, *seclabel = NULL;
656 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
658 KDBUS_ITEM_FOREACH(d, k, items) {
661 l = d->size - offsetof(struct kdbus_item, data);
665 case KDBUS_ITEM_PAYLOAD_OFF:
667 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
669 if (!bus_header_is_complete(h, d->vec.size))
673 n_bytes += d->vec.size;
676 case KDBUS_ITEM_PAYLOAD_MEMFD:
680 n_bytes += d->memfd.size;
683 case KDBUS_ITEM_FDS: {
688 f = realloc(fds, sizeof(int) * (n_fds + j));
693 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
698 case KDBUS_ITEM_SECLABEL:
707 r = bus_header_message_size(h, &total);
711 if (n_bytes != total)
714 /* on kdbus we only speak native endian gvariant, never dbus1
715 * marshalling or reverse endian */
716 if (h->version != 2 ||
717 h->endian != BUS_NATIVE_ENDIAN)
720 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
724 /* The well-known names list is different from the other
725 credentials. If we asked for it, but nothing is there, this
726 means that the list of well-known names is simply empty, not
727 that we lack any data */
729 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
731 KDBUS_ITEM_FOREACH(d, k, items) {
734 l = d->size - offsetof(struct kdbus_item, data);
738 case KDBUS_ITEM_PAYLOAD_OFF: {
741 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
743 if (idx + d->vec.size > begin_body) {
744 struct bus_body_part *part;
746 /* Contains body material */
748 part = message_append_part(m);
754 /* A -1 offset is NUL padding. */
755 part->is_zero = d->vec.offset == ~0ULL;
757 if (idx >= begin_body) {
759 part->data = (uint8_t *)k + d->vec.offset;
760 part->size = d->vec.size;
763 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
764 part->size = d->vec.size - (begin_body - idx);
774 case KDBUS_ITEM_PAYLOAD_MEMFD: {
775 struct bus_body_part *part;
777 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
782 part = message_append_part(m);
788 part->memfd = d->memfd.fd;
789 part->size = d->memfd.size;
792 idx += d->memfd.size;
796 case KDBUS_ITEM_CREDS:
797 /* UID/GID/PID are always valid */
798 m->creds.uid = d->creds.uid;
799 m->creds.gid = d->creds.gid;
800 m->creds.pid = d->creds.pid;
801 m->creds.mask |= (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID) & bus->creds_mask;
803 /* The PID starttime/TID might be missing
804 * however, when the data is faked by some
805 * data bus proxy and it lacks that
806 * information about the real client since
807 * SO_PEERCRED is used for that */
809 if (d->creds.starttime > 0) {
810 m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
811 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
814 if (d->creds.tid > 0) {
815 m->creds.tid = d->creds.tid;
816 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
820 case KDBUS_ITEM_TIMESTAMP:
821 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
822 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
825 case KDBUS_ITEM_PID_COMM:
826 m->creds.comm = d->str;
827 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
830 case KDBUS_ITEM_TID_COMM:
831 m->creds.tid_comm = d->str;
832 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
836 m->creds.exe = d->str;
837 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
840 case KDBUS_ITEM_CMDLINE:
841 m->creds.cmdline = d->str;
842 m->creds.cmdline_size = l;
843 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
846 case KDBUS_ITEM_CGROUP:
847 m->creds.cgroup = d->str;
848 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;
850 if (!bus->cgroup_root) {
851 r = cg_get_root_path(&bus->cgroup_root);
856 m->creds.cgroup_root = bus->cgroup_root;
860 case KDBUS_ITEM_AUDIT:
861 m->creds.audit_session_id = d->audit.sessionid;
862 m->creds.audit_login_uid = d->audit.loginuid;
863 m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
866 case KDBUS_ITEM_CAPS:
867 m->creds.capability = d->data;
868 m->creds.capability_size = l;
869 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;
872 case KDBUS_ITEM_DST_NAME:
873 destination = d->str;
876 case KDBUS_ITEM_NAME:
877 r = strv_extend(&m->creds.well_known_names, d->name.name);
883 case KDBUS_ITEM_SECLABEL:
887 log_debug("Got unknown field from kernel %llu", d->type);
891 r = bus_message_parse_fields(m);
895 /* Override information from the user header with data from the kernel */
896 if (k->src_id == KDBUS_SRC_ID_KERNEL)
897 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
899 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
900 m->sender = m->creds.unique_name = m->sender_buffer;
904 m->destination = destination;
905 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
906 m->destination = NULL;
907 else if (k->dst_id == KDBUS_DST_ID_NAME)
908 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
910 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
911 m->destination = m->destination_buffer;
914 /* We take possession of the kmsg struct now */
916 m->release_kdbus = true;
920 bus->rqueue[bus->rqueue_size++] = m;
926 struct bus_body_part *part;
929 /* Make sure the memfds are not freed twice */
930 MESSAGE_FOREACH_PART(part, i, m)
931 if (part->memfd >= 0)
934 sd_bus_message_unref(m);
940 int bus_kernel_read_message(sd_bus *bus) {
947 r = bus_rqueue_make_room(bus);
951 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &off);
958 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + off);
960 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
961 r = bus_kernel_make_message(bus, k);
963 /* Anybody can send us invalid messages, let's just drop them. */
964 if (r == -EBADMSG || r == -EPROTOTYPE) {
965 log_debug("Ignoring invalid message: %s", strerror(-r));
969 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
970 r = bus_kernel_translate_message(bus, k);
975 close_kdbus_msg(bus, k);
977 return r < 0 ? r : 1;
980 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
981 struct memfd_cache *c;
988 if (!bus || !bus->is_kernel)
991 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
993 if (bus->n_memfd_cache <= 0) {
996 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
998 r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, &fd);
1008 c = &bus->memfd_cache[--bus->n_memfd_cache];
1011 assert(c->mapped == 0 || c->address);
1013 *address = c->address;
1014 *mapped = c->mapped;
1015 *allocated = c->allocated;
1018 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1023 static void close_and_munmap(int fd, void *address, size_t size) {
1025 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1027 close_nointr_nofail(fd);
1030 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1031 struct memfd_cache *c;
1032 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1035 assert(mapped == 0 || address);
1037 if (!bus || !bus->is_kernel) {
1038 close_and_munmap(fd, address, mapped);
1042 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1044 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1045 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1047 close_and_munmap(fd, address, mapped);
1051 c = &bus->memfd_cache[bus->n_memfd_cache++];
1053 c->address = address;
1055 /* If overly long, let's return a bit to the OS */
1056 if (mapped > max_mapped) {
1057 assert_se(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &max_mapped) >= 0);
1058 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1059 c->mapped = c->allocated = max_mapped;
1062 c->allocated = allocated;
1065 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1068 void bus_kernel_flush_memfd(sd_bus *b) {
1073 for (i = 0; i < b->n_memfd_cache; i++)
1074 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1077 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1080 assert(kdbus_flags);
1082 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1083 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1085 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1086 f |= KDBUS_NAME_REPLACE_EXISTING;
1088 if (flags & SD_BUS_NAME_QUEUE)
1089 f |= KDBUS_NAME_QUEUE;
1095 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1100 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1101 m |= KDBUS_ATTACH_CREDS;
1103 if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1104 m |= KDBUS_ATTACH_COMM;
1106 if (mask & SD_BUS_CREDS_EXE)
1107 m |= KDBUS_ATTACH_EXE;
1109 if (mask & SD_BUS_CREDS_CMDLINE)
1110 m |= KDBUS_ATTACH_CMDLINE;
1112 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))
1113 m |= KDBUS_ATTACH_CGROUP;
1115 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1116 m |= KDBUS_ATTACH_CAPS;
1118 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1119 m |= KDBUS_ATTACH_SECLABEL;
1121 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1122 m |= KDBUS_ATTACH_AUDIT;
1124 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1125 m |= KDBUS_ATTACH_NAMES;
1131 int bus_kernel_create_bus(const char *name, char **s) {
1132 struct kdbus_cmd_make *make;
1133 struct kdbus_item *n;
1139 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1143 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1144 offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1145 offsetof(struct kdbus_item, str) +
1146 DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1));
1148 make->size = offsetof(struct kdbus_cmd_make, items);
1151 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1152 n->type = KDBUS_ITEM_BLOOM_SIZE;
1153 n->data64[0] = BLOOM_SIZE;
1154 assert_cc(BLOOM_SIZE % 8 == 0);
1155 make->size += ALIGN8(n->size);
1157 n = KDBUS_ITEM_NEXT(n);
1158 sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name);
1159 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1160 n->type = KDBUS_ITEM_MAKE_NAME;
1161 make->size += ALIGN8(n->size);
1163 make->flags = KDBUS_MAKE_POLICY_OPEN;
1165 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1166 close_nointr_nofail(fd);
1170 /* The higher 32bit of the flags field are considered
1171 * 'incompatible flags'. Refuse them all for now. */
1172 if (make->flags > 0xFFFFFFFFULL) {
1173 close_nointr_nofail(fd);
1180 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1182 close_nointr_nofail(fd);
1192 int bus_kernel_create_starter(const char *bus, const char *name) {
1193 struct kdbus_cmd_hello *hello;
1194 struct kdbus_item *n;
1201 p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1202 sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1204 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1208 hello = alloca0(ALIGN8(offsetof(struct kdbus_cmd_hello, items) +
1209 offsetof(struct kdbus_item, str) +
1213 strcpy(n->str, name);
1214 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1215 n->type = KDBUS_ITEM_NAME;
1217 hello->size = ALIGN8(offsetof(struct kdbus_cmd_hello, items) + n->size);
1218 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1219 hello->pool_size = KDBUS_POOL_SIZE;
1221 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1222 close_nointr_nofail(fd);
1226 /* The higher 32bit of both flags fields are considered
1227 * 'incompatible flags'. Refuse them all for now. */
1228 if (hello->bus_flags > 0xFFFFFFFFULL ||
1229 hello->conn_flags > 0xFFFFFFFFULL) {
1230 close_nointr_nofail(fd);
1234 if (hello->bloom_size != BLOOM_SIZE) {
1235 close_nointr_nofail(fd);
1242 int bus_kernel_create_namespace(const char *name, char **s) {
1243 struct kdbus_cmd_make *make;
1244 struct kdbus_item *n;
1250 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1254 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1255 offsetof(struct kdbus_item, str) +
1259 strcpy(n->str, name);
1260 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1261 n->type = KDBUS_ITEM_MAKE_NAME;
1263 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1264 make->flags = KDBUS_MAKE_POLICY_OPEN | KDBUS_MAKE_ACCESS_WORLD;
1266 if (ioctl(fd, KDBUS_CMD_NS_MAKE, make) < 0) {
1267 close_nointr_nofail(fd);
1271 /* The higher 32bit of the flags field are considered
1272 * 'incompatible flags'. Refuse them all for now. */
1273 if (make->flags > 0xFFFFFFFFULL) {
1274 close_nointr_nofail(fd);
1281 p = strappend("/dev/kdbus/ns/", name);
1283 close_nointr_nofail(fd);
1293 int bus_kernel_create_monitor(const char *bus) {
1294 struct kdbus_cmd_hello *hello;
1300 p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1301 sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1303 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1307 hello = alloca0(sizeof(struct kdbus_cmd_hello));
1308 hello->size = sizeof(struct kdbus_cmd_hello);
1309 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1310 hello->pool_size = KDBUS_POOL_SIZE;
1312 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1313 close_nointr_nofail(fd);
1317 /* The higher 32bit of both flags fields are considered
1318 * 'incompatible flags'. Refuse them all for now. */
1319 if (hello->bus_flags > 0xFFFFFFFFULL ||
1320 hello->conn_flags > 0xFFFFFFFFULL) {
1321 close_nointr_nofail(fd);
1328 int bus_kernel_try_close(sd_bus *bus) {
1330 assert(bus->is_kernel);
1332 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)