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_EXPECT_REPLY) |
 298                 ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_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_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_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_free cmd_free = {
 819                 .size = sizeof(cmd_free),
 820                 .flags = 0,
 821         };
 822         struct kdbus_bloom_parameter *bloom = NULL;
 823         struct kdbus_cmd_hello *hello;
 824         struct kdbus_item_list *items;
 825         struct kdbus_item *item;
 826         _cleanup_free_ char *g = NULL;
 827         const char *name;
 828         size_t l = 0, m = 0, sz;
 829         int r;
 830
 831         assert(b);
 832
 833         if (b->is_server)
 834                 return -EINVAL;
 835
 836         b->use_memfd = 1;
 837
 838         if (b->description) {
 839                 g = bus_label_escape(b->description);
 840                 if (!g)
 841                         return -ENOMEM;
 842
 843                 name = g;
 844         } else {
 845                 char pr[17] = {};
 846
 847                 /* If no name is explicitly set, we'll include a hint
 848                  * indicating the library implementation, a hint which
 849                  * kind of bus this is and the thread name */
 850
 851                 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
 852
 853                 if (isempty(pr)) {
 854                         name = b->is_system ? "sd-system" :
 855                                 b->is_user ? "sd-user" : "sd";
 856                 } else {
 857                         _cleanup_free_ char *e = NULL;
 858
 859                         e = bus_label_escape(pr);
 860                         if (!e)
 861                                 return -ENOMEM;
 862
 863                         g = strappend(b->is_system ? "sd-system-" :
 864                                       b->is_user ? "sd-user-" : "sd-",
 865                                       e);
 866                         if (!g)
 867                                 return -ENOMEM;
 868
 869                         name = g;
 870                 }
 871
 872                 b->description = bus_label_unescape(name);
 873                 if (!b->description)
 874                         return -ENOMEM;
 875         }
 876
 877         m = strlen(name);
 878
 879         sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
 880                 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
 881
 882         if (b->fake_creds_valid)
 883                 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
 884
 885         if (b->fake_pids_valid)
 886                 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
 887
 888         if (b->fake_label) {
 889                 l = strlen(b->fake_label);
 890                 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
 891         }
 892
 893         hello = alloca0_align(sz, 8);
 894         hello->size = sz;
 895         hello->flags = b->hello_flags;
 896         hello->attach_flags_send = _KDBUS_ATTACH_ANY;
 897         hello->attach_flags_recv = b->attach_flags;
 898         hello->pool_size = KDBUS_POOL_SIZE;
 899
 900         item = hello->items;
 901
 902         item->size = offsetof(struct kdbus_item, str) + m + 1;
 903         item->type = KDBUS_ITEM_CONN_DESCRIPTION;
 904         memcpy(item->str, name, m + 1);
 905         item = KDBUS_ITEM_NEXT(item);
 906
 907         if (b->fake_creds_valid) {
 908                 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
 909                 item->type = KDBUS_ITEM_CREDS;
 910                 item->creds = b->fake_creds;
 911
 912                 item = KDBUS_ITEM_NEXT(item);
 913         }
 914
 915         if (b->fake_pids_valid) {
 916                 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
 917                 item->type = KDBUS_ITEM_PIDS;
 918                 item->pids = b->fake_pids;
 919
 920                 item = KDBUS_ITEM_NEXT(item);
 921         }
 922
 923         if (b->fake_label) {
 924                 item->size = offsetof(struct kdbus_item, str) + l + 1;
 925                 item->type = KDBUS_ITEM_SECLABEL;
 926                 memcpy(item->str, b->fake_label, l+1);
 927         }
 928
 929         r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
 930         if (r < 0)
 931                 return -errno;
 932
 933         if (!b->kdbus_buffer) {
 934                 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
 935                 if (b->kdbus_buffer == MAP_FAILED) {
 936                         b->kdbus_buffer = NULL;
 937                         r = -errno;
 938                         goto fail;
 939                 }
 940         }
 941
 942         /* The higher 32bit of the bus_flags fields are considered
 943          * 'incompatible flags'. Refuse them all for now. */
 944         if (hello->bus_flags > 0xFFFFFFFFULL) {
 945                 r = -ENOTSUP;
 946                 goto fail;
 947         }
 948
 949         /* extract bloom parameters from items */
 950         items = (void*)((uint8_t*)b->kdbus_buffer + hello->offset);
 951         KDBUS_ITEM_FOREACH(item, items, items) {
 952                 switch (item->type) {
 953                 case KDBUS_ITEM_BLOOM_PARAMETER:
 954                         bloom = &item->bloom_parameter;
 955                         break;
 956                 }
 957         }
 958
 959         if (!bloom || !bloom_validate_parameters((size_t) bloom->size, (unsigned) bloom->n_hash)) {
 960                 r = -ENOTSUP;
 961                 goto fail;
 962         }
 963
 964         b->bloom_size = (size_t) bloom->size;
 965         b->bloom_n_hash = (unsigned) bloom->n_hash;
 966
 967         if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0) {
 968                 r = -ENOMEM;
 969                 goto fail;
 970         }
 971
 972         b->unique_id = hello->id;
 973
 974         b->is_kernel = true;
 975         b->bus_client = true;
 976         b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
 977         b->message_version = 2;
 978         b->message_endian = BUS_NATIVE_ENDIAN;
 979
 980         /* the kernel told us the UUID of the underlying bus */
 981         memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
 982
 983         /* free returned items */
 984         (void) bus_kernel_cmd_free(b, hello->offset);
 985
 986         return bus_start_running(b);
 987
 988 fail:
 989         cmd_free.offset = hello->offset;
 990         (void) ioctl(b->input_fd, KDBUS_CMD_FREE, &cmd_free);
 991         return r;
 992 }
 993
 994 int bus_kernel_connect(sd_bus *b) {
 995         assert(b);
 996         assert(b->input_fd < 0);
 997         assert(b->output_fd < 0);
 998         assert(b->kernel);
 999
1000         if (b->is_server)
1001                 return -EINVAL;
1002
1003         b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
1004         if (b->input_fd < 0)
1005                 return -errno;
1006
1007         b->output_fd = b->input_fd;
1008
1009         return bus_kernel_take_fd(b);
1010 }
1011
1012 int bus_kernel_cmd_free(sd_bus *bus, uint64_t offset) {
1013         struct kdbus_cmd_free cmd = {
1014                 .size = sizeof(cmd),
1015                 .flags = 0,
1016                 .offset = offset,
1017         };
1018         int r;
1019
1020         assert(bus);
1021         assert(bus->is_kernel);
1022
1023         r = ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
1024         if (r < 0)
1025                 return -errno;
1026
1027         return 0;
1028 }
1029
1030 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
1031         struct kdbus_item *d;
1032
1033         assert(bus);
1034         assert(k);
1035
1036         KDBUS_ITEM_FOREACH(d, k, items) {
1037                 if (d->type == KDBUS_ITEM_FDS)
1038                         close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
1039                 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
1040                         safe_close(d->memfd.fd);
1041         }
1042
1043         bus_kernel_cmd_free(bus, (uint8_t*) k - (uint8_t*) bus->kdbus_buffer);
1044 }
1045
1046 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
1047         struct kdbus_cmd_send cmd = { };
1048         int r;
1049
1050         assert(bus);
1051         assert(m);
1052         assert(bus->state == BUS_RUNNING);
1053
1054         /* If we can't deliver, we want room for the error message */
1055         r = bus_rqueue_make_room(bus);
1056         if (r < 0)
1057                 return r;
1058
1059         r = bus_message_setup_kmsg(bus, m);
1060         if (r < 0)
1061                 return r;
1062
1063         cmd.size = sizeof(cmd);
1064         cmd.msg_address = (uintptr_t)m->kdbus;
1065
1066         /* If this is a synchronous method call, then let's tell the
1067          * kernel, so that it can pass CPU time/scheduling to the
1068          * destination for the time, if it wants to. If we
1069          * synchronously wait for the result anyway, we won't need CPU
1070          * anyway. */
1071         if (hint_sync_call) {
1072                 m->kdbus->flags |= KDBUS_MSG_EXPECT_REPLY;
1073                 cmd.flags |= KDBUS_SEND_SYNC_REPLY;
1074         }
1075
1076         r = ioctl(bus->output_fd, KDBUS_CMD_SEND, &cmd);
1077         if (r < 0) {
1078                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1079                 sd_bus_message *reply;
1080
1081                 if (errno == EAGAIN || errno == EINTR)
1082                         return 0;
1083                 else if (errno == ENXIO || errno == ESRCH) {
1084
1085                         /* ENXIO: unique name not known
1086                          * ESRCH: well-known name not known */
1087
1088                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1089                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
1090                         else {
1091                                 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
1092                                 return 0;
1093                         }
1094
1095                 } else if (errno == EADDRNOTAVAIL) {
1096
1097                         /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
1098
1099                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1100                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
1101                         else {
1102                                 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
1103                                 return 0;
1104                         }
1105                 } else
1106                         return -errno;
1107
1108                 r = bus_message_new_synthetic_error(
1109                                 bus,
1110                                 BUS_MESSAGE_COOKIE(m),
1111                                 &error,
1112                                 &reply);
1113
1114                 if (r < 0)
1115                         return r;
1116
1117                 r = bus_seal_synthetic_message(bus, reply);
1118                 if (r < 0)
1119                         return r;
1120
1121                 bus->rqueue[bus->rqueue_size++] = reply;
1122
1123         } else if (hint_sync_call) {
1124                 struct kdbus_msg *k;
1125
1126                 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + cmd.reply.offset);
1127                 assert(k);
1128
1129                 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1130
1131                         r = bus_kernel_make_message(bus, k);
1132                         if (r < 0) {
1133                                 close_kdbus_msg(bus, k);
1134
1135                                 /* Anybody can send us invalid messages, let's just drop them. */
1136                                 if (r == -EBADMSG || r == -EPROTOTYPE)
1137                                         log_debug_errno(r, "Ignoring invalid message: %m");
1138                                 else
1139                                         return r;
1140                         }
1141                 } else {
1142                         log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1143                         close_kdbus_msg(bus, k);
1144                 }
1145         }
1146
1147         return 1;
1148 }
1149
1150 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
1151         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1152         int r;
1153
1154         assert(bus);
1155
1156         r = sd_bus_message_new_signal(
1157                         bus,
1158                         &m,
1159                         "/org/freedesktop/DBus",
1160                         "org.freedesktop.DBus",
1161                         "NameOwnerChanged");
1162         if (r < 0)
1163                 return r;
1164
1165         r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1166         if (r < 0)
1167                 return r;
1168
1169         bus_message_set_sender_driver(bus, m);
1170
1171         r = bus_seal_synthetic_message(bus, m);
1172         if (r < 0)
1173                 return r;
1174
1175         bus->rqueue[bus->rqueue_size++] = m;
1176         m = NULL;
1177
1178         return 1;
1179 }
1180
1181 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1182         char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1183
1184         assert(bus);
1185         assert(k);
1186         assert(d);
1187
1188         if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1189                 old_owner[0] = 0;
1190         else
1191                 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1192
1193         if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1194
1195                 if (isempty(old_owner))
1196                         return 0;
1197
1198                 new_owner[0] = 0;
1199         } else
1200                 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1201
1202         return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
1203 }
1204
1205 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1206         char owner[UNIQUE_NAME_MAX];
1207
1208         assert(bus);
1209         assert(k);
1210         assert(d);
1211
1212         sprintf(owner, ":1.%llu", d->id_change.id);
1213
1214         return push_name_owner_changed(
1215                         bus, owner,
1216                         d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1217                         d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
1218 }
1219
1220 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1221         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1222         int r;
1223
1224         assert(bus);
1225         assert(k);
1226         assert(d);
1227
1228         r = bus_message_new_synthetic_error(
1229                         bus,
1230                         k->cookie_reply,
1231                         d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1232                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1233                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1234                         &m);
1235         if (r < 0)
1236                 return r;
1237
1238         bus_message_set_sender_driver(bus, m);
1239
1240         r = bus_seal_synthetic_message(bus, m);
1241         if (r < 0)
1242                 return r;
1243
1244         bus->rqueue[bus->rqueue_size++] = m;
1245         m = NULL;
1246
1247         return 1;
1248 }
1249
1250 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1251         struct kdbus_item *d, *found = NULL;
1252
1253         static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1254                 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1255                 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1256                 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1257
1258                 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1259                 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1260
1261                 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1262                 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1263         };
1264
1265         assert(bus);
1266         assert(k);
1267         assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1268
1269         KDBUS_ITEM_FOREACH(d, k, items) {
1270                 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1271                         if (found)
1272                                 return -EBADMSG;
1273                         found = d;
1274                 } else
1275                         log_debug("Got unknown field from kernel %llu", d->type);
1276         }
1277
1278         if (!found) {
1279                 log_debug("Didn't find a kernel message to translate.");
1280                 return 0;
1281         }
1282
1283         return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1284 }
1285
1286 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1287         struct kdbus_cmd_recv recv = { .size = sizeof(recv) };
1288         struct kdbus_msg *k;
1289         int r;
1290
1291         assert(bus);
1292
1293         r = bus_rqueue_make_room(bus);
1294         if (r < 0)
1295                 return r;
1296
1297         if (hint_priority) {
1298                 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1299                 recv.priority = priority;
1300         }
1301
1302         r = ioctl(bus->input_fd, KDBUS_CMD_RECV, &recv);
1303         if (r < 0) {
1304                 if (errno == EAGAIN)
1305                         return 0;
1306
1307                 if (errno == EOVERFLOW) {
1308                         log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1309                         return 0;
1310                 }
1311
1312                 return -errno;
1313         }
1314
1315         k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.reply.offset);
1316         if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1317                 r = bus_kernel_make_message(bus, k);
1318
1319                 /* Anybody can send us invalid messages, let's just drop them. */
1320                 if (r == -EBADMSG || r == -EPROTOTYPE) {
1321                         log_debug_errno(r, "Ignoring invalid message: %m");
1322                         r = 0;
1323                 }
1324
1325         } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1326                 r = bus_kernel_translate_message(bus, k);
1327         else {
1328                 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1329                 r = 0;
1330         }
1331
1332         if (r <= 0)
1333                 close_kdbus_msg(bus, k);
1334
1335         return r < 0 ? r : 1;
1336 }
1337
1338 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1339         struct memfd_cache *c;
1340         int fd;
1341
1342         assert(address);
1343         assert(mapped);
1344         assert(allocated);
1345
1346         if (!bus || !bus->is_kernel)
1347                 return -ENOTSUP;
1348
1349         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1350
1351         if (bus->n_memfd_cache <= 0) {
1352                 int r;
1353
1354                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1355
1356                 r = memfd_new(bus->description);
1357                 if (r < 0)
1358                         return r;
1359
1360                 *address = NULL;
1361                 *mapped = 0;
1362                 *allocated = 0;
1363                 return r;
1364         }
1365
1366         c = &bus->memfd_cache[--bus->n_memfd_cache];
1367
1368         assert(c->fd >= 0);
1369         assert(c->mapped == 0 || c->address);
1370
1371         *address = c->address;
1372         *mapped = c->mapped;
1373         *allocated = c->allocated;
1374         fd = c->fd;
1375
1376         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1377
1378         return fd;
1379 }
1380
1381 static void close_and_munmap(int fd, void *address, size_t size) {
1382         if (size > 0)
1383                 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1384
1385         safe_close(fd);
1386 }
1387
1388 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1389         struct memfd_cache *c;
1390         uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1391
1392         assert(fd >= 0);
1393         assert(mapped == 0 || address);
1394
1395         if (!bus || !bus->is_kernel) {
1396                 close_and_munmap(fd, address, mapped);
1397                 return;
1398         }
1399
1400         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1401
1402         if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1403                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1404
1405                 close_and_munmap(fd, address, mapped);
1406                 return;
1407         }
1408
1409         c = &bus->memfd_cache[bus->n_memfd_cache++];
1410         c->fd = fd;
1411         c->address = address;
1412
1413         /* If overly long, let's return a bit to the OS */
1414         if (mapped > max_mapped) {
1415                 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1416                 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1417                 c->mapped = c->allocated = max_mapped;
1418         } else {
1419                 c->mapped = mapped;
1420                 c->allocated = allocated;
1421         }
1422
1423         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1424 }
1425
1426 void bus_kernel_flush_memfd(sd_bus *b) {
1427         unsigned i;
1428
1429         assert(b);
1430
1431         for (i = 0; i < b->n_memfd_cache; i++)
1432                 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1433 }
1434
1435 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1436         uint64_t f = 0;
1437
1438         if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1439                 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1440
1441         if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1442                 f |= KDBUS_NAME_REPLACE_EXISTING;
1443
1444         if (flags & SD_BUS_NAME_QUEUE)
1445                 f |= KDBUS_NAME_QUEUE;
1446
1447         return f;
1448 }
1449
1450 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1451         uint64_t m = 0;
1452
1453         if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1454                     SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1455                 m |= KDBUS_ATTACH_CREDS;
1456
1457         if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_TID))
1458                 m |= KDBUS_ATTACH_PIDS;
1459
1460         if (mask & SD_BUS_CREDS_COMM)
1461                 m |= KDBUS_ATTACH_PID_COMM;
1462
1463         if (mask & SD_BUS_CREDS_TID_COMM)
1464                 m |= KDBUS_ATTACH_TID_COMM;
1465
1466         if (mask & SD_BUS_CREDS_EXE)
1467                 m |= KDBUS_ATTACH_EXE;
1468
1469         if (mask & SD_BUS_CREDS_CMDLINE)
1470                 m |= KDBUS_ATTACH_CMDLINE;
1471
1472         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))
1473                 m |= KDBUS_ATTACH_CGROUP;
1474
1475         if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1476                 m |= KDBUS_ATTACH_CAPS;
1477
1478         if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1479                 m |= KDBUS_ATTACH_SECLABEL;
1480
1481         if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1482                 m |= KDBUS_ATTACH_AUDIT;
1483
1484         if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1485                 m |= KDBUS_ATTACH_NAMES;
1486
1487         if (mask & SD_BUS_CREDS_DESCRIPTION)
1488                 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1489
1490         if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1491                 m |= KDBUS_ATTACH_AUXGROUPS;
1492
1493         return m;
1494 }
1495
1496 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1497         struct kdbus_cmd_make *make;
1498         struct kdbus_item *n;
1499         size_t l;
1500         int fd;
1501
1502         assert(name);
1503         assert(s);
1504
1505         fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1506         if (fd < 0)
1507                 return -errno;
1508
1509         l = strlen(name);
1510         make = alloca0_align(offsetof(struct kdbus_cmd_make, items) +
1511                              ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1512                              ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1513                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1514                              8);
1515
1516         make->size = offsetof(struct kdbus_cmd_make, items);
1517
1518         /* Set the bloom parameters */
1519         n = make->items;
1520         n->size = offsetof(struct kdbus_item, bloom_parameter) +
1521                   sizeof(struct kdbus_bloom_parameter);
1522         n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1523         n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1524         n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1525
1526         assert_cc(DEFAULT_BLOOM_SIZE > 0);
1527         assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1528
1529         make->size += ALIGN8(n->size);
1530
1531         /* The busses we create make no restrictions on what metadata
1532          * peers can read from incoming messages. */
1533         n = KDBUS_ITEM_NEXT(n);
1534         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1535         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1536         n->data64[0] = _KDBUS_ATTACH_ANY;
1537         make->size += ALIGN8(n->size);
1538
1539         /* Set the a good name */
1540         n = KDBUS_ITEM_NEXT(n);
1541         sprintf(n->str, UID_FMT "-%s", getuid(), name);
1542         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1543         n->type = KDBUS_ITEM_MAKE_NAME;
1544         make->size += ALIGN8(n->size);
1545
1546         make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1547
1548         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1549                 safe_close(fd);
1550                 return -errno;
1551         }
1552
1553         if (s) {
1554                 char *p;
1555
1556                 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1557                 if (!p) {
1558                         safe_close(fd);
1559                         return -ENOMEM;
1560                 }
1561
1562                 *s = p;
1563         }
1564
1565         return fd;
1566 }
1567
1568 static int bus_kernel_translate_access(BusPolicyAccess access) {
1569         assert(access >= 0);
1570         assert(access < _BUS_POLICY_ACCESS_MAX);
1571
1572         switch (access) {
1573
1574         case BUS_POLICY_ACCESS_SEE:
1575                 return KDBUS_POLICY_SEE;
1576
1577         case BUS_POLICY_ACCESS_TALK:
1578                 return KDBUS_POLICY_TALK;
1579
1580         case BUS_POLICY_ACCESS_OWN:
1581                 return KDBUS_POLICY_OWN;
1582
1583         default:
1584                 assert_not_reached("Unknown policy access");
1585         }
1586 }
1587
1588 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1589         int r;
1590
1591         assert(policy);
1592         assert(item);
1593
1594         switch (policy->type) {
1595
1596         case BUSNAME_POLICY_TYPE_USER: {
1597                 const char *user = policy->name;
1598                 uid_t uid;
1599
1600                 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1601                 if (r < 0)
1602                         return r;
1603
1604                 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1605                 item->policy_access.id = uid;
1606                 break;
1607         }
1608
1609         case BUSNAME_POLICY_TYPE_GROUP: {
1610                 const char *group = policy->name;
1611                 gid_t gid;
1612
1613                 r = get_group_creds(&group, &gid);
1614                 if (r < 0)
1615                         return r;
1616
1617                 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1618                 item->policy_access.id = gid;
1619                 break;
1620         }
1621
1622         default:
1623                 assert_not_reached("Unknown policy type");
1624         }
1625
1626         item->policy_access.access = bus_kernel_translate_access(policy->access);
1627
1628         return 0;
1629 }
1630
1631 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1632         char *p;
1633         int fd;
1634         size_t len;
1635
1636         assert(bus);
1637
1638         len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1639
1640         if (path) {
1641                 p = new(char, len);
1642                 if (!p)
1643                         return -ENOMEM;
1644         } else
1645                 p = newa(char, len);
1646
1647         sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1648
1649         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1650         if (fd < 0) {
1651                 if (path)
1652                         free(p);
1653
1654                 return -errno;
1655         }
1656
1657         if (path)
1658                 *path = p;
1659
1660         return fd;
1661 }
1662
1663 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1664         _cleanup_free_ char *path = NULL;
1665         struct kdbus_cmd_make *make;
1666         struct kdbus_item *n;
1667         const char *name;
1668         int fd;
1669
1670         fd = bus_kernel_open_bus_fd(bus_name, &path);
1671         if (fd < 0)
1672                 return fd;
1673
1674         make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) +
1675                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1676                              8);
1677         make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1678         make->flags = KDBUS_MAKE_ACCESS_WORLD;
1679
1680         n = make->items;
1681         sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1682         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1683         n->type = KDBUS_ITEM_MAKE_NAME;
1684         make->size += ALIGN8(n->size);
1685         name = n->str;
1686
1687         if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1688                 safe_close(fd);
1689                 return -errno;
1690         }
1691
1692         if (ep_path) {
1693                 char *p;
1694
1695                 p = strjoin(dirname(path), "/", name, NULL);
1696                 if (!p) {
1697                         safe_close(fd);
1698                         return -ENOMEM;
1699                 }
1700
1701                 *ep_path = p;
1702         }
1703
1704         return fd;
1705 }
1706
1707 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
1708
1709         struct kdbus_cmd_update *update;
1710         struct kdbus_item *n;
1711         BusEndpointPolicy *po;
1712         Iterator i;
1713         size_t size;
1714         int r;
1715
1716         size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
1717
1718         HASHMAP_FOREACH(po, ep->policy_hash, i) {
1719                 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
1720                 size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1721         }
1722
1723         update = alloca0_align(size, 8);
1724         update->size = size;
1725
1726         n = update->items;
1727
1728         HASHMAP_FOREACH(po, ep->policy_hash, i) {
1729                 n->type = KDBUS_ITEM_NAME;
1730                 n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1;
1731                 strcpy(n->str, po->name);
1732                 n = KDBUS_ITEM_NEXT(n);
1733
1734                 n->type = KDBUS_ITEM_POLICY_ACCESS;
1735                 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1736
1737                 n->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1738                 n->policy_access.access = bus_kernel_translate_access(po->access);
1739                 n->policy_access.id = uid;
1740
1741                 n = KDBUS_ITEM_NEXT(n);
1742         }
1743
1744         r = ioctl(fd, KDBUS_CMD_ENDPOINT_UPDATE, update);
1745         if (r < 0)
1746                 return -errno;
1747
1748         return 0;
1749 }
1750
1751 int bus_kernel_make_starter(
1752                 int fd,
1753                 const char *name,
1754                 bool activating,
1755                 bool accept_fd,
1756                 BusNamePolicy *policy,
1757                 BusPolicyAccess world_policy) {
1758
1759         struct kdbus_cmd_free cmd_free = { .size = sizeof(cmd_free) };
1760         struct kdbus_cmd_hello *hello;
1761         struct kdbus_item *n;
1762         size_t policy_cnt = 0;
1763         BusNamePolicy *po;
1764         size_t size;
1765         int r;
1766
1767         assert(fd >= 0);
1768         assert(name);
1769
1770         LIST_FOREACH(policy, po, policy)
1771                 policy_cnt++;
1772
1773         if (world_policy >= 0)
1774                 policy_cnt++;
1775
1776         size = offsetof(struct kdbus_cmd_hello, items) +
1777                ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1778                policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1779
1780         hello = alloca0_align(size, 8);
1781
1782         n = hello->items;
1783         strcpy(n->str, name);
1784         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1785         n->type = KDBUS_ITEM_NAME;
1786         n = KDBUS_ITEM_NEXT(n);
1787
1788         LIST_FOREACH(policy, po, policy) {
1789                 n->type = KDBUS_ITEM_POLICY_ACCESS;
1790                 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1791
1792                 r = bus_kernel_translate_policy(po, n);
1793                 if (r < 0)
1794                         return r;
1795
1796                 n = KDBUS_ITEM_NEXT(n);
1797         }
1798
1799         if (world_policy >= 0) {
1800                 n->type = KDBUS_ITEM_POLICY_ACCESS;
1801                 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1802                 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1803                 n->policy_access.access = bus_kernel_translate_access(world_policy);
1804         }
1805
1806         hello->size = size;
1807         hello->flags =
1808                 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1809                 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1810         hello->pool_size = KDBUS_POOL_SIZE;
1811         hello->attach_flags_send = _KDBUS_ATTACH_ANY;
1812         hello->attach_flags_recv = _KDBUS_ATTACH_ANY;
1813
1814         if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1815                 return -errno;
1816
1817         /* not interested in any output values */
1818         cmd_free.offset = hello->offset;
1819         (void) ioctl(fd, KDBUS_CMD_FREE, &cmd_free);
1820
1821         /* The higher 32bit of the bus_flags fields are considered
1822          * 'incompatible flags'. Refuse them all for now. */
1823         if (hello->bus_flags > 0xFFFFFFFFULL)
1824                 return -ENOTSUP;
1825
1826         return fd;
1827 }
1828
1829 int bus_kernel_try_close(sd_bus *bus) {
1830         assert(bus);
1831         assert(bus->is_kernel);
1832
1833         if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1834                 return -errno;
1835
1836         return 0;
1837 }
1838
1839 int bus_kernel_drop_one(int fd) {
1840         struct kdbus_cmd_recv recv = {
1841                 .size = sizeof(recv),
1842                 .flags = KDBUS_RECV_DROP,
1843         };
1844
1845         assert(fd >= 0);
1846
1847         if (ioctl(fd, KDBUS_CMD_RECV, &recv) < 0)
1848                 return -errno;
1849
1850         return 0;
1851 }
1852
1853 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1854         struct kdbus_cmd_update *update;
1855         struct kdbus_item *n;
1856
1857         assert(bus);
1858         assert(bus->is_kernel);
1859
1860         update = alloca0_align(offsetof(struct kdbus_cmd_update, items) +
1861                                ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1862                                8);
1863
1864         n = update->items;
1865         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1866         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1867         n->data64[0] = bus->attach_flags;
1868
1869         update->size =
1870                 offsetof(struct kdbus_cmd_update, items) +
1871                 ALIGN8(n->size);
1872
1873         if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0)
1874                 return -errno;
1875
1876         return 0;
1877 }
1878
1879 int bus_kernel_fix_attach_mask(void) {
1880         _cleanup_free_ char *mask = NULL;
1881         uint64_t m = (uint64_t) -1;
1882         char buf[2+16+2];
1883         int r;
1884
1885         /* By default we don't want any kdbus metadata fields to be
1886          * suppressed, hence we reset the kernel mask for it to
1887          * (uint64_t) -1. This is overridable via a kernel command
1888          * line option, however. */
1889
1890         r = get_proc_cmdline_key("systemd.kdbus_attach_flags_mask=", &mask);
1891         if (r < 0)
1892                 return log_warning_errno(r, "Failed to read kernel command line: %m");
1893
1894         if (mask) {
1895                 const char *p = mask;
1896
1897                 if (startswith(p, "0x"))
1898                         p += 2;
1899
1900                 if (sscanf(p, "%" PRIx64, &m) != 1)
1901                         log_warning("Couldn't parse systemd.kdbus_attach_flags_mask= kernel command line parameter.");
1902         }
1903
1904         sprintf(buf, "0x%" PRIx64 "\n", m);
1905         r = write_string_file("/sys/module/kdbus/parameters/attach_flags_mask", buf);
1906         if (r < 0)
1907                 return log_full_errno(
1908                                 IN_SET(r, -ENOENT, -EROFS) ? LOG_DEBUG : LOG_WARNING, r,
1909                                 "Failed to write kdbus attach mask: %m");
1910
1911         return 0;
1912 }
1913
1914 int bus_kernel_get_bus_name(sd_bus *bus, char **name) {
1915         struct kdbus_cmd_info cmd = {
1916                 .size = sizeof(struct kdbus_cmd_info),
1917         };
1918         struct kdbus_info *info;
1919         struct kdbus_item *item;
1920         char *n = NULL;
1921         int r;
1922
1923         assert(bus);
1924         assert(name);
1925         assert(bus->is_kernel);
1926
1927         r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
1928         if (r < 0)
1929                 return -errno;
1930
1931         info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset);
1932
1933         KDBUS_ITEM_FOREACH(item, info, items)
1934                 if (item->type == KDBUS_ITEM_MAKE_NAME) {
1935                         r = free_and_strdup(&n, item->str);
1936                         break;
1937                 }
1938
1939         bus_kernel_cmd_free(bus, cmd.offset);
1940
1941         if (r < 0)
1942                 return r;
1943         if (!n)
1944                 return -EIO;
1945
1946         *name = n;
1947         return 0;
1948 }