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 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1580         char *p;
1581         int fd;
1582         size_t len;
1583
1584         assert(bus);
1585
1586         len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1587
1588         if (path) {
1589                 p = new(char, len);
1590                 if (!p)
1591                         return -ENOMEM;
1592         } else
1593                 p = newa(char, len);
1594
1595         sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1596
1597         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1598         if (fd < 0) {
1599                 if (path)
1600                         free(p);
1601
1602                 return -errno;
1603         }
1604
1605         if (path)
1606                 *path = p;
1607
1608         return fd;
1609 }
1610
1611 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1612         _cleanup_free_ char *path = NULL;
1613         struct kdbus_cmd_make *make;
1614         struct kdbus_item *n;
1615         const char *name;
1616         int fd;
1617
1618         fd = bus_kernel_open_bus_fd(bus_name, &path);
1619         if (fd < 0)
1620                 return fd;
1621
1622         make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) +
1623                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1624                              8);
1625         make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1626         make->flags = KDBUS_MAKE_ACCESS_WORLD;
1627
1628         n = make->items;
1629         sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1630         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1631         n->type = KDBUS_ITEM_MAKE_NAME;
1632         make->size += ALIGN8(n->size);
1633         name = n->str;
1634
1635         if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1636                 safe_close(fd);
1637                 return -errno;
1638         }
1639
1640         if (ep_path) {
1641                 char *p;
1642
1643                 p = strjoin(dirname(path), "/", name, NULL);
1644                 if (!p) {
1645                         safe_close(fd);
1646                         return -ENOMEM;
1647                 }
1648
1649                 *ep_path = p;
1650         }
1651
1652         return fd;
1653 }
1654
1655 int bus_kernel_try_close(sd_bus *bus) {
1656         assert(bus);
1657         assert(bus->is_kernel);
1658
1659         if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1660                 return -errno;
1661
1662         return 0;
1663 }
1664
1665 int bus_kernel_drop_one(int fd) {
1666         struct kdbus_cmd_recv recv = {
1667                 .size = sizeof(recv),
1668                 .flags = KDBUS_RECV_DROP,
1669         };
1670
1671         assert(fd >= 0);
1672
1673         if (ioctl(fd, KDBUS_CMD_RECV, &recv) < 0)
1674                 return -errno;
1675
1676         return 0;
1677 }
1678
1679 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1680         struct kdbus_cmd_update *update;
1681         struct kdbus_item *n;
1682
1683         assert(bus);
1684         assert(bus->is_kernel);
1685
1686         update = alloca0_align(offsetof(struct kdbus_cmd_update, items) +
1687                                ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1688                                8);
1689
1690         n = update->items;
1691         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1692         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1693         n->data64[0] = bus->attach_flags;
1694
1695         update->size =
1696                 offsetof(struct kdbus_cmd_update, items) +
1697                 ALIGN8(n->size);
1698
1699         if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0)
1700                 return -errno;
1701
1702         return 0;
1703 }
1704
1705 int bus_kernel_fix_attach_mask(void) {
1706         _cleanup_free_ char *mask = NULL;
1707         uint64_t m = (uint64_t) -1;
1708         char buf[2+16+2];
1709         int r;
1710
1711         /* By default we don't want any kdbus metadata fields to be
1712          * suppressed, hence we reset the kernel mask for it to
1713          * (uint64_t) -1. This is overridable via a kernel command
1714          * line option, however. */
1715
1716         r = get_proc_cmdline_key("systemd.kdbus_attach_flags_mask=", &mask);
1717         if (r < 0)
1718                 return log_warning_errno(r, "Failed to read kernel command line: %m");
1719
1720         if (mask) {
1721                 const char *p = mask;
1722
1723                 if (startswith(p, "0x"))
1724                         p += 2;
1725
1726                 if (sscanf(p, "%" PRIx64, &m) != 1)
1727                         log_warning("Couldn't parse systemd.kdbus_attach_flags_mask= kernel command line parameter.");
1728         }
1729
1730         sprintf(buf, "0x%" PRIx64 "\n", m);
1731         r = write_string_file("/sys/module/kdbus/parameters/attach_flags_mask", buf);
1732         if (r < 0)
1733                 return log_full_errno(
1734                                 IN_SET(r, -ENOENT, -EROFS) ? LOG_DEBUG : LOG_WARNING, r,
1735                                 "Failed to write kdbus attach mask: %m");
1736
1737         return 0;
1738 }
1739
1740 int bus_kernel_get_bus_name(sd_bus *bus, char **name) {
1741         struct kdbus_cmd_info cmd = {
1742                 .size = sizeof(struct kdbus_cmd_info),
1743         };
1744         struct kdbus_info *info;
1745         struct kdbus_item *item;
1746         char *n = NULL;
1747         int r;
1748
1749         assert(bus);
1750         assert(name);
1751         assert(bus->is_kernel);
1752
1753         r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
1754         if (r < 0)
1755                 return -errno;
1756
1757         info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset);
1758
1759         KDBUS_ITEM_FOREACH(item, info, items)
1760                 if (item->type == KDBUS_ITEM_MAKE_NAME) {
1761                         r = free_and_strdup(&n, item->str);
1762                         break;
1763                 }
1764
1765         bus_kernel_cmd_free(bus, cmd.offset);
1766
1767         if (r < 0)
1768                 return r;
1769         if (!n)
1770                 return -EIO;
1771
1772         *name = n;
1773         return 0;
1774 }