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, data64) + sizeof(uint64_t)) +
1514                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1515                              8);
1516
1517         make->size = offsetof(struct kdbus_cmd_make, items);
1518
1519         /* Set the bloom parameters */
1520         n = make->items;
1521         n->size = offsetof(struct kdbus_item, bloom_parameter) +
1522                   sizeof(struct kdbus_bloom_parameter);
1523         n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1524         n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1525         n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1526
1527         assert_cc(DEFAULT_BLOOM_SIZE > 0);
1528         assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1529
1530         make->size += ALIGN8(n->size);
1531
1532         /* The busses we create make no restrictions on what metadata
1533          * peers can read from incoming messages. */
1534         n = KDBUS_ITEM_NEXT(n);
1535         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1536         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1537         n->data64[0] = _KDBUS_ATTACH_ANY;
1538         make->size += ALIGN8(n->size);
1539
1540         /* Provide all metadata via bus-owner queries */
1541         n = KDBUS_ITEM_NEXT(n);
1542         n->type = KDBUS_ITEM_ATTACH_FLAGS_SEND;
1543         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1544         n->data64[0] = _KDBUS_ATTACH_ANY;
1545         make->size += ALIGN8(n->size);
1546
1547         /* Set the a good name */
1548         n = KDBUS_ITEM_NEXT(n);
1549         sprintf(n->str, UID_FMT "-%s", getuid(), name);
1550         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1551         n->type = KDBUS_ITEM_MAKE_NAME;
1552         make->size += ALIGN8(n->size);
1553
1554         make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1555
1556         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1557                 safe_close(fd);
1558                 return -errno;
1559         }
1560
1561         if (s) {
1562                 char *p;
1563
1564                 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1565                 if (!p) {
1566                         safe_close(fd);
1567                         return -ENOMEM;
1568                 }
1569
1570                 *s = p;
1571         }
1572
1573         return fd;
1574 }
1575
1576 static int bus_kernel_translate_access(BusPolicyAccess access) {
1577         assert(access >= 0);
1578         assert(access < _BUS_POLICY_ACCESS_MAX);
1579
1580         switch (access) {
1581
1582         case BUS_POLICY_ACCESS_SEE:
1583                 return KDBUS_POLICY_SEE;
1584
1585         case BUS_POLICY_ACCESS_TALK:
1586                 return KDBUS_POLICY_TALK;
1587
1588         case BUS_POLICY_ACCESS_OWN:
1589                 return KDBUS_POLICY_OWN;
1590
1591         default:
1592                 assert_not_reached("Unknown policy access");
1593         }
1594 }
1595
1596 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1597         int r;
1598
1599         assert(policy);
1600         assert(item);
1601
1602         switch (policy->type) {
1603
1604         case BUSNAME_POLICY_TYPE_USER: {
1605                 const char *user = policy->name;
1606                 uid_t uid;
1607
1608                 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1609                 if (r < 0)
1610                         return r;
1611
1612                 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1613                 item->policy_access.id = uid;
1614                 break;
1615         }
1616
1617         case BUSNAME_POLICY_TYPE_GROUP: {
1618                 const char *group = policy->name;
1619                 gid_t gid;
1620
1621                 r = get_group_creds(&group, &gid);
1622                 if (r < 0)
1623                         return r;
1624
1625                 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1626                 item->policy_access.id = gid;
1627                 break;
1628         }
1629
1630         default:
1631                 assert_not_reached("Unknown policy type");
1632         }
1633
1634         item->policy_access.access = bus_kernel_translate_access(policy->access);
1635
1636         return 0;
1637 }
1638
1639 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1640         char *p;
1641         int fd;
1642         size_t len;
1643
1644         assert(bus);
1645
1646         len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1647
1648         if (path) {
1649                 p = new(char, len);
1650                 if (!p)
1651                         return -ENOMEM;
1652         } else
1653                 p = newa(char, len);
1654
1655         sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1656
1657         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1658         if (fd < 0) {
1659                 if (path)
1660                         free(p);
1661
1662                 return -errno;
1663         }
1664
1665         if (path)
1666                 *path = p;
1667
1668         return fd;
1669 }
1670
1671 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1672         _cleanup_free_ char *path = NULL;
1673         struct kdbus_cmd_make *make;
1674         struct kdbus_item *n;
1675         const char *name;
1676         int fd;
1677
1678         fd = bus_kernel_open_bus_fd(bus_name, &path);
1679         if (fd < 0)
1680                 return fd;
1681
1682         make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) +
1683                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1684                              8);
1685         make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1686         make->flags = KDBUS_MAKE_ACCESS_WORLD;
1687
1688         n = make->items;
1689         sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1690         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1691         n->type = KDBUS_ITEM_MAKE_NAME;
1692         make->size += ALIGN8(n->size);
1693         name = n->str;
1694
1695         if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1696                 safe_close(fd);
1697                 return -errno;
1698         }
1699
1700         if (ep_path) {
1701                 char *p;
1702
1703                 p = strjoin(dirname(path), "/", name, NULL);
1704                 if (!p) {
1705                         safe_close(fd);
1706                         return -ENOMEM;
1707                 }
1708
1709                 *ep_path = p;
1710         }
1711
1712         return fd;
1713 }
1714
1715 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
1716
1717         struct kdbus_cmd_update *update;
1718         struct kdbus_item *n;
1719         BusEndpointPolicy *po;
1720         Iterator i;
1721         size_t size;
1722         int r;
1723
1724         size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
1725
1726         HASHMAP_FOREACH(po, ep->policy_hash, i) {
1727                 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
1728                 size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1729         }
1730
1731         update = alloca0_align(size, 8);
1732         update->size = size;
1733
1734         n = update->items;
1735
1736         HASHMAP_FOREACH(po, ep->policy_hash, i) {
1737                 n->type = KDBUS_ITEM_NAME;
1738                 n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1;
1739                 strcpy(n->str, po->name);
1740                 n = KDBUS_ITEM_NEXT(n);
1741
1742                 n->type = KDBUS_ITEM_POLICY_ACCESS;
1743                 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1744
1745                 n->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1746                 n->policy_access.access = bus_kernel_translate_access(po->access);
1747                 n->policy_access.id = uid;
1748
1749                 n = KDBUS_ITEM_NEXT(n);
1750         }
1751
1752         r = ioctl(fd, KDBUS_CMD_ENDPOINT_UPDATE, update);
1753         if (r < 0)
1754                 return -errno;
1755
1756         return 0;
1757 }
1758
1759 int bus_kernel_make_starter(
1760                 int fd,
1761                 const char *name,
1762                 bool activating,
1763                 bool accept_fd,
1764                 BusNamePolicy *policy,
1765                 BusPolicyAccess world_policy) {
1766
1767         struct kdbus_cmd_free cmd_free = { .size = sizeof(cmd_free) };
1768         struct kdbus_cmd_hello *hello;
1769         struct kdbus_item *n;
1770         size_t policy_cnt = 0;
1771         BusNamePolicy *po;
1772         size_t size;
1773         int r;
1774
1775         assert(fd >= 0);
1776         assert(name);
1777
1778         LIST_FOREACH(policy, po, policy)
1779                 policy_cnt++;
1780
1781         if (world_policy >= 0)
1782                 policy_cnt++;
1783
1784         size = offsetof(struct kdbus_cmd_hello, items) +
1785                ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1786                policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1787
1788         hello = alloca0_align(size, 8);
1789
1790         n = hello->items;
1791         strcpy(n->str, name);
1792         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1793         n->type = KDBUS_ITEM_NAME;
1794         n = KDBUS_ITEM_NEXT(n);
1795
1796         LIST_FOREACH(policy, po, policy) {
1797                 n->type = KDBUS_ITEM_POLICY_ACCESS;
1798                 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1799
1800                 r = bus_kernel_translate_policy(po, n);
1801                 if (r < 0)
1802                         return r;
1803
1804                 n = KDBUS_ITEM_NEXT(n);
1805         }
1806
1807         if (world_policy >= 0) {
1808                 n->type = KDBUS_ITEM_POLICY_ACCESS;
1809                 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1810                 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1811                 n->policy_access.access = bus_kernel_translate_access(world_policy);
1812         }
1813
1814         hello->size = size;
1815         hello->flags =
1816                 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1817                 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1818         hello->pool_size = KDBUS_POOL_SIZE;
1819         hello->attach_flags_send = _KDBUS_ATTACH_ANY;
1820         hello->attach_flags_recv = _KDBUS_ATTACH_ANY;
1821
1822         if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1823                 return -errno;
1824
1825         /* not interested in any output values */
1826         cmd_free.offset = hello->offset;
1827         (void) ioctl(fd, KDBUS_CMD_FREE, &cmd_free);
1828
1829         /* The higher 32bit of the bus_flags fields are considered
1830          * 'incompatible flags'. Refuse them all for now. */
1831         if (hello->bus_flags > 0xFFFFFFFFULL)
1832                 return -ENOTSUP;
1833
1834         return fd;
1835 }
1836
1837 int bus_kernel_try_close(sd_bus *bus) {
1838         assert(bus);
1839         assert(bus->is_kernel);
1840
1841         if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1842                 return -errno;
1843
1844         return 0;
1845 }
1846
1847 int bus_kernel_drop_one(int fd) {
1848         struct kdbus_cmd_recv recv = {
1849                 .size = sizeof(recv),
1850                 .flags = KDBUS_RECV_DROP,
1851         };
1852
1853         assert(fd >= 0);
1854
1855         if (ioctl(fd, KDBUS_CMD_RECV, &recv) < 0)
1856                 return -errno;
1857
1858         return 0;
1859 }
1860
1861 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1862         struct kdbus_cmd_update *update;
1863         struct kdbus_item *n;
1864
1865         assert(bus);
1866         assert(bus->is_kernel);
1867
1868         update = alloca0_align(offsetof(struct kdbus_cmd_update, items) +
1869                                ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1870                                8);
1871
1872         n = update->items;
1873         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1874         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1875         n->data64[0] = bus->attach_flags;
1876
1877         update->size =
1878                 offsetof(struct kdbus_cmd_update, items) +
1879                 ALIGN8(n->size);
1880
1881         if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0)
1882                 return -errno;
1883
1884         return 0;
1885 }
1886
1887 int bus_kernel_fix_attach_mask(void) {
1888         _cleanup_free_ char *mask = NULL;
1889         uint64_t m = (uint64_t) -1;
1890         char buf[2+16+2];
1891         int r;
1892
1893         /* By default we don't want any kdbus metadata fields to be
1894          * suppressed, hence we reset the kernel mask for it to
1895          * (uint64_t) -1. This is overridable via a kernel command
1896          * line option, however. */
1897
1898         r = get_proc_cmdline_key("systemd.kdbus_attach_flags_mask=", &mask);
1899         if (r < 0)
1900                 return log_warning_errno(r, "Failed to read kernel command line: %m");
1901
1902         if (mask) {
1903                 const char *p = mask;
1904
1905                 if (startswith(p, "0x"))
1906                         p += 2;
1907
1908                 if (sscanf(p, "%" PRIx64, &m) != 1)
1909                         log_warning("Couldn't parse systemd.kdbus_attach_flags_mask= kernel command line parameter.");
1910         }
1911
1912         sprintf(buf, "0x%" PRIx64 "\n", m);
1913         r = write_string_file("/sys/module/kdbus/parameters/attach_flags_mask", buf);
1914         if (r < 0)
1915                 return log_full_errno(
1916                                 IN_SET(r, -ENOENT, -EROFS) ? LOG_DEBUG : LOG_WARNING, r,
1917                                 "Failed to write kdbus attach mask: %m");
1918
1919         return 0;
1920 }
1921
1922 int bus_kernel_get_bus_name(sd_bus *bus, char **name) {
1923         struct kdbus_cmd_info cmd = {
1924                 .size = sizeof(struct kdbus_cmd_info),
1925         };
1926         struct kdbus_info *info;
1927         struct kdbus_item *item;
1928         char *n = NULL;
1929         int r;
1930
1931         assert(bus);
1932         assert(name);
1933         assert(bus->is_kernel);
1934
1935         r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
1936         if (r < 0)
1937                 return -errno;
1938
1939         info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset);
1940
1941         KDBUS_ITEM_FOREACH(item, info, items)
1942                 if (item->type == KDBUS_ITEM_MAKE_NAME) {
1943                         r = free_and_strdup(&n, item->str);
1944                         break;
1945                 }
1946
1947         bus_kernel_cmd_free(bus, cmd.offset);
1948
1949         if (r < 0)
1950                 return r;
1951         if (!n)
1952                 return -EIO;
1953
1954         *name = n;
1955         return 0;
1956 }