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