]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd/sd-bus/bus-kernel.c
projects / thirdparty / systemd.git / blob
? search:


a32b0ef2218533c1008fab2c6eac81bb2fc7dcd8
[thirdparty/systemd.git] / src / libsystemd / sd-bus / bus-kernel.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2013 Lennart Poettering
7
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.
12
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.
17
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/>.
20 ***/
21
22 #ifdef HAVE_VALGRIND_MEMCHECK_H
23 #include <valgrind/memcheck.h>
24 #endif
25
26 #include <fcntl.h>
27 #include <malloc.h>
28 #include <sys/mman.h>
29 #include <sys/prctl.h>
30
31 /* When we include libgen.h because we need dirname() we immediately
32 * undefine basename() since libgen.h defines it as a macro to the POSIX
33 * version which is really broken. We prefer GNU basename(). */
34 #include <libgen.h>
35 #undef basename
36
37 #include "bus-bloom.h"
38 #include "bus-internal.h"
39 #include "bus-kernel.h"
40 #include "bus-label.h"
41 #include "bus-message.h"
42 #include "bus-util.h"
43 #include "capability-util.h"
44 #include "fd-util.h"
45 #include "fileio.h"
46 #include "formats-util.h"
47 #include "memfd-util.h"
48 #include "parse-util.h"
49 #include "string-util.h"
50 #include "strv.h"
51 #include "user-util.h"
52 #include "util.h"
53
54 #define UNIQUE_NAME_MAX (3+DECIMAL_STR_MAX(uint64_t))
55
56 int bus_kernel_parse_unique_name(const char *s, uint64_t *id) {
57 int r;
58
59 assert(s);
60 assert(id);
61
62 if (!startswith(s, ":1."))
63 return 0;
64
65 r = safe_atou64(s + 3, id);
66 if (r < 0)
67 return r;
68
69 return 1;
70 }
71
72 static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) {
73 assert(d);
74 assert(sz > 0);
75
76 *d = ALIGN8_PTR(*d);
77
78 /* Note that p can be NULL, which encodes a region full of
79 * zeroes, which is useful to optimize certain padding
80 * conditions */
81
82 (*d)->size = offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec);
83 (*d)->type = KDBUS_ITEM_PAYLOAD_VEC;
84 (*d)->vec.address = PTR_TO_UINT64(p);
85 (*d)->vec.size = sz;
86
87 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
88 }
89
90 static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t start, size_t sz) {
91 assert(d);
92 assert(memfd >= 0);
93 assert(sz > 0);
94
95 *d = ALIGN8_PTR(*d);
96 (*d)->size = offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd);
97 (*d)->type = KDBUS_ITEM_PAYLOAD_MEMFD;
98 (*d)->memfd.fd = memfd;
99 (*d)->memfd.start = start;
100 (*d)->memfd.size = sz;
101
102 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
103 }
104
105 static void append_destination(struct kdbus_item **d, const char *s, size_t length) {
106 assert(d);
107 assert(s);
108
109 *d = ALIGN8_PTR(*d);
110
111 (*d)->size = offsetof(struct kdbus_item, str) + length + 1;
112 (*d)->type = KDBUS_ITEM_DST_NAME;
113 memcpy((*d)->str, s, length + 1);
114
115 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
116 }
117
118 static struct kdbus_bloom_filter *append_bloom(struct kdbus_item **d, size_t length) {
119 struct kdbus_item *i;
120
121 assert(d);
122
123 i = ALIGN8_PTR(*d);
124
125 i->size = offsetof(struct kdbus_item, bloom_filter) +
126 offsetof(struct kdbus_bloom_filter, data) +
127 length;
128 i->type = KDBUS_ITEM_BLOOM_FILTER;
129
130 *d = (struct kdbus_item *) ((uint8_t*) i + i->size);
131
132 return &i->bloom_filter;
133 }
134
135 static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) {
136 assert(d);
137 assert(fds);
138 assert(n_fds > 0);
139
140 *d = ALIGN8_PTR(*d);
141 (*d)->size = offsetof(struct kdbus_item, fds) + sizeof(int) * n_fds;
142 (*d)->type = KDBUS_ITEM_FDS;
143 memcpy((*d)->fds, fds, sizeof(int) * n_fds);
144
145 *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
146 }
147
148 static void add_bloom_arg(void *data, size_t size, unsigned n_hash, unsigned i, const char *t) {
149 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
150 char *e;
151
152 assert(data);
153 assert(size > 0);
154 assert(i < 64);
155 assert(t);
156
157 e = stpcpy(buf, "arg");
158 if (i < 10)
159 *(e++) = '0' + (char) i;
160 else {
161 *(e++) = '0' + (char) (i / 10);
162 *(e++) = '0' + (char) (i % 10);
163 }
164
165 *e = 0;
166 bloom_add_pair(data, size, n_hash, buf, t);
167
168 strcpy(e, "-dot-prefix");
169 bloom_add_prefixes(data, size, n_hash, buf, t, '.');
170 strcpy(e, "-slash-prefix");
171 bloom_add_prefixes(data, size, n_hash, buf, t, '/');
172 }
173
174 static void add_bloom_arg_has(void *data, size_t size, unsigned n_hash, unsigned i, const char *t) {
175 char buf[sizeof("arg")-1 + 2 + sizeof("-has")];
176 char *e;
177
178 assert(data);
179 assert(size > 0);
180 assert(i < 64);
181 assert(t);
182
183 e = stpcpy(buf, "arg");
184 if (i < 10)
185 *(e++) = '0' + (char) i;
186 else {
187 *(e++) = '0' + (char) (i / 10);
188 *(e++) = '0' + (char) (i % 10);
189 }
190
191 strcpy(e, "-has");
192 bloom_add_pair(data, size, n_hash, buf, t);
193 }
194
195 static int bus_message_setup_bloom(sd_bus_message *m, struct kdbus_bloom_filter *bloom) {
196 void *data;
197 unsigned i;
198 int r;
199
200 assert(m);
201 assert(bloom);
202
203 data = bloom->data;
204 memzero(data, m->bus->bloom_size);
205 bloom->generation = 0;
206
207 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "message-type", bus_message_type_to_string(m->header->type));
208
209 if (m->interface)
210 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "interface", m->interface);
211 if (m->member)
212 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "member", m->member);
213 if (m->path) {
214 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path", m->path);
215 bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path);
216 bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path, '/');
217 }
218
219 r = sd_bus_message_rewind(m, true);
220 if (r < 0)
221 return r;
222
223 for (i = 0; i < 64; i++) {
224 const char *t, *contents;
225 char type;
226
227 r = sd_bus_message_peek_type(m, &type, &contents);
228 if (r < 0)
229 return r;
230
231 if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE)) {
232
233 /* The bloom filter includes simple strings of any kind */
234 r = sd_bus_message_read_basic(m, type, &t);
235 if (r < 0)
236 return r;
237
238 add_bloom_arg(data, m->bus->bloom_size, m->bus->bloom_n_hash, i, t);
239 }
240
241 if (type == SD_BUS_TYPE_ARRAY && STR_IN_SET(contents, "s", "o", "g")) {
242
243 /* As well as array of simple strings of any kinds */
244 r = sd_bus_message_enter_container(m, type, contents);
245 if (r < 0)
246 return r;
247
248 while ((r = sd_bus_message_read_basic(m, contents[0], &t)) > 0)
249 add_bloom_arg_has(data, m->bus->bloom_size, m->bus->bloom_n_hash, i, t);
250 if (r < 0)
251 return r;
252
253 r = sd_bus_message_exit_container(m);
254 if (r < 0)
255 return r;
256
257 } else
258 /* Stop adding to bloom filter as soon as we
259 * run into the first argument we cannot add
260 * to it. */
261 break;
262 }
263
264 return 0;
265 }
266
267 static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
268 struct bus_body_part *part;
269 struct kdbus_item *d;
270 const char *destination;
271 bool well_known;
272 uint64_t unique;
273 size_t sz, dl;
274 unsigned i;
275 int r;
276
277 assert(b);
278 assert(m);
279 assert(m->sealed);
280
281 /* We put this together only once, if this message is reused
282 * we reuse the earlier-built version */
283 if (m->kdbus)
284 return 0;
285
286 destination = m->destination ?: m->destination_ptr;
287
288 if (destination) {
289 r = bus_kernel_parse_unique_name(destination, &unique);
290 if (r < 0)
291 return r;
292
293 well_known = r == 0;
294 } else
295 well_known = false;
296
297 sz = offsetof(struct kdbus_msg, items);
298
299 /* Add in fixed header, fields header and payload */
300 sz += (1 + m->n_body_parts) * ALIGN8(offsetof(struct kdbus_item, vec) +
301 MAX(sizeof(struct kdbus_vec),
302 sizeof(struct kdbus_memfd)));
303
304 /* Add space for bloom filter */
305 sz += ALIGN8(offsetof(struct kdbus_item, bloom_filter) +
306 offsetof(struct kdbus_bloom_filter, data) +
307 m->bus->bloom_size);
308
309 /* Add in well-known destination header */
310 if (well_known) {
311 dl = strlen(destination);
312 sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1);
313 }
314
315 /* Add space for unix fds */
316 if (m->n_fds > 0)
317 sz += ALIGN8(offsetof(struct kdbus_item, fds) + sizeof(int)*m->n_fds);
318
319 m->kdbus = memalign(8, sz);
320 if (!m->kdbus) {
321 r = -ENOMEM;
322 goto fail;
323 }
324
325 m->free_kdbus = true;
326 memzero(m->kdbus, sz);
327
328 m->kdbus->flags =
329 ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_EXPECT_REPLY) |
330 ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_NO_AUTO_START : 0) |
331 ((m->header->type == SD_BUS_MESSAGE_SIGNAL) ? KDBUS_MSG_SIGNAL : 0);
332
333 if (well_known)
334 /* verify_destination_id will usually be 0, which makes the kernel driver only look
335 * at the provided well-known name. Otherwise, the kernel will make sure the provided
336 * destination id matches the owner of the provided weel-known-name, and fail if they
337 * differ. Currently, this is only needed for bus-proxyd. */
338 m->kdbus->dst_id = m->verify_destination_id;
339 else
340 m->kdbus->dst_id = destination ? unique : KDBUS_DST_ID_BROADCAST;
341
342 m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
343 m->kdbus->cookie = m->header->dbus2.cookie;
344 m->kdbus->priority = m->priority;
345
346 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
347 m->kdbus->cookie_reply = m->reply_cookie;
348 else {
349 struct timespec now;
350
351 assert_se(clock_gettime(CLOCK_MONOTONIC_COARSE, &now) == 0);
352 m->kdbus->timeout_ns = now.tv_sec * NSEC_PER_SEC + now.tv_nsec +
353 m->timeout * NSEC_PER_USEC;
354 }
355
356 d = m->kdbus->items;
357
358 if (well_known)
359 append_destination(&d, destination, dl);
360
361 append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
362
363 MESSAGE_FOREACH_PART(part, i, m) {
364 if (part->is_zero) {
365 /* If this is padding then simply send a
366 * vector with a NULL data pointer which the
367 * kernel will just pass through. This is the
368 * most efficient way to encode zeroes */
369
370 append_payload_vec(&d, NULL, part->size);
371 continue;
372 }
373
374 if (part->memfd >= 0 && part->sealed && destination) {
375 /* Try to send a memfd, if the part is
376 * sealed and this is not a broadcast. Since we can only */
377
378 append_payload_memfd(&d, part->memfd, part->memfd_offset, part->size);
379 continue;
380 }
381
382 /* Otherwise, let's send a vector to the actual data.
383 * For that, we need to map it first. */
384 r = bus_body_part_map(part);
385 if (r < 0)
386 goto fail;
387
388 append_payload_vec(&d, part->data, part->size);
389 }
390
391 if (m->header->type == SD_BUS_MESSAGE_SIGNAL) {
392 struct kdbus_bloom_filter *bloom;
393
394 bloom = append_bloom(&d, m->bus->bloom_size);
395 r = bus_message_setup_bloom(m, bloom);
396 if (r < 0)
397 goto fail;
398 }
399
400 if (m->n_fds > 0)
401 append_fds(&d, m->fds, m->n_fds);
402
403 m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
404 assert(m->kdbus->size <= sz);
405
406 return 0;
407
408 fail:
409 m->poisoned = true;
410 return r;
411 }
412
413 static void unset_memfds(struct sd_bus_message *m) {
414 struct bus_body_part *part;
415 unsigned i;
416
417 assert(m);
418
419 /* Make sure the memfds are not freed twice */
420 MESSAGE_FOREACH_PART(part, i, m)
421 if (part->memfd >= 0)
422 part->memfd = -1;
423 }
424
425 static void message_set_timestamp(sd_bus *bus, sd_bus_message *m, const struct kdbus_timestamp *ts) {
426 assert(bus);
427 assert(m);
428
429 if (!ts)
430 return;
431
432 if (!(bus->attach_flags & KDBUS_ATTACH_TIMESTAMP))
433 return;
434
435 m->realtime = ts->realtime_ns / NSEC_PER_USEC;
436 m->monotonic = ts->monotonic_ns / NSEC_PER_USEC;
437 m->seqnum = ts->seqnum;
438 }
439
440 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
441 sd_bus_message *m = NULL;
442 struct kdbus_item *d;
443 unsigned n_fds = 0;
444 _cleanup_free_ int *fds = NULL;
445 struct bus_header *header = NULL;
446 void *footer = NULL;
447 size_t header_size = 0, footer_size = 0;
448 size_t n_bytes = 0, idx = 0;
449 const char *destination = NULL, *seclabel = NULL;
450 bool last_was_memfd = false;
451 int r;
452
453 assert(bus);
454 assert(k);
455 assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
456
457 KDBUS_ITEM_FOREACH(d, k, items) {
458 size_t l;
459
460 l = d->size - offsetof(struct kdbus_item, data);
461
462 switch (d->type) {
463
464 case KDBUS_ITEM_PAYLOAD_OFF:
465 if (!header) {
466 header = (struct bus_header*)((uint8_t*) k + d->vec.offset);
467 header_size = d->vec.size;
468 }
469
470 footer = (uint8_t*) k + d->vec.offset;
471 footer_size = d->vec.size;
472
473 n_bytes += d->vec.size;
474 last_was_memfd = false;
475 break;
476
477 case KDBUS_ITEM_PAYLOAD_MEMFD:
478 if (!header) /* memfd cannot be first part */
479 return -EBADMSG;
480
481 n_bytes += d->memfd.size;
482 last_was_memfd = true;
483 break;
484
485 case KDBUS_ITEM_FDS: {
486 int *f;
487 unsigned j;
488
489 j = l / sizeof(int);
490 f = realloc(fds, sizeof(int) * (n_fds + j));
491 if (!f)
492 return -ENOMEM;
493
494 fds = f;
495 memcpy(fds + n_fds, d->fds, sizeof(int) * j);
496 n_fds += j;
497 break;
498 }
499
500 case KDBUS_ITEM_SECLABEL:
501 seclabel = d->str;
502 break;
503 }
504 }
505
506 if (last_was_memfd) /* memfd cannot be last part */
507 return -EBADMSG;
508
509 if (!header)
510 return -EBADMSG;
511
512 if (header_size < sizeof(struct bus_header))
513 return -EBADMSG;
514
515 /* on kdbus we only speak native endian gvariant, never dbus1
516 * marshalling or reverse endian */
517 if (header->version != 2 ||
518 header->endian != BUS_NATIVE_ENDIAN)
519 return -EPROTOTYPE;
520
521 r = bus_message_from_header(
522 bus,
523 header, header_size,
524 footer, footer_size,
525 n_bytes,
526 fds, n_fds,
527 seclabel, 0, &m);
528 if (r < 0)
529 return r;
530
531 /* The well-known names list is different from the other
532 credentials. If we asked for it, but nothing is there, this
533 means that the list of well-known names is simply empty, not
534 that we lack any data */
535
536 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
537
538 KDBUS_ITEM_FOREACH(d, k, items) {
539 size_t l;
540
541 l = d->size - offsetof(struct kdbus_item, data);
542
543 switch (d->type) {
544
545 case KDBUS_ITEM_PAYLOAD_OFF: {
546 size_t begin_body;
547
548 begin_body = BUS_MESSAGE_BODY_BEGIN(m);
549
550 if (idx + d->vec.size > begin_body) {
551 struct bus_body_part *part;
552
553 /* Contains body material */
554
555 part = message_append_part(m);
556 if (!part) {
557 r = -ENOMEM;
558 goto fail;
559 }
560
561 /* A -1 offset is NUL padding. */
562 part->is_zero = d->vec.offset == ~0ULL;
563
564 if (idx >= begin_body) {
565 if (!part->is_zero)
566 part->data = (uint8_t* )k + d->vec.offset;
567 part->size = d->vec.size;
568 } else {
569 if (!part->is_zero)
570 part->data = (uint8_t*) k + d->vec.offset + (begin_body - idx);
571 part->size = d->vec.size - (begin_body - idx);
572 }
573
574 part->sealed = true;
575 }
576
577 idx += d->vec.size;
578 break;
579 }
580
581 case KDBUS_ITEM_PAYLOAD_MEMFD: {
582 struct bus_body_part *part;
583
584 if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
585 r = -EBADMSG;
586 goto fail;
587 }
588
589 part = message_append_part(m);
590 if (!part) {
591 r = -ENOMEM;
592 goto fail;
593 }
594
595 part->memfd = d->memfd.fd;
596 part->memfd_offset = d->memfd.start;
597 part->size = d->memfd.size;
598 part->sealed = true;
599
600 idx += d->memfd.size;
601 break;
602 }
603
604 case KDBUS_ITEM_PIDS:
605
606 /* The PID/TID might be missing, when the data
607 * is faked by a bus proxy and it lacks that
608 * information about the real client (since
609 * SO_PEERCRED is used for that). Also kernel
610 * namespacing might make some of this data
611 * unavailable when untranslatable. */
612
613 if (d->pids.pid > 0) {
614 m->creds.pid = (pid_t) d->pids.pid;
615 m->creds.mask |= SD_BUS_CREDS_PID & bus->creds_mask;
616 }
617
618 if (d->pids.tid > 0) {
619 m->creds.tid = (pid_t) d->pids.tid;
620 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
621 }
622
623 if (d->pids.ppid > 0) {
624 m->creds.ppid = (pid_t) d->pids.ppid;
625 m->creds.mask |= SD_BUS_CREDS_PPID & bus->creds_mask;
626 } else if (d->pids.pid == 1) {
627 m->creds.ppid = 0;
628 m->creds.mask |= SD_BUS_CREDS_PPID & bus->creds_mask;
629 }
630
631 break;
632
633 case KDBUS_ITEM_CREDS:
634
635 /* EUID/SUID/FSUID/EGID/SGID/FSGID might be
636 * missing too (see above). */
637
638 if ((uid_t) d->creds.uid != UID_INVALID) {
639 m->creds.uid = (uid_t) d->creds.uid;
640 m->creds.mask |= SD_BUS_CREDS_UID & bus->creds_mask;
641 }
642
643 if ((uid_t) d->creds.euid != UID_INVALID) {
644 m->creds.euid = (uid_t) d->creds.euid;
645 m->creds.mask |= SD_BUS_CREDS_EUID & bus->creds_mask;
646 }
647
648 if ((uid_t) d->creds.suid != UID_INVALID) {
649 m->creds.suid = (uid_t) d->creds.suid;
650 m->creds.mask |= SD_BUS_CREDS_SUID & bus->creds_mask;
651 }
652
653 if ((uid_t) d->creds.fsuid != UID_INVALID) {
654 m->creds.fsuid = (uid_t) d->creds.fsuid;
655 m->creds.mask |= SD_BUS_CREDS_FSUID & bus->creds_mask;
656 }
657
658 if ((gid_t) d->creds.gid != GID_INVALID) {
659 m->creds.gid = (gid_t) d->creds.gid;
660 m->creds.mask |= SD_BUS_CREDS_GID & bus->creds_mask;
661 }
662
663 if ((gid_t) d->creds.egid != GID_INVALID) {
664 m->creds.egid = (gid_t) d->creds.egid;
665 m->creds.mask |= SD_BUS_CREDS_EGID & bus->creds_mask;
666 }
667
668 if ((gid_t) d->creds.sgid != GID_INVALID) {
669 m->creds.sgid = (gid_t) d->creds.sgid;
670 m->creds.mask |= SD_BUS_CREDS_SGID & bus->creds_mask;
671 }
672
673 if ((gid_t) d->creds.fsgid != GID_INVALID) {
674 m->creds.fsgid = (gid_t) d->creds.fsgid;
675 m->creds.mask |= SD_BUS_CREDS_FSGID & bus->creds_mask;
676 }
677
678 break;
679
680 case KDBUS_ITEM_TIMESTAMP:
681 message_set_timestamp(bus, m, &d->timestamp);
682 break;
683
684 case KDBUS_ITEM_PID_COMM:
685 m->creds.comm = d->str;
686 m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
687 break;
688
689 case KDBUS_ITEM_TID_COMM:
690 m->creds.tid_comm = d->str;
691 m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
692 break;
693
694 case KDBUS_ITEM_EXE:
695 m->creds.exe = d->str;
696 m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
697 break;
698
699 case KDBUS_ITEM_CMDLINE:
700 m->creds.cmdline = d->str;
701 m->creds.cmdline_size = l;
702 m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
703 break;
704
705 case KDBUS_ITEM_CGROUP:
706 m->creds.cgroup = d->str;
707 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;
708
709 r = bus_get_root_path(bus);
710 if (r < 0)
711 goto fail;
712
713 m->creds.cgroup_root = bus->cgroup_root;
714 break;
715
716 case KDBUS_ITEM_AUDIT:
717 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
718 m->creds.mask |= SD_BUS_CREDS_AUDIT_SESSION_ID & bus->creds_mask;
719
720 m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
721 m->creds.mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID & bus->creds_mask;
722 break;
723
724 case KDBUS_ITEM_CAPS:
725 if (d->caps.last_cap != cap_last_cap() ||
726 d->size - offsetof(struct kdbus_item, caps.caps) < DIV_ROUND_UP(d->caps.last_cap, 32U) * 4 * 4) {
727 r = -EBADMSG;
728 goto fail;
729 }
730
731 m->creds.capability = d->caps.caps;
732 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;
733 break;
734
735 case KDBUS_ITEM_DST_NAME:
736 if (!service_name_is_valid(d->str)) {
737 r = -EBADMSG;
738 goto fail;
739 }
740
741 destination = d->str;
742 break;
743
744 case KDBUS_ITEM_OWNED_NAME:
745 if (!service_name_is_valid(d->name.name)) {
746 r = -EBADMSG;
747 goto fail;
748 }
749
750 if (bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) {
751 char **wkn;
752 size_t n;
753
754 /* We just extend the array here, but
755 * do not allocate the strings inside
756 * of it, instead we just point to our
757 * buffer directly. */
758 n = strv_length(m->creds.well_known_names);
759 wkn = realloc(m->creds.well_known_names, (n + 2) * sizeof(char*));
760 if (!wkn) {
761 r = -ENOMEM;
762 goto fail;
763 }
764
765 wkn[n] = d->name.name;
766 wkn[n+1] = NULL;
767 m->creds.well_known_names = wkn;
768
769 m->creds.mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES;
770 }
771 break;
772
773 case KDBUS_ITEM_CONN_DESCRIPTION:
774 m->creds.description = d->str;
775 m->creds.mask |= SD_BUS_CREDS_DESCRIPTION & bus->creds_mask;
776 break;
777
778 case KDBUS_ITEM_AUXGROUPS:
779
780 if (bus->creds_mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS) {
781 size_t i, n;
782 gid_t *g;
783
784 n = (d->size - offsetof(struct kdbus_item, data64)) / sizeof(uint64_t);
785 g = new(gid_t, n);
786 if (!g) {
787 r = -ENOMEM;
788 goto fail;
789 }
790
791 for (i = 0; i < n; i++)
792 g[i] = d->data64[i];
793
794 m->creds.supplementary_gids = g;
795 m->creds.n_supplementary_gids = n;
796 m->creds.mask |= SD_BUS_CREDS_SUPPLEMENTARY_GIDS;
797 }
798
799 break;
800
801 case KDBUS_ITEM_FDS:
802 case KDBUS_ITEM_SECLABEL:
803 case KDBUS_ITEM_BLOOM_FILTER:
804 break;
805
806 default:
807 log_debug("Got unknown field from kernel %llu", d->type);
808 }
809 }
810
811 /* If we requested the list of well-known names to be appended
812 * and the sender had none no item for it will be
813 * attached. However, this does *not* mean that the kernel
814 * didn't want to provide this information to us. Hence, let's
815 * explicitly mark this information as available if it was
816 * requested. */
817 m->creds.mask |= bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES;
818
819 r = bus_message_parse_fields(m);
820 if (r < 0)
821 goto fail;
822
823 /* Refuse messages if kdbus and dbus1 cookie doesn't match up */
824 if ((uint64_t) m->header->dbus2.cookie != k->cookie) {
825 r = -EBADMSG;
826 goto fail;
827 }
828
829 /* Refuse messages where the reply flag doesn't match up */
830 if (!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) != !!(k->flags & KDBUS_MSG_EXPECT_REPLY)) {
831 r = -EBADMSG;
832 goto fail;
833 }
834
835 /* Refuse reply messages where the reply cookie doesn't match up */
836 if ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) && m->reply_cookie != k->cookie_reply) {
837 r = -EBADMSG;
838 goto fail;
839 }
840
841 /* Refuse messages where the autostart flag doesn't match up */
842 if (!(m->header->flags & BUS_MESSAGE_NO_AUTO_START) != !(k->flags & KDBUS_MSG_NO_AUTO_START)) {
843 r = -EBADMSG;
844 goto fail;
845 }
846
847 /* Override information from the user header with data from the kernel */
848 if (k->src_id == KDBUS_SRC_ID_KERNEL)
849 bus_message_set_sender_driver(bus, m);
850 else {
851 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
852 m->sender = m->creds.unique_name = m->sender_buffer;
853 }
854
855 if (destination)
856 m->destination = destination;
857 else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
858 m->destination = NULL;
859 else if (k->dst_id == KDBUS_DST_ID_NAME)
860 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
861 else {
862 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
863 m->destination = m->destination_buffer;
864 }
865
866 /* We take possession of the kmsg struct now */
867 m->kdbus = k;
868 m->release_kdbus = true;
869 m->free_fds = true;
870 fds = NULL;
871
872 bus->rqueue[bus->rqueue_size++] = m;
873
874 return 1;
875
876 fail:
877 unset_memfds(m);
878 sd_bus_message_unref(m);
879
880 return r;
881 }
882
883 int bus_kernel_take_fd(sd_bus *b) {
884 struct kdbus_bloom_parameter *bloom = NULL;
885 struct kdbus_item *items, *item;
886 struct kdbus_cmd_hello *hello;
887 _cleanup_free_ char *g = NULL;
888 const char *name;
889 size_t l = 0, m = 0, sz;
890 int r;
891
892 assert(b);
893
894 if (b->is_server)
895 return -EINVAL;
896
897 b->use_memfd = 1;
898
899 if (b->description) {
900 g = bus_label_escape(b->description);
901 if (!g)
902 return -ENOMEM;
903
904 name = g;
905 } else {
906 char pr[17] = {};
907
908 /* If no name is explicitly set, we'll include a hint
909 * indicating the library implementation, a hint which
910 * kind of bus this is and the thread name */
911
912 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
913
914 if (isempty(pr)) {
915 name = b->is_system ? "sd-system" :
916 b->is_user ? "sd-user" : "sd";
917 } else {
918 _cleanup_free_ char *e = NULL;
919
920 e = bus_label_escape(pr);
921 if (!e)
922 return -ENOMEM;
923
924 g = strappend(b->is_system ? "sd-system-" :
925 b->is_user ? "sd-user-" : "sd-",
926 e);
927 if (!g)
928 return -ENOMEM;
929
930 name = g;
931 }
932
933 b->description = bus_label_unescape(name);
934 if (!b->description)
935 return -ENOMEM;
936 }
937
938 m = strlen(name);
939
940 sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
941 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
942
943 if (b->fake_creds_valid)
944 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
945
946 if (b->fake_pids_valid)
947 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
948
949 if (b->fake_label) {
950 l = strlen(b->fake_label);
951 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
952 }
953
954 hello = alloca0_align(sz, 8);
955 hello->size = sz;
956 hello->flags = b->hello_flags;
957 hello->attach_flags_send = _KDBUS_ATTACH_ANY;
958 hello->attach_flags_recv = b->attach_flags;
959 hello->pool_size = KDBUS_POOL_SIZE;
960
961 item = hello->items;
962
963 item->size = offsetof(struct kdbus_item, str) + m + 1;
964 item->type = KDBUS_ITEM_CONN_DESCRIPTION;
965 memcpy(item->str, name, m + 1);
966 item = KDBUS_ITEM_NEXT(item);
967
968 if (b->fake_creds_valid) {
969 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
970 item->type = KDBUS_ITEM_CREDS;
971 item->creds = b->fake_creds;
972
973 item = KDBUS_ITEM_NEXT(item);
974 }
975
976 if (b->fake_pids_valid) {
977 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
978 item->type = KDBUS_ITEM_PIDS;
979 item->pids = b->fake_pids;
980
981 item = KDBUS_ITEM_NEXT(item);
982 }
983
984 if (b->fake_label) {
985 item->size = offsetof(struct kdbus_item, str) + l + 1;
986 item->type = KDBUS_ITEM_SECLABEL;
987 memcpy(item->str, b->fake_label, l+1);
988 }
989
990 r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
991 if (r < 0) {
992 if (errno == ENOTTY)
993 /* If the ioctl is not supported we assume that the
994 * API version changed in a major incompatible way,
995 * let's indicate an API incompatibility in this
996 * case. */
997 return -ESOCKTNOSUPPORT;
998
999 return -errno;
1000 }
1001
1002 if (!b->kdbus_buffer) {
1003 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
1004 if (b->kdbus_buffer == MAP_FAILED) {
1005 b->kdbus_buffer = NULL;
1006 r = -errno;
1007 goto fail;
1008 }
1009 }
1010
1011 /* The higher 32bit of the bus_flags fields are considered
1012 * 'incompatible flags'. Refuse them all for now. */
1013 if (hello->bus_flags > 0xFFFFFFFFULL) {
1014 r = -ESOCKTNOSUPPORT;
1015 goto fail;
1016 }
1017
1018 /* extract bloom parameters from items */
1019 items = (void*)((uint8_t*)b->kdbus_buffer + hello->offset);
1020 KDBUS_FOREACH(item, items, hello->items_size) {
1021 switch (item->type) {
1022 case KDBUS_ITEM_BLOOM_PARAMETER:
1023 bloom = &item->bloom_parameter;
1024 break;
1025 }
1026 }
1027
1028 if (!bloom || !bloom_validate_parameters((size_t) bloom->size, (unsigned) bloom->n_hash)) {
1029 r = -EOPNOTSUPP;
1030 goto fail;
1031 }
1032
1033 b->bloom_size = (size_t) bloom->size;
1034 b->bloom_n_hash = (unsigned) bloom->n_hash;
1035
1036 if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0) {
1037 r = -ENOMEM;
1038 goto fail;
1039 }
1040
1041 b->unique_id = hello->id;
1042
1043 b->is_kernel = true;
1044 b->bus_client = true;
1045 b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
1046 b->message_version = 2;
1047 b->message_endian = BUS_NATIVE_ENDIAN;
1048
1049 /* the kernel told us the UUID of the underlying bus */
1050 memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
1051
1052 /* free returned items */
1053 (void) bus_kernel_cmd_free(b, hello->offset);
1054 return bus_start_running(b);
1055
1056 fail:
1057 (void) bus_kernel_cmd_free(b, hello->offset);
1058 return r;
1059 }
1060
1061 int bus_kernel_connect(sd_bus *b) {
1062 assert(b);
1063 assert(b->input_fd < 0);
1064 assert(b->output_fd < 0);
1065 assert(b->kernel);
1066
1067 if (b->is_server)
1068 return -EINVAL;
1069
1070 b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
1071 if (b->input_fd < 0)
1072 return -errno;
1073
1074 b->output_fd = b->input_fd;
1075
1076 return bus_kernel_take_fd(b);
1077 }
1078
1079 int bus_kernel_cmd_free(sd_bus *bus, uint64_t offset) {
1080 struct kdbus_cmd_free cmd = {
1081 .size = sizeof(cmd),
1082 .offset = offset,
1083 };
1084 int r;
1085
1086 assert(bus);
1087 assert(bus->is_kernel);
1088
1089 r = ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
1090 if (r < 0)
1091 return -errno;
1092
1093 return 0;
1094 }
1095
1096 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
1097 struct kdbus_item *d;
1098
1099 assert(bus);
1100 assert(k);
1101
1102 KDBUS_ITEM_FOREACH(d, k, items) {
1103 if (d->type == KDBUS_ITEM_FDS)
1104 close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
1105 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
1106 safe_close(d->memfd.fd);
1107 }
1108
1109 bus_kernel_cmd_free(bus, (uint8_t*) k - (uint8_t*) bus->kdbus_buffer);
1110 }
1111
1112 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
1113 struct kdbus_cmd_send cmd = { };
1114 int r;
1115
1116 assert(bus);
1117 assert(m);
1118 assert(bus->state == BUS_RUNNING);
1119
1120 /* If we can't deliver, we want room for the error message */
1121 r = bus_rqueue_make_room(bus);
1122 if (r < 0)
1123 return r;
1124
1125 r = bus_message_setup_kmsg(bus, m);
1126 if (r < 0)
1127 return r;
1128
1129 cmd.size = sizeof(cmd);
1130 cmd.msg_address = (uintptr_t)m->kdbus;
1131
1132 /* If this is a synchronous method call, then let's tell the
1133 * kernel, so that it can pass CPU time/scheduling to the
1134 * destination for the time, if it wants to. If we
1135 * synchronously wait for the result anyway, we won't need CPU
1136 * anyway. */
1137 if (hint_sync_call) {
1138 m->kdbus->flags |= KDBUS_MSG_EXPECT_REPLY;
1139 cmd.flags |= KDBUS_SEND_SYNC_REPLY;
1140 }
1141
1142 r = ioctl(bus->output_fd, KDBUS_CMD_SEND, &cmd);
1143 if (r < 0) {
1144 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1145 sd_bus_message *reply;
1146
1147 if (errno == EAGAIN || errno == EINTR)
1148 return 0;
1149 else if (errno == ENXIO || errno == ESRCH) {
1150
1151 /* ENXIO: unique name not known
1152 * ESRCH: well-known name not known */
1153
1154 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1155 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
1156 else {
1157 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
1158 return 0;
1159 }
1160
1161 } else if (errno == EADDRNOTAVAIL) {
1162
1163 /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
1164
1165 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1166 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
1167 else {
1168 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
1169 return 0;
1170 }
1171 } else
1172 return -errno;
1173
1174 r = bus_message_new_synthetic_error(
1175 bus,
1176 BUS_MESSAGE_COOKIE(m),
1177 &error,
1178 &reply);
1179
1180 if (r < 0)
1181 return r;
1182
1183 r = bus_seal_synthetic_message(bus, reply);
1184 if (r < 0)
1185 return r;
1186
1187 bus->rqueue[bus->rqueue_size++] = reply;
1188
1189 } else if (hint_sync_call) {
1190 struct kdbus_msg *k;
1191
1192 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + cmd.reply.offset);
1193 assert(k);
1194
1195 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1196
1197 r = bus_kernel_make_message(bus, k);
1198 if (r < 0) {
1199 close_kdbus_msg(bus, k);
1200
1201 /* Anybody can send us invalid messages, let's just drop them. */
1202 if (r == -EBADMSG || r == -EPROTOTYPE)
1203 log_debug_errno(r, "Ignoring invalid synchronous reply: %m");
1204 else
1205 return r;
1206 }
1207 } else {
1208 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1209 close_kdbus_msg(bus, k);
1210 }
1211 }
1212
1213 return 1;
1214 }
1215
1216 static int push_name_owner_changed(
1217 sd_bus *bus,
1218 const char *name,
1219 const char *old_owner,
1220 const char *new_owner,
1221 const struct kdbus_timestamp *ts) {
1222
1223 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1224 int r;
1225
1226 assert(bus);
1227
1228 r = sd_bus_message_new_signal(
1229 bus,
1230 &m,
1231 "/org/freedesktop/DBus",
1232 "org.freedesktop.DBus",
1233 "NameOwnerChanged");
1234 if (r < 0)
1235 return r;
1236
1237 r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1238 if (r < 0)
1239 return r;
1240
1241 bus_message_set_sender_driver(bus, m);
1242 message_set_timestamp(bus, m, ts);
1243
1244 r = bus_seal_synthetic_message(bus, m);
1245 if (r < 0)
1246 return r;
1247
1248 bus->rqueue[bus->rqueue_size++] = m;
1249 m = NULL;
1250
1251 return 1;
1252 }
1253
1254 static int translate_name_change(
1255 sd_bus *bus,
1256 const struct kdbus_msg *k,
1257 const struct kdbus_item *d,
1258 const struct kdbus_timestamp *ts) {
1259
1260 char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1261
1262 assert(bus);
1263 assert(k);
1264 assert(d);
1265
1266 if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1267 old_owner[0] = 0;
1268 else
1269 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1270
1271 if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1272
1273 if (isempty(old_owner))
1274 return 0;
1275
1276 new_owner[0] = 0;
1277 } else
1278 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1279
1280 return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner, ts);
1281 }
1282
1283 static int translate_id_change(
1284 sd_bus *bus,
1285 const struct kdbus_msg *k,
1286 const struct kdbus_item *d,
1287 const struct kdbus_timestamp *ts) {
1288
1289 char owner[UNIQUE_NAME_MAX];
1290
1291 assert(bus);
1292 assert(k);
1293 assert(d);
1294
1295 sprintf(owner, ":1.%llu", d->id_change.id);
1296
1297 return push_name_owner_changed(
1298 bus, owner,
1299 d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1300 d->type == KDBUS_ITEM_ID_ADD ? owner : NULL,
1301 ts);
1302 }
1303
1304 static int translate_reply(
1305 sd_bus *bus,
1306 const struct kdbus_msg *k,
1307 const struct kdbus_item *d,
1308 const struct kdbus_timestamp *ts) {
1309
1310 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1311 int r;
1312
1313 assert(bus);
1314 assert(k);
1315 assert(d);
1316
1317 r = bus_message_new_synthetic_error(
1318 bus,
1319 k->cookie_reply,
1320 d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1321 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1322 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1323 &m);
1324 if (r < 0)
1325 return r;
1326
1327 message_set_timestamp(bus, m, ts);
1328
1329 r = bus_seal_synthetic_message(bus, m);
1330 if (r < 0)
1331 return r;
1332
1333 bus->rqueue[bus->rqueue_size++] = m;
1334 m = NULL;
1335
1336 return 1;
1337 }
1338
1339 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1340 static int (* const translate[])(sd_bus *bus, const struct kdbus_msg *k, const struct kdbus_item *d, const struct kdbus_timestamp *ts) = {
1341 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1342 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1343 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1344
1345 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1346 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1347
1348 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1349 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1350 };
1351
1352 struct kdbus_item *d, *found = NULL;
1353 struct kdbus_timestamp *ts = NULL;
1354
1355 assert(bus);
1356 assert(k);
1357 assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1358
1359 KDBUS_ITEM_FOREACH(d, k, items) {
1360 if (d->type == KDBUS_ITEM_TIMESTAMP)
1361 ts = &d->timestamp;
1362 else if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1363 if (found)
1364 return -EBADMSG;
1365 found = d;
1366 } else
1367 log_debug("Got unknown field from kernel %llu", d->type);
1368 }
1369
1370 if (!found) {
1371 log_debug("Didn't find a kernel message to translate.");
1372 return 0;
1373 }
1374
1375 return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found, ts);
1376 }
1377
1378 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1379 struct kdbus_cmd_recv recv = { .size = sizeof(recv) };
1380 struct kdbus_msg *k;
1381 int r;
1382
1383 assert(bus);
1384
1385 r = bus_rqueue_make_room(bus);
1386 if (r < 0)
1387 return r;
1388
1389 if (hint_priority) {
1390 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1391 recv.priority = priority;
1392 }
1393
1394 r = ioctl(bus->input_fd, KDBUS_CMD_RECV, &recv);
1395 if (recv.return_flags & KDBUS_RECV_RETURN_DROPPED_MSGS)
1396 log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1397 if (r < 0) {
1398 if (errno == EAGAIN)
1399 return 0;
1400
1401 return -errno;
1402 }
1403
1404 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.msg.offset);
1405 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1406 r = bus_kernel_make_message(bus, k);
1407
1408 /* Anybody can send us invalid messages, let's just drop them. */
1409 if (r == -EBADMSG || r == -EPROTOTYPE) {
1410 log_debug_errno(r, "Ignoring invalid message: %m");
1411 r = 0;
1412 }
1413
1414 if (r <= 0)
1415 close_kdbus_msg(bus, k);
1416 } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL) {
1417 r = bus_kernel_translate_message(bus, k);
1418 close_kdbus_msg(bus, k);
1419 } else {
1420 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1421 r = 0;
1422 close_kdbus_msg(bus, k);
1423 }
1424
1425 return r < 0 ? r : 1;
1426 }
1427
1428 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1429 struct memfd_cache *c;
1430 int fd;
1431
1432 assert(address);
1433 assert(mapped);
1434 assert(allocated);
1435
1436 if (!bus || !bus->is_kernel)
1437 return -EOPNOTSUPP;
1438
1439 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) == 0);
1440
1441 if (bus->n_memfd_cache <= 0) {
1442 int r;
1443
1444 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) == 0);
1445
1446 r = memfd_new(bus->description);
1447 if (r < 0)
1448 return r;
1449
1450 *address = NULL;
1451 *mapped = 0;
1452 *allocated = 0;
1453 return r;
1454 }
1455
1456 c = &bus->memfd_cache[--bus->n_memfd_cache];
1457
1458 assert(c->fd >= 0);
1459 assert(c->mapped == 0 || c->address);
1460
1461 *address = c->address;
1462 *mapped = c->mapped;
1463 *allocated = c->allocated;
1464 fd = c->fd;
1465
1466 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) == 0);
1467
1468 return fd;
1469 }
1470
1471 static void close_and_munmap(int fd, void *address, size_t size) {
1472 if (size > 0)
1473 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1474
1475 safe_close(fd);
1476 }
1477
1478 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1479 struct memfd_cache *c;
1480 uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1481
1482 assert(fd >= 0);
1483 assert(mapped == 0 || address);
1484
1485 if (!bus || !bus->is_kernel) {
1486 close_and_munmap(fd, address, mapped);
1487 return;
1488 }
1489
1490 assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) == 0);
1491
1492 if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1493 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) == 0);
1494
1495 close_and_munmap(fd, address, mapped);
1496 return;
1497 }
1498
1499 c = &bus->memfd_cache[bus->n_memfd_cache++];
1500 c->fd = fd;
1501 c->address = address;
1502
1503 /* If overly long, let's return a bit to the OS */
1504 if (mapped > max_mapped) {
1505 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1506 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1507 c->mapped = c->allocated = max_mapped;
1508 } else {
1509 c->mapped = mapped;
1510 c->allocated = allocated;
1511 }
1512
1513 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) == 0);
1514 }
1515
1516 void bus_kernel_flush_memfd(sd_bus *b) {
1517 unsigned i;
1518
1519 assert(b);
1520
1521 for (i = 0; i < b->n_memfd_cache; i++)
1522 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1523 }
1524
1525 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1526 uint64_t f = 0;
1527
1528 if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1529 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1530
1531 if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1532 f |= KDBUS_NAME_REPLACE_EXISTING;
1533
1534 if (flags & SD_BUS_NAME_QUEUE)
1535 f |= KDBUS_NAME_QUEUE;
1536
1537 return f;
1538 }
1539
1540 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1541 uint64_t m = 0;
1542
1543 if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1544 SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1545 m |= KDBUS_ATTACH_CREDS;
1546
1547 if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_TID|SD_BUS_CREDS_PPID))
1548 m |= KDBUS_ATTACH_PIDS;
1549
1550 if (mask & SD_BUS_CREDS_COMM)
1551 m |= KDBUS_ATTACH_PID_COMM;
1552
1553 if (mask & SD_BUS_CREDS_TID_COMM)
1554 m |= KDBUS_ATTACH_TID_COMM;
1555
1556 if (mask & SD_BUS_CREDS_EXE)
1557 m |= KDBUS_ATTACH_EXE;
1558
1559 if (mask & SD_BUS_CREDS_CMDLINE)
1560 m |= KDBUS_ATTACH_CMDLINE;
1561
1562 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))
1563 m |= KDBUS_ATTACH_CGROUP;
1564
1565 if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1566 m |= KDBUS_ATTACH_CAPS;
1567
1568 if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1569 m |= KDBUS_ATTACH_SECLABEL;
1570
1571 if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1572 m |= KDBUS_ATTACH_AUDIT;
1573
1574 if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1575 m |= KDBUS_ATTACH_NAMES;
1576
1577 if (mask & SD_BUS_CREDS_DESCRIPTION)
1578 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1579
1580 if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1581 m |= KDBUS_ATTACH_AUXGROUPS;
1582
1583 return m;
1584 }
1585
1586 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1587 struct kdbus_cmd *make;
1588 struct kdbus_item *n;
1589 size_t l;
1590 int fd;
1591
1592 assert(name);
1593 assert(s);
1594
1595 fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1596 if (fd < 0)
1597 return -errno;
1598
1599 l = strlen(name);
1600 make = alloca0_align(offsetof(struct kdbus_cmd, items) +
1601 ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1602 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1603 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1604 8);
1605
1606 make->size = offsetof(struct kdbus_cmd, items);
1607
1608 /* Set the bloom parameters */
1609 n = make->items;
1610 n->size = offsetof(struct kdbus_item, bloom_parameter) +
1611 sizeof(struct kdbus_bloom_parameter);
1612 n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1613 n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1614 n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1615
1616 assert_cc(DEFAULT_BLOOM_SIZE > 0);
1617 assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1618
1619 make->size += ALIGN8(n->size);
1620
1621 /* Provide all metadata via bus-owner queries */
1622 n = KDBUS_ITEM_NEXT(n);
1623 n->type = KDBUS_ITEM_ATTACH_FLAGS_SEND;
1624 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1625 n->data64[0] = _KDBUS_ATTACH_ANY;
1626 make->size += ALIGN8(n->size);
1627
1628 /* Set the a good name */
1629 n = KDBUS_ITEM_NEXT(n);
1630 sprintf(n->str, UID_FMT "-%s", getuid(), name);
1631 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1632 n->type = KDBUS_ITEM_MAKE_NAME;
1633 make->size += ALIGN8(n->size);
1634
1635 make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1636
1637 if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1638 safe_close(fd);
1639
1640 /* Major API change? then the ioctls got shuffled around. */
1641 if (errno == ENOTTY)
1642 return -ESOCKTNOSUPPORT;
1643
1644 return -errno;
1645 }
1646
1647 if (s) {
1648 char *p;
1649
1650 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1651 if (!p) {
1652 safe_close(fd);
1653 return -ENOMEM;
1654 }
1655
1656 *s = p;
1657 }
1658
1659 return fd;
1660 }
1661
1662 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1663 char *p;
1664 int fd;
1665 size_t len;
1666
1667 assert(bus);
1668
1669 len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1670
1671 if (path) {
1672 p = new(char, len);
1673 if (!p)
1674 return -ENOMEM;
1675 } else
1676 p = newa(char, len);
1677
1678 sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1679
1680 fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1681 if (fd < 0) {
1682 if (path)
1683 free(p);
1684
1685 return -errno;
1686 }
1687
1688 if (path)
1689 *path = p;
1690
1691 return fd;
1692 }
1693
1694 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1695 _cleanup_free_ char *path = NULL;
1696 struct kdbus_cmd *make;
1697 struct kdbus_item *n;
1698 const char *name;
1699 int fd;
1700
1701 fd = bus_kernel_open_bus_fd(bus_name, &path);
1702 if (fd < 0)
1703 return fd;
1704
1705 make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd, items)) +
1706 ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1707 8);
1708 make->size = ALIGN8(offsetof(struct kdbus_cmd, items));
1709 make->flags = KDBUS_MAKE_ACCESS_WORLD;
1710
1711 n = make->items;
1712 sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1713 n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1714 n->type = KDBUS_ITEM_MAKE_NAME;
1715 make->size += ALIGN8(n->size);
1716 name = n->str;
1717
1718 if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1719 safe_close(fd);
1720 return -errno;
1721 }
1722
1723 if (ep_path) {
1724 char *p;
1725
1726 p = strjoin(dirname(path), "/", name, NULL);
1727 if (!p) {
1728 safe_close(fd);
1729 return -ENOMEM;
1730 }
1731
1732 *ep_path = p;
1733 }
1734
1735 return fd;
1736 }
1737
1738 int bus_kernel_try_close(sd_bus *bus) {
1739 struct kdbus_cmd byebye = { .size = sizeof(byebye) };
1740
1741 assert(bus);
1742 assert(bus->is_kernel);
1743
1744 if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE, &byebye) < 0)
1745 return -errno;
1746
1747 return 0;
1748 }
1749
1750 int bus_kernel_drop_one(int fd) {
1751 struct kdbus_cmd_recv recv = {
1752 .size = sizeof(recv),
1753 .flags = KDBUS_RECV_DROP,
1754 };
1755
1756 assert(fd >= 0);
1757
1758 if (ioctl(fd, KDBUS_CMD_RECV, &recv) < 0)
1759 return -errno;
1760
1761 return 0;
1762 }
1763
1764 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1765 struct kdbus_cmd *update;
1766 struct kdbus_item *n;
1767
1768 assert(bus);
1769 assert(bus->is_kernel);
1770
1771 update = alloca0_align(offsetof(struct kdbus_cmd, items) +
1772 ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1773 8);
1774
1775 n = update->items;
1776 n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1777 n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1778 n->data64[0] = bus->attach_flags;
1779
1780 update->size =
1781 offsetof(struct kdbus_cmd, items) +
1782 ALIGN8(n->size);
1783
1784 if (ioctl(bus->input_fd, KDBUS_CMD_UPDATE, update) < 0)
1785 return -errno;
1786
1787 return 0;
1788 }
1789
1790 int bus_kernel_get_bus_name(sd_bus *bus, char **name) {
1791 struct kdbus_cmd_info cmd = {
1792 .size = sizeof(struct kdbus_cmd_info),
1793 };
1794 struct kdbus_info *info;
1795 struct kdbus_item *item;
1796 char *n = NULL;
1797 int r;
1798
1799 assert(bus);
1800 assert(name);
1801 assert(bus->is_kernel);
1802
1803 r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
1804 if (r < 0)
1805 return -errno;
1806
1807 info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset);
1808
1809 KDBUS_ITEM_FOREACH(item, info, items)
1810 if (item->type == KDBUS_ITEM_MAKE_NAME) {
1811 r = free_and_strdup(&n, item->str);
1812 break;
1813 }
1814
1815 bus_kernel_cmd_free(bus, cmd.offset);
1816
1817 if (r < 0)
1818 return r;
1819 if (!n)
1820 return -EIO;
1821
1822 *name = n;
1823 return 0;
1824 }
Unnamed repository; edit this file 'description' to name the repository.