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");
178 *(e++) = '0' + (char) i;
180 *(e++) = '0' + (char) (i / 10);
181 *(e++) = '0' + (char) (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 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
262 m->kdbus->cookie_reply = m->reply_cookie;
264 m->kdbus->timeout_ns = m->timeout * NSEC_PER_USEC;
269 append_destination(&d, m->destination, dl);
271 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
273 MESSAGE_FOREACH_PART(part, i, m) {
275 /* If this is padding then simply send a
276 * vector with a NULL data pointer which the
277 * kernel will just pass through. This is the
278 * most efficient way to encode zeroes */
280 append_payload_vec(&d, NULL, part->size);
284 if (part->memfd >= 0 && part->sealed && m->destination) {
285 /* Try to send a memfd, if the part is
286 * sealed and this is not a broadcast. Since we can only */
288 append_payload_memfd(&d, part->memfd, part->size);
292 /* Otherwise let's send a vector to the actual data,
293 * for that we need to map it first. */
294 r = bus_body_part_map(part);
298 append_payload_vec(&d, part->data, part->size);
301 if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
304 p = append_bloom(&d, BLOOM_SIZE);
305 r = bus_message_setup_bloom(m, p);
311 append_fds(&d, m->fds, m->n_fds);
313 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
314 assert(m->kdbus->size <= sz);
323 int bus_kernel_take_fd(sd_bus *b) {
324 struct kdbus_cmd_hello *hello;
325 struct kdbus_item *item;
336 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items));
338 if (b->fake_creds_valid)
339 sz += ALIGN8(offsetof(struct kdbus_item, creds)) + sizeof(struct kdbus_creds);
342 l = strlen(b->fake_label);
343 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
348 hello->conn_flags = b->hello_flags;
349 hello->attach_flags = b->attach_flags;
350 hello->pool_size = KDBUS_POOL_SIZE;
354 if (b->fake_creds_valid) {
355 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
356 item->type = KDBUS_ITEM_CREDS;
357 item->creds = b->fake_creds;
359 item = KDBUS_ITEM_NEXT(item);
363 item->size = offsetof(struct kdbus_item, str) + l + 1;
364 memcpy(item->str, b->fake_label, l+1);
367 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
371 if (!b->kdbus_buffer) {
372 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
373 if (b->kdbus_buffer == MAP_FAILED) {
374 b->kdbus_buffer = NULL;
379 /* The higher 32bit of both flags fields are considered
380 * 'incompatible flags'. Refuse them all for now. */
381 if (hello->bus_flags > 0xFFFFFFFFULL ||
382 hello->conn_flags > 0xFFFFFFFFULL)
385 if (hello->bloom_size != BLOOM_SIZE)
388 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
391 b->unique_id = hello->id;
394 b->bus_client = true;
395 b->can_fds = !!(hello->conn_flags & KDBUS_HELLO_ACCEPT_FD);
396 b->message_version = 2;
397 b->message_endian = BUS_NATIVE_ENDIAN;
399 /* the kernel told us the UUID of the underlying bus */
400 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
402 return bus_start_running(b);
405 int bus_kernel_connect(sd_bus *b) {
407 assert(b->input_fd < 0);
408 assert(b->output_fd < 0);
414 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
418 b->output_fd = b->input_fd;
420 return bus_kernel_take_fd(b);
423 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m) {
428 assert(bus->state == BUS_RUNNING);
430 /* If we can't deliver, we want room for the error message */
431 r = bus_rqueue_make_room(bus);
435 r = bus_message_setup_kmsg(bus, m);
439 r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
441 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
442 sd_bus_message *reply;
444 if (errno == EAGAIN || errno == EINTR)
446 else if (errno == ENXIO || errno == ESRCH) {
448 /* ENXIO: unique name not known
449 * ESRCH: well-known name not known */
451 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
452 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
454 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
458 } else if (errno == EADDRNOTAVAIL) {
460 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
462 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
463 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
465 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
471 r = bus_message_new_synthetic_error(
473 BUS_MESSAGE_COOKIE(m),
480 r = bus_seal_synthetic_message(bus, reply);
484 bus->rqueue[bus->rqueue_size++] = reply;
492 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
494 struct kdbus_item *d;
499 off = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
500 ioctl(bus->input_fd, KDBUS_CMD_FREE, &off);
502 KDBUS_ITEM_FOREACH(d, k, items) {
504 if (d->type == KDBUS_ITEM_FDS)
505 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
506 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
507 close_nointr_nofail(d->memfd.fd);
511 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
512 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
517 r = sd_bus_message_new_signal(
519 "/org/freedesktop/DBus",
520 "org.freedesktop.DBus",
526 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
530 m->sender = "org.freedesktop.DBus";
532 r = bus_seal_synthetic_message(bus, m);
536 bus->rqueue[bus->rqueue_size++] = m;
542 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
543 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
549 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
552 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old.id);
554 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
556 if (isempty(old_owner))
561 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new.id);
563 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
566 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
567 char owner[UNIQUE_NAME_MAX];
573 sprintf(owner, ":1.%llu", d->id_change.id);
575 return push_name_owner_changed(
577 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
578 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
581 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
582 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
589 r = bus_message_new_synthetic_error(
592 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
593 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
594 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
599 m->sender = "org.freedesktop.DBus";
601 r = bus_seal_synthetic_message(bus, m);
605 bus->rqueue[bus->rqueue_size++] = m;
611 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
612 struct kdbus_item *d, *found = NULL;
614 static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
615 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
616 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
617 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
619 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
620 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
622 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
623 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
628 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
630 KDBUS_ITEM_FOREACH(d, k, items) {
631 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
636 log_debug("Got unknown field from kernel %llu", d->type);
640 log_debug("Didn't find a kernel message to translate.");
644 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
647 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
648 sd_bus_message *m = NULL;
649 struct kdbus_item *d;
651 _cleanup_free_ int *fds = NULL;
652 struct bus_header *h = NULL;
653 size_t total, n_bytes = 0, idx = 0;
654 const char *destination = NULL, *seclabel = NULL;
659 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
661 KDBUS_ITEM_FOREACH(d, k, items) {
664 l = d->size - offsetof(struct kdbus_item, data);
668 case KDBUS_ITEM_PAYLOAD_OFF:
670 h = (struct bus_header *)((uint8_t *)k + d->vec.offset);
672 if (!bus_header_is_complete(h, d->vec.size))
676 n_bytes += d->vec.size;
679 case KDBUS_ITEM_PAYLOAD_MEMFD:
683 n_bytes += d->memfd.size;
686 case KDBUS_ITEM_FDS: {
691 f = realloc(fds, sizeof(int) * (n_fds + j));
696 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
701 case KDBUS_ITEM_SECLABEL:
710 r = bus_header_message_size(h, &total);
714 if (n_bytes != total)
717 /* on kdbus we only speak native endian gvariant, never dbus1
718 * marshalling or reverse endian */
719 if (h->version != 2 ||
720 h->endian != BUS_NATIVE_ENDIAN)
723 r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
727 /* The well-known names list is different from the other
728 credentials. If we asked for it, but nothing is there, this
729 means that the list of well-known names is simply empty, not
730 that we lack any data */
732 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
734 KDBUS_ITEM_FOREACH(d, k, items) {
737 l = d->size - offsetof(struct kdbus_item, data);
741 case KDBUS_ITEM_PAYLOAD_OFF: {
744 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
746 if (idx + d->vec.size > begin_body) {
747 struct bus_body_part *part;
749 /* Contains body material */
751 part = message_append_part(m);
757 /* A -1 offset is NUL padding. */
758 part->is_zero = d->vec.offset == ~0ULL;
760 if (idx >= begin_body) {
762 part->data = (uint8_t *)k + d->vec.offset;
763 part->size = d->vec.size;
766 part->data = (uint8_t *)k + d->vec.offset + (begin_body - idx);
767 part->size = d->vec.size - (begin_body - idx);
777 case KDBUS_ITEM_PAYLOAD_MEMFD: {
778 struct bus_body_part *part;
780 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
785 part = message_append_part(m);
791 part->memfd = d->memfd.fd;
792 part->size = d->memfd.size;
795 idx += d->memfd.size;
799 case KDBUS_ITEM_CREDS:
800 /* UID/GID/PID are always valid */
801 m->creds.uid = (uid_t) d->creds.uid;
802 m->creds.gid = (gid_t) d->creds.gid;
803 m->creds.pid = (pid_t) d->creds.pid;
804 m->creds.mask |= (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID) & bus->creds_mask;
806 /* The PID starttime/TID might be missing
807 * however, when the data is faked by some
808 * data bus proxy and it lacks that
809 * information about the real client since
810 * SO_PEERCRED is used for that */
812 if (d->creds.starttime > 0) {
813 m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
814 m->creds.mask |= SD_BUS_CREDS_PID_STARTTIME & bus->creds_mask;
817 if (d->creds.tid > 0) {
818 m->creds.tid = (pid_t) d->creds.tid;
819 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
823 case KDBUS_ITEM_TIMESTAMP:
824 m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
825 m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
828 case KDBUS_ITEM_PID_COMM:
829 m->creds.comm = d->str;
830 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
833 case KDBUS_ITEM_TID_COMM:
834 m->creds.tid_comm = d->str;
835 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
839 m->creds.exe = d->str;
840 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
843 case KDBUS_ITEM_CMDLINE:
844 m->creds.cmdline = d->str;
845 m->creds.cmdline_size = l;
846 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
849 case KDBUS_ITEM_CGROUP:
850 m->creds.cgroup = d->str;
851 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;
853 if (!bus->cgroup_root) {
854 r = cg_get_root_path(&bus->cgroup_root);
859 m->creds.cgroup_root = bus->cgroup_root;
863 case KDBUS_ITEM_AUDIT:
864 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
865 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
866 m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
869 case KDBUS_ITEM_CAPS:
870 m->creds.capability = d->data;
871 m->creds.capability_size = l;
872 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;
875 case KDBUS_ITEM_DST_NAME:
876 if (!service_name_is_valid(d->str))
879 destination = d->str;
882 case KDBUS_ITEM_NAME:
883 if (!service_name_is_valid(d->name.name))
886 r = strv_extend(&m->creds.well_known_names, d->name.name);
892 case KDBUS_ITEM_SECLABEL:
896 log_debug("Got unknown field from kernel %llu", d->type);
900 r = bus_message_parse_fields(m);
904 /* Override information from the user header with data from the kernel */
905 if (k->src_id == KDBUS_SRC_ID_KERNEL)
906 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
908 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
909 m->sender = m->creds.unique_name = m->sender_buffer;
913 m->destination = destination;
914 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
915 m->destination = NULL;
916 else if (k->dst_id == KDBUS_DST_ID_NAME)
917 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
919 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
920 m->destination = m->destination_buffer;
923 /* We take possession of the kmsg struct now */
925 m->release_kdbus = true;
929 bus->rqueue[bus->rqueue_size++] = m;
935 struct bus_body_part *part;
938 /* Make sure the memfds are not freed twice */
939 MESSAGE_FOREACH_PART(part, i, m)
940 if (part->memfd >= 0)
943 sd_bus_message_unref(m);
949 int bus_kernel_read_message(sd_bus *bus) {
956 r = bus_rqueue_make_room(bus);
960 r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &off);
967 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + off);
969 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
970 r = bus_kernel_make_message(bus, k);
972 /* Anybody can send us invalid messages, let's just drop them. */
973 if (r == -EBADMSG || r == -EPROTOTYPE) {
974 log_debug("Ignoring invalid message: %s", strerror(-r));
978 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
979 r = bus_kernel_translate_message(bus, k);
984 close_kdbus_msg(bus, k);
986 return r < 0 ? r : 1;
989 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
990 struct memfd_cache *c;
997 if (!bus || !bus->is_kernel)
1000 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1002 if (bus->n_memfd_cache <= 0) {
1005 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1007 r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, &fd);
1017 c = &bus->memfd_cache[--bus->n_memfd_cache];
1020 assert(c->mapped == 0 || c->address);
1022 *address = c->address;
1023 *mapped = c->mapped;
1024 *allocated = c->allocated;
1027 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1032 static void close_and_munmap(int fd, void *address, size_t size) {
1034 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1036 close_nointr_nofail(fd);
1039 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1040 struct memfd_cache *c;
1041 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1044 assert(mapped == 0 || address);
1046 if (!bus || !bus->is_kernel) {
1047 close_and_munmap(fd, address, mapped);
1051 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1053 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1054 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1056 close_and_munmap(fd, address, mapped);
1060 c = &bus->memfd_cache[bus->n_memfd_cache++];
1062 c->address = address;
1064 /* If overly long, let's return a bit to the OS */
1065 if (mapped > max_mapped) {
1066 assert_se(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &max_mapped) >= 0);
1067 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1068 c->mapped = c->allocated = max_mapped;
1071 c->allocated = allocated;
1074 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1077 void bus_kernel_flush_memfd(sd_bus *b) {
1082 for (i = 0; i < b->n_memfd_cache; i++)
1083 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1086 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1089 assert(kdbus_flags);
1091 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1092 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1094 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1095 f |= KDBUS_NAME_REPLACE_EXISTING;
1097 if (flags & SD_BUS_NAME_QUEUE)
1098 f |= KDBUS_NAME_QUEUE;
1104 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1109 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1110 m |= KDBUS_ATTACH_CREDS;
1112 if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1113 m |= KDBUS_ATTACH_COMM;
1115 if (mask & SD_BUS_CREDS_EXE)
1116 m |= KDBUS_ATTACH_EXE;
1118 if (mask & SD_BUS_CREDS_CMDLINE)
1119 m |= KDBUS_ATTACH_CMDLINE;
1121 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))
1122 m |= KDBUS_ATTACH_CGROUP;
1124 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1125 m |= KDBUS_ATTACH_CAPS;
1127 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1128 m |= KDBUS_ATTACH_SECLABEL;
1130 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1131 m |= KDBUS_ATTACH_AUDIT;
1133 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1134 m |= KDBUS_ATTACH_NAMES;
1140 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1141 struct kdbus_cmd_make *make;
1142 struct kdbus_item *n;
1148 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1152 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1153 offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1154 offsetof(struct kdbus_item, str) +
1155 DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1));
1157 make->size = offsetof(struct kdbus_cmd_make, items);
1160 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1161 n->type = KDBUS_ITEM_BLOOM_SIZE;
1162 n->data64[0] = BLOOM_SIZE;
1163 assert_cc(BLOOM_SIZE % 8 == 0);
1164 make->size += ALIGN8(n->size);
1166 n = KDBUS_ITEM_NEXT(n);
1167 sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name);
1168 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1169 n->type = KDBUS_ITEM_MAKE_NAME;
1170 make->size += ALIGN8(n->size);
1172 make->flags = KDBUS_MAKE_POLICY_OPEN | (world ? KDBUS_MAKE_ACCESS_WORLD : 0);
1174 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1175 close_nointr_nofail(fd);
1179 /* The higher 32bit of the flags field are considered
1180 * 'incompatible flags'. Refuse them all for now. */
1181 if (make->flags > 0xFFFFFFFFULL) {
1182 close_nointr_nofail(fd);
1189 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1191 close_nointr_nofail(fd);
1201 int bus_kernel_create_starter(const char *bus, const char *name) {
1202 struct kdbus_cmd_hello *hello;
1203 struct kdbus_item *n;
1210 p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1211 sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1213 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1217 hello = alloca0(ALIGN8(offsetof(struct kdbus_cmd_hello, items) +
1218 offsetof(struct kdbus_item, str) +
1222 strcpy(n->str, name);
1223 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1224 n->type = KDBUS_ITEM_NAME;
1226 hello->size = ALIGN8(offsetof(struct kdbus_cmd_hello, items) + n->size);
1227 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1228 hello->pool_size = KDBUS_POOL_SIZE;
1230 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1231 close_nointr_nofail(fd);
1235 /* The higher 32bit of both flags fields are considered
1236 * 'incompatible flags'. Refuse them all for now. */
1237 if (hello->bus_flags > 0xFFFFFFFFULL ||
1238 hello->conn_flags > 0xFFFFFFFFULL) {
1239 close_nointr_nofail(fd);
1243 if (hello->bloom_size != BLOOM_SIZE) {
1244 close_nointr_nofail(fd);
1251 int bus_kernel_create_namespace(const char *name, char **s) {
1252 struct kdbus_cmd_make *make;
1253 struct kdbus_item *n;
1259 fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1263 make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1264 offsetof(struct kdbus_item, str) +
1268 strcpy(n->str, name);
1269 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1270 n->type = KDBUS_ITEM_MAKE_NAME;
1272 make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1273 make->flags = KDBUS_MAKE_POLICY_OPEN | KDBUS_MAKE_ACCESS_WORLD;
1275 if (ioctl(fd, KDBUS_CMD_NS_MAKE, make) < 0) {
1276 close_nointr_nofail(fd);
1280 /* The higher 32bit of the flags field are considered
1281 * 'incompatible flags'. Refuse them all for now. */
1282 if (make->flags > 0xFFFFFFFFULL) {
1283 close_nointr_nofail(fd);
1290 p = strappend("/dev/kdbus/ns/", name);
1292 close_nointr_nofail(fd);
1302 int bus_kernel_create_monitor(const char *bus) {
1303 struct kdbus_cmd_hello *hello;
1309 p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1310 sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1312 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1316 hello = alloca0(sizeof(struct kdbus_cmd_hello));
1317 hello->size = sizeof(struct kdbus_cmd_hello);
1318 hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1319 hello->pool_size = KDBUS_POOL_SIZE;
1321 if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1322 close_nointr_nofail(fd);
1326 /* The higher 32bit of both flags fields are considered
1327 * 'incompatible flags'. Refuse them all for now. */
1328 if (hello->bus_flags > 0xFFFFFFFFULL ||
1329 hello->conn_flags > 0xFFFFFFFFULL) {
1330 close_nointr_nofail(fd);
1337 int bus_kernel_try_close(sd_bus *bus) {
1339 assert(bus->is_kernel);
1341 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)