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