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