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