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