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