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