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