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