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