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_TIMESTAMP)
1271                         continue;
1272
1273                 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1274                         if (found)
1275                                 return -EBADMSG;
1276                         found = d;
1277                 } else
1278                         log_debug("Got unknown field from kernel %llu", d->type);
1279         }
1280
1281         if (!found) {
1282                 log_debug("Didn't find a kernel message to translate.");
1283                 return 0;
1284         }
1285
1286         return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1287 }
1288
1289 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1290         struct kdbus_cmd_recv recv = { .size = sizeof(recv) };
1291         struct kdbus_msg *k;
1292         int r;
1293
1294         assert(bus);
1295
1296         r = bus_rqueue_make_room(bus);
1297         if (r < 0)
1298                 return r;
1299
1300         if (hint_priority) {
1301                 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1302                 recv.priority = priority;
1303         }
1304
1305         r = ioctl(bus->input_fd, KDBUS_CMD_RECV, &recv);
1306         if (r < 0) {
1307                 if (errno == EAGAIN)
1308                         return 0;
1309
1310                 if (errno == EOVERFLOW) {
1311                         log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1312                         return 0;
1313                 }
1314
1315                 return -errno;
1316         }
1317
1318         k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.reply.offset);
1319         if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1320                 r = bus_kernel_make_message(bus, k);
1321
1322                 /* Anybody can send us invalid messages, let's just drop them. */
1323                 if (r == -EBADMSG || r == -EPROTOTYPE) {
1324                         log_debug_errno(r, "Ignoring invalid message: %m");
1325                         r = 0;
1326                 }
1327
1328         } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1329                 r = bus_kernel_translate_message(bus, k);
1330         else {
1331                 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1332                 r = 0;
1333         }
1334
1335         if (r <= 0)
1336                 close_kdbus_msg(bus, k);
1337
1338         return r < 0 ? r : 1;
1339 }
1340
1341 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1342         struct memfd_cache *c;
1343         int fd;
1344
1345         assert(address);
1346         assert(mapped);
1347         assert(allocated);
1348
1349         if (!bus || !bus->is_kernel)
1350                 return -ENOTSUP;
1351
1352         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1353
1354         if (bus->n_memfd_cache <= 0) {
1355                 int r;
1356
1357                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1358
1359                 r = memfd_new(bus->description);
1360                 if (r < 0)
1361                         return r;
1362
1363                 *address = NULL;
1364                 *mapped = 0;
1365                 *allocated = 0;
1366                 return r;
1367         }
1368
1369         c = &bus->memfd_cache[--bus->n_memfd_cache];
1370
1371         assert(c->fd >= 0);
1372         assert(c->mapped == 0 || c->address);
1373
1374         *address = c->address;
1375         *mapped = c->mapped;
1376         *allocated = c->allocated;
1377         fd = c->fd;
1378
1379         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1380
1381         return fd;
1382 }
1383
1384 static void close_and_munmap(int fd, void *address, size_t size) {
1385         if (size > 0)
1386                 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1387
1388         safe_close(fd);
1389 }
1390
1391 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1392         struct memfd_cache *c;
1393         uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1394
1395         assert(fd >= 0);
1396         assert(mapped == 0 || address);
1397
1398         if (!bus || !bus->is_kernel) {
1399                 close_and_munmap(fd, address, mapped);
1400                 return;
1401         }
1402
1403         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1404
1405         if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1406                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1407
1408                 close_and_munmap(fd, address, mapped);
1409                 return;
1410         }
1411
1412         c = &bus->memfd_cache[bus->n_memfd_cache++];
1413         c->fd = fd;
1414         c->address = address;
1415
1416         /* If overly long, let's return a bit to the OS */
1417         if (mapped > max_mapped) {
1418                 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1419                 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1420                 c->mapped = c->allocated = max_mapped;
1421         } else {
1422                 c->mapped = mapped;
1423                 c->allocated = allocated;
1424         }
1425
1426         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1427 }
1428
1429 void bus_kernel_flush_memfd(sd_bus *b) {
1430         unsigned i;
1431
1432         assert(b);
1433
1434         for (i = 0; i < b->n_memfd_cache; i++)
1435                 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1436 }
1437
1438 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1439         uint64_t f = 0;
1440
1441         if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1442                 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1443
1444         if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1445                 f |= KDBUS_NAME_REPLACE_EXISTING;
1446
1447         if (flags & SD_BUS_NAME_QUEUE)
1448                 f |= KDBUS_NAME_QUEUE;
1449
1450         return f;
1451 }
1452
1453 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1454         uint64_t m = 0;
1455
1456         if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1457                     SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1458                 m |= KDBUS_ATTACH_CREDS;
1459
1460         if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_TID))
1461                 m |= KDBUS_ATTACH_PIDS;
1462
1463         if (mask & SD_BUS_CREDS_COMM)
1464                 m |= KDBUS_ATTACH_PID_COMM;
1465
1466         if (mask & SD_BUS_CREDS_TID_COMM)
1467                 m |= KDBUS_ATTACH_TID_COMM;
1468
1469         if (mask & SD_BUS_CREDS_EXE)
1470                 m |= KDBUS_ATTACH_EXE;
1471
1472         if (mask & SD_BUS_CREDS_CMDLINE)
1473                 m |= KDBUS_ATTACH_CMDLINE;
1474
1475         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))
1476                 m |= KDBUS_ATTACH_CGROUP;
1477
1478         if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1479                 m |= KDBUS_ATTACH_CAPS;
1480
1481         if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1482                 m |= KDBUS_ATTACH_SECLABEL;
1483
1484         if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1485                 m |= KDBUS_ATTACH_AUDIT;
1486
1487         if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1488                 m |= KDBUS_ATTACH_NAMES;
1489
1490         if (mask & SD_BUS_CREDS_DESCRIPTION)
1491                 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1492
1493         if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1494                 m |= KDBUS_ATTACH_AUXGROUPS;
1495
1496         return m;
1497 }
1498
1499 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1500         struct kdbus_cmd_make *make;
1501         struct kdbus_item *n;
1502         size_t l;
1503         int fd;
1504
1505         assert(name);
1506         assert(s);
1507
1508         fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1509         if (fd < 0)
1510                 return -errno;
1511
1512         l = strlen(name);
1513         make = alloca0_align(offsetof(struct kdbus_cmd_make, items) +
1514                              ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1515                              ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1516                              ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1517                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1518                              8);
1519
1520         make->size = offsetof(struct kdbus_cmd_make, items);
1521
1522         /* Set the bloom parameters */
1523         n = make->items;
1524         n->size = offsetof(struct kdbus_item, bloom_parameter) +
1525                   sizeof(struct kdbus_bloom_parameter);
1526         n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1527         n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1528         n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1529
1530         assert_cc(DEFAULT_BLOOM_SIZE > 0);
1531         assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1532
1533         make->size += ALIGN8(n->size);
1534
1535         /* The busses we create make no restrictions on what metadata
1536          * peers can read from incoming messages. */
1537         n = KDBUS_ITEM_NEXT(n);
1538         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1539         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1540         n->data64[0] = _KDBUS_ATTACH_ANY;
1541         make->size += ALIGN8(n->size);
1542
1543         /* Provide all metadata via bus-owner queries */
1544         n = KDBUS_ITEM_NEXT(n);
1545         n->type = KDBUS_ITEM_ATTACH_FLAGS_SEND;
1546         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1547         n->data64[0] = _KDBUS_ATTACH_ANY;
1548         make->size += ALIGN8(n->size);
1549
1550         /* Set the a good name */
1551         n = KDBUS_ITEM_NEXT(n);
1552         sprintf(n->str, UID_FMT "-%s", getuid(), name);
1553         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1554         n->type = KDBUS_ITEM_MAKE_NAME;
1555         make->size += ALIGN8(n->size);
1556
1557         make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1558
1559         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1560                 safe_close(fd);
1561                 return -errno;
1562         }
1563
1564         if (s) {
1565                 char *p;
1566
1567                 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1568                 if (!p) {
1569                         safe_close(fd);
1570                         return -ENOMEM;
1571                 }
1572
1573                 *s = p;
1574         }
1575
1576         return fd;
1577 }
1578
1579 static int bus_kernel_translate_access(BusPolicyAccess access) {
1580         assert(access >= 0);
1581         assert(access < _BUS_POLICY_ACCESS_MAX);
1582
1583         switch (access) {
1584
1585         case BUS_POLICY_ACCESS_SEE:
1586                 return KDBUS_POLICY_SEE;
1587
1588         case BUS_POLICY_ACCESS_TALK:
1589                 return KDBUS_POLICY_TALK;
1590
1591         case BUS_POLICY_ACCESS_OWN:
1592                 return KDBUS_POLICY_OWN;
1593
1594         default:
1595                 assert_not_reached("Unknown policy access");
1596         }
1597 }
1598
1599 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1600         int r;
1601
1602         assert(policy);
1603         assert(item);
1604
1605         switch (policy->type) {
1606
1607         case BUSNAME_POLICY_TYPE_USER: {
1608                 const char *user = policy->name;
1609                 uid_t uid;
1610
1611                 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1612                 if (r < 0)
1613                         return r;
1614
1615                 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1616                 item->policy_access.id = uid;
1617                 break;
1618         }
1619
1620         case BUSNAME_POLICY_TYPE_GROUP: {
1621                 const char *group = policy->name;
1622                 gid_t gid;
1623
1624                 r = get_group_creds(&group, &gid);
1625                 if (r < 0)
1626                         return r;
1627
1628                 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1629                 item->policy_access.id = gid;
1630                 break;
1631         }
1632
1633         default:
1634                 assert_not_reached("Unknown policy type");
1635         }
1636
1637         item->policy_access.access = bus_kernel_translate_access(policy->access);
1638
1639         return 0;
1640 }
1641
1642 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1643         char *p;
1644         int fd;
1645         size_t len;
1646
1647         assert(bus);
1648
1649         len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1650
1651         if (path) {
1652                 p = new(char, len);
1653                 if (!p)
1654                         return -ENOMEM;
1655         } else
1656                 p = newa(char, len);
1657
1658         sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1659
1660         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1661         if (fd < 0) {
1662                 if (path)
1663                         free(p);
1664
1665                 return -errno;
1666         }
1667
1668         if (path)
1669                 *path = p;
1670
1671         return fd;
1672 }
1673
1674 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1675         _cleanup_free_ char *path = NULL;
1676         struct kdbus_cmd_make *make;
1677         struct kdbus_item *n;
1678         const char *name;
1679         int fd;
1680
1681         fd = bus_kernel_open_bus_fd(bus_name, &path);
1682         if (fd < 0)
1683                 return fd;
1684
1685         make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) +
1686                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1687                              8);
1688         make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1689         make->flags = KDBUS_MAKE_ACCESS_WORLD;
1690
1691         n = make->items;
1692         sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1693         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1694         n->type = KDBUS_ITEM_MAKE_NAME;
1695         make->size += ALIGN8(n->size);
1696         name = n->str;
1697
1698         if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1699                 safe_close(fd);
1700                 return -errno;
1701         }
1702
1703         if (ep_path) {
1704                 char *p;
1705
1706                 p = strjoin(dirname(path), "/", name, NULL);
1707                 if (!p) {
1708                         safe_close(fd);
1709                         return -ENOMEM;
1710                 }
1711
1712                 *ep_path = p;
1713         }
1714
1715         return fd;
1716 }
1717
1718 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
1719
1720         struct kdbus_cmd_update *update;
1721         struct kdbus_item *n;
1722         BusEndpointPolicy *po;
1723         Iterator i;
1724         size_t size;
1725         int r;
1726
1727         size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
1728
1729         HASHMAP_FOREACH(po, ep->policy_hash, i) {
1730                 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
1731                 size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1732         }
1733
1734         update = alloca0_align(size, 8);
1735         update->size = size;
1736
1737         n = update->items;
1738
1739         HASHMAP_FOREACH(po, ep->policy_hash, i) {
1740                 n->type = KDBUS_ITEM_NAME;
1741                 n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1;
1742                 strcpy(n->str, po->name);
1743                 n = KDBUS_ITEM_NEXT(n);
1744
1745                 n->type = KDBUS_ITEM_POLICY_ACCESS;
1746                 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1747
1748                 n->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1749                 n->policy_access.access = bus_kernel_translate_access(po->access);
1750                 n->policy_access.id = uid;
1751
1752                 n = KDBUS_ITEM_NEXT(n);
1753         }
1754
1755         r = ioctl(fd, KDBUS_CMD_ENDPOINT_UPDATE, update);
1756         if (r < 0)
1757                 return -errno;
1758
1759         return 0;
1760 }
1761
1762 int bus_kernel_make_starter(
1763                 int fd,
1764                 const char *name,
1765                 bool activating,
1766                 bool accept_fd,
1767                 BusNamePolicy *policy,
1768                 BusPolicyAccess world_policy) {
1769
1770         struct kdbus_cmd_free cmd_free = { .size = sizeof(cmd_free) };
1771         struct kdbus_cmd_hello *hello;
1772         struct kdbus_item *n;
1773         size_t policy_cnt = 0;
1774         BusNamePolicy *po;
1775         size_t size;
1776         int r;
1777
1778         assert(fd >= 0);
1779         assert(name);
1780
1781         LIST_FOREACH(policy, po, policy)
1782                 policy_cnt++;
1783
1784         if (world_policy >= 0)
1785                 policy_cnt++;
1786
1787         size = offsetof(struct kdbus_cmd_hello, items) +
1788                ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1789                policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1790
1791         hello = alloca0_align(size, 8);
1792
1793         n = hello->items;
1794         strcpy(n->str, name);
1795         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1796         n->type = KDBUS_ITEM_NAME;
1797         n = KDBUS_ITEM_NEXT(n);
1798
1799         LIST_FOREACH(policy, po, policy) {
1800                 n->type = KDBUS_ITEM_POLICY_ACCESS;
1801                 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1802
1803                 r = bus_kernel_translate_policy(po, n);
1804                 if (r < 0)
1805                         return r;
1806
1807                 n = KDBUS_ITEM_NEXT(n);
1808         }
1809
1810         if (world_policy >= 0) {
1811                 n->type = KDBUS_ITEM_POLICY_ACCESS;
1812                 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1813                 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1814                 n->policy_access.access = bus_kernel_translate_access(world_policy);
1815         }
1816
1817         hello->size = size;
1818         hello->flags =
1819                 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1820                 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1821         hello->pool_size = KDBUS_POOL_SIZE;
1822         hello->attach_flags_send = _KDBUS_ATTACH_ANY;
1823         hello->attach_flags_recv = _KDBUS_ATTACH_ANY;
1824
1825         if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1826                 return -errno;
1827
1828         /* not interested in any output values */
1829         cmd_free.offset = hello->offset;
1830         (void) ioctl(fd, KDBUS_CMD_FREE, &cmd_free);
1831
1832         /* The higher 32bit of the bus_flags fields are considered
1833          * 'incompatible flags'. Refuse them all for now. */
1834         if (hello->bus_flags > 0xFFFFFFFFULL)
1835                 return -ENOTSUP;
1836
1837         return fd;
1838 }
1839
1840 int bus_kernel_try_close(sd_bus *bus) {
1841         assert(bus);
1842         assert(bus->is_kernel);
1843
1844         if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1845                 return -errno;
1846
1847         return 0;
1848 }
1849
1850 int bus_kernel_drop_one(int fd) {
1851         struct kdbus_cmd_recv recv = {
1852                 .size = sizeof(recv),
1853                 .flags = KDBUS_RECV_DROP,
1854         };
1855
1856         assert(fd >= 0);
1857
1858         if (ioctl(fd, KDBUS_CMD_RECV, &recv) < 0)
1859                 return -errno;
1860
1861         return 0;
1862 }
1863
1864 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1865         struct kdbus_cmd_update *update;
1866         struct kdbus_item *n;
1867
1868         assert(bus);
1869         assert(bus->is_kernel);
1870
1871         update = alloca0_align(offsetof(struct kdbus_cmd_update, items) +
1872                                ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1873                                8);
1874
1875         n = update->items;
1876         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1877         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1878         n->data64[0] = bus->attach_flags;
1879
1880         update->size =
1881                 offsetof(struct kdbus_cmd_update, items) +
1882                 ALIGN8(n->size);
1883
1884         if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0)
1885                 return -errno;
1886
1887         return 0;
1888 }
1889
1890 int bus_kernel_fix_attach_mask(void) {
1891         _cleanup_free_ char *mask = NULL;
1892         uint64_t m = (uint64_t) -1;
1893         char buf[2+16+2];
1894         int r;
1895
1896         /* By default we don't want any kdbus metadata fields to be
1897          * suppressed, hence we reset the kernel mask for it to
1898          * (uint64_t) -1. This is overridable via a kernel command
1899          * line option, however. */
1900
1901         r = get_proc_cmdline_key("systemd.kdbus_attach_flags_mask=", &mask);
1902         if (r < 0)
1903                 return log_warning_errno(r, "Failed to read kernel command line: %m");
1904
1905         if (mask) {
1906                 const char *p = mask;
1907
1908                 if (startswith(p, "0x"))
1909                         p += 2;
1910
1911                 if (sscanf(p, "%" PRIx64, &m) != 1)
1912                         log_warning("Couldn't parse systemd.kdbus_attach_flags_mask= kernel command line parameter.");
1913         }
1914
1915         sprintf(buf, "0x%" PRIx64 "\n", m);
1916         r = write_string_file("/sys/module/kdbus/parameters/attach_flags_mask", buf);
1917         if (r < 0)
1918                 return log_full_errno(
1919                                 IN_SET(r, -ENOENT, -EROFS) ? LOG_DEBUG : LOG_WARNING, r,
1920                                 "Failed to write kdbus attach mask: %m");
1921
1922         return 0;
1923 }
1924
1925 int bus_kernel_get_bus_name(sd_bus *bus, char **name) {
1926         struct kdbus_cmd_info cmd = {
1927                 .size = sizeof(struct kdbus_cmd_info),
1928         };
1929         struct kdbus_info *info;
1930         struct kdbus_item *item;
1931         char *n = NULL;
1932         int r;
1933
1934         assert(bus);
1935         assert(name);
1936         assert(bus->is_kernel);
1937
1938         r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
1939         if (r < 0)
1940                 return -errno;
1941
1942         info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset);
1943
1944         KDBUS_ITEM_FOREACH(item, info, items)
1945                 if (item->type == KDBUS_ITEM_MAKE_NAME) {
1946                         r = free_and_strdup(&n, item->str);
1947                         break;
1948                 }
1949
1950         bus_kernel_cmd_free(bus, cmd.offset);
1951
1952         if (r < 0)
1953                 return r;
1954         if (!n)
1955                 return -EIO;
1956
1957         *name = n;
1958         return 0;
1959 }