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