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_item *items, *item;
 844         struct kdbus_cmd_hello *hello;
 845         _cleanup_free_ char *g = NULL;
 846         const char *name;
 847         size_t l = 0, m = 0, sz;
 848         int r;
 849
 850         assert(b);
 851
 852         if (b->is_server)
 853                 return -EINVAL;
 854
 855         b->use_memfd = 1;
 856
 857         if (b->description) {
 858                 g = bus_label_escape(b->description);
 859                 if (!g)
 860                         return -ENOMEM;
 861
 862                 name = g;
 863         } else {
 864                 char pr[17] = {};
 865
 866                 /* If no name is explicitly set, we'll include a hint
 867                  * indicating the library implementation, a hint which
 868                  * kind of bus this is and the thread name */
 869
 870                 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
 871
 872                 if (isempty(pr)) {
 873                         name = b->is_system ? "sd-system" :
 874                                 b->is_user ? "sd-user" : "sd";
 875                 } else {
 876                         _cleanup_free_ char *e = NULL;
 877
 878                         e = bus_label_escape(pr);
 879                         if (!e)
 880                                 return -ENOMEM;
 881
 882                         g = strappend(b->is_system ? "sd-system-" :
 883                                       b->is_user ? "sd-user-" : "sd-",
 884                                       e);
 885                         if (!g)
 886                                 return -ENOMEM;
 887
 888                         name = g;
 889                 }
 890
 891                 b->description = bus_label_unescape(name);
 892                 if (!b->description)
 893                         return -ENOMEM;
 894         }
 895
 896         m = strlen(name);
 897
 898         sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
 899                 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
 900
 901         if (b->fake_creds_valid)
 902                 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
 903
 904         if (b->fake_pids_valid)
 905                 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
 906
 907         if (b->fake_label) {
 908                 l = strlen(b->fake_label);
 909                 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
 910         }
 911
 912         hello = alloca0_align(sz, 8);
 913         hello->size = sz;
 914         hello->flags = b->hello_flags;
 915         hello->attach_flags_send = _KDBUS_ATTACH_ANY;
 916         hello->attach_flags_recv = b->attach_flags;
 917         hello->pool_size = KDBUS_POOL_SIZE;
 918
 919         item = hello->items;
 920
 921         item->size = offsetof(struct kdbus_item, str) + m + 1;
 922         item->type = KDBUS_ITEM_CONN_DESCRIPTION;
 923         memcpy(item->str, name, m + 1);
 924         item = KDBUS_ITEM_NEXT(item);
 925
 926         if (b->fake_creds_valid) {
 927                 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
 928                 item->type = KDBUS_ITEM_CREDS;
 929                 item->creds = b->fake_creds;
 930
 931                 item = KDBUS_ITEM_NEXT(item);
 932         }
 933
 934         if (b->fake_pids_valid) {
 935                 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
 936                 item->type = KDBUS_ITEM_PIDS;
 937                 item->pids = b->fake_pids;
 938
 939                 item = KDBUS_ITEM_NEXT(item);
 940         }
 941
 942         if (b->fake_label) {
 943                 item->size = offsetof(struct kdbus_item, str) + l + 1;
 944                 item->type = KDBUS_ITEM_SECLABEL;
 945                 memcpy(item->str, b->fake_label, l+1);
 946         }
 947
 948         r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
 949         if (r < 0)
 950                 return -errno;
 951
 952         if (!b->kdbus_buffer) {
 953                 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
 954                 if (b->kdbus_buffer == MAP_FAILED) {
 955                         b->kdbus_buffer = NULL;
 956                         r = -errno;
 957                         goto fail;
 958                 }
 959         }
 960
 961         /* The higher 32bit of the bus_flags fields are considered
 962          * 'incompatible flags'. Refuse them all for now. */
 963         if (hello->bus_flags > 0xFFFFFFFFULL) {
 964                 r = -ENOTSUP;
 965                 goto fail;
 966         }
 967
 968         /* extract bloom parameters from items */
 969         items = (void*)((uint8_t*)b->kdbus_buffer + hello->offset);
 970         KDBUS_FOREACH(item, items, hello->items_size) {
 971                 switch (item->type) {
 972                 case KDBUS_ITEM_BLOOM_PARAMETER:
 973                         bloom = &item->bloom_parameter;
 974                         break;
 975                 }
 976         }
 977
 978         if (!bloom || !bloom_validate_parameters((size_t) bloom->size, (unsigned) bloom->n_hash)) {
 979                 r = -ENOTSUP;
 980                 goto fail;
 981         }
 982
 983         b->bloom_size = (size_t) bloom->size;
 984         b->bloom_n_hash = (unsigned) bloom->n_hash;
 985
 986         if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0) {
 987                 r = -ENOMEM;
 988                 goto fail;
 989         }
 990
 991         b->unique_id = hello->id;
 992
 993         b->is_kernel = true;
 994         b->bus_client = true;
 995         b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
 996         b->message_version = 2;
 997         b->message_endian = BUS_NATIVE_ENDIAN;
 998
 999         /* the kernel told us the UUID of the underlying bus */
1000         memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
1001
1002         /* free returned items */
1003         (void) bus_kernel_cmd_free(b, hello->offset);
1004         return bus_start_running(b);
1005
1006 fail:
1007         (void) bus_kernel_cmd_free(b, hello->offset);
1008         return r;
1009 }
1010
1011 int bus_kernel_connect(sd_bus *b) {
1012         assert(b);
1013         assert(b->input_fd < 0);
1014         assert(b->output_fd < 0);
1015         assert(b->kernel);
1016
1017         if (b->is_server)
1018                 return -EINVAL;
1019
1020         b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
1021         if (b->input_fd < 0)
1022                 return -errno;
1023
1024         b->output_fd = b->input_fd;
1025
1026         return bus_kernel_take_fd(b);
1027 }
1028
1029 int bus_kernel_cmd_free(sd_bus *bus, uint64_t offset) {
1030         struct kdbus_cmd_free cmd = {
1031                 .size = sizeof(cmd),
1032                 .offset = offset,
1033         };
1034         int r;
1035
1036         assert(bus);
1037         assert(bus->is_kernel);
1038
1039         r = ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
1040         if (r < 0)
1041                 return -errno;
1042
1043         return 0;
1044 }
1045
1046 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
1047         struct kdbus_item *d;
1048
1049         assert(bus);
1050         assert(k);
1051
1052         KDBUS_ITEM_FOREACH(d, k, items) {
1053                 if (d->type == KDBUS_ITEM_FDS)
1054                         close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
1055                 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
1056                         safe_close(d->memfd.fd);
1057         }
1058
1059         bus_kernel_cmd_free(bus, (uint8_t*) k - (uint8_t*) bus->kdbus_buffer);
1060 }
1061
1062 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
1063         struct kdbus_cmd_send cmd = { };
1064         int r;
1065
1066         assert(bus);
1067         assert(m);
1068         assert(bus->state == BUS_RUNNING);
1069
1070         /* If we can't deliver, we want room for the error message */
1071         r = bus_rqueue_make_room(bus);
1072         if (r < 0)
1073                 return r;
1074
1075         r = bus_message_setup_kmsg(bus, m);
1076         if (r < 0)
1077                 return r;
1078
1079         cmd.size = sizeof(cmd);
1080         cmd.msg_address = (uintptr_t)m->kdbus;
1081
1082         /* If this is a synchronous method call, then let's tell the
1083          * kernel, so that it can pass CPU time/scheduling to the
1084          * destination for the time, if it wants to. If we
1085          * synchronously wait for the result anyway, we won't need CPU
1086          * anyway. */
1087         if (hint_sync_call) {
1088                 m->kdbus->flags |= KDBUS_MSG_EXPECT_REPLY;
1089                 cmd.flags |= KDBUS_SEND_SYNC_REPLY;
1090         }
1091
1092         r = ioctl(bus->output_fd, KDBUS_CMD_SEND, &cmd);
1093         if (r < 0) {
1094                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1095                 sd_bus_message *reply;
1096
1097                 if (errno == EAGAIN || errno == EINTR)
1098                         return 0;
1099                 else if (errno == ENXIO || errno == ESRCH) {
1100
1101                         /* ENXIO: unique name not known
1102                          * ESRCH: well-known name not known */
1103
1104                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1105                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
1106                         else {
1107                                 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
1108                                 return 0;
1109                         }
1110
1111                 } else if (errno == EADDRNOTAVAIL) {
1112
1113                         /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
1114
1115                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1116                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
1117                         else {
1118                                 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
1119                                 return 0;
1120                         }
1121                 } else
1122                         return -errno;
1123
1124                 r = bus_message_new_synthetic_error(
1125                                 bus,
1126                                 BUS_MESSAGE_COOKIE(m),
1127                                 &error,
1128                                 &reply);
1129
1130                 if (r < 0)
1131                         return r;
1132
1133                 r = bus_seal_synthetic_message(bus, reply);
1134                 if (r < 0)
1135                         return r;
1136
1137                 bus->rqueue[bus->rqueue_size++] = reply;
1138
1139         } else if (hint_sync_call) {
1140                 struct kdbus_msg *k;
1141
1142                 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + cmd.reply.offset);
1143                 assert(k);
1144
1145                 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1146
1147                         r = bus_kernel_make_message(bus, k);
1148                         if (r < 0) {
1149                                 close_kdbus_msg(bus, k);
1150
1151                                 /* Anybody can send us invalid messages, let's just drop them. */
1152                                 if (r == -EBADMSG || r == -EPROTOTYPE)
1153                                         log_debug_errno(r, "Ignoring invalid synchronous reply: %m");
1154                                 else
1155                                         return r;
1156                         }
1157                 } else {
1158                         log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1159                         close_kdbus_msg(bus, k);
1160                 }
1161         }
1162
1163         return 1;
1164 }
1165
1166 static int push_name_owner_changed(
1167                 sd_bus *bus,
1168                 const char *name,
1169                 const char *old_owner,
1170                 const char *new_owner,
1171                 const struct kdbus_timestamp *ts) {
1172
1173         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1174         int r;
1175
1176         assert(bus);
1177
1178         r = sd_bus_message_new_signal(
1179                         bus,
1180                         &m,
1181                         "/org/freedesktop/DBus",
1182                         "org.freedesktop.DBus",
1183                         "NameOwnerChanged");
1184         if (r < 0)
1185                 return r;
1186
1187         r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1188         if (r < 0)
1189                 return r;
1190
1191         bus_message_set_sender_driver(bus, m);
1192         message_set_timestamp(bus, m, ts);
1193
1194         r = bus_seal_synthetic_message(bus, m);
1195         if (r < 0)
1196                 return r;
1197
1198         bus->rqueue[bus->rqueue_size++] = m;
1199         m = NULL;
1200
1201         return 1;
1202 }
1203
1204 static int translate_name_change(
1205                 sd_bus *bus,
1206                 const struct kdbus_msg *k,
1207                 const struct kdbus_item *d,
1208                 const struct kdbus_timestamp *ts) {
1209
1210         char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1211
1212         assert(bus);
1213         assert(k);
1214         assert(d);
1215
1216         if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1217                 old_owner[0] = 0;
1218         else
1219                 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1220
1221         if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1222
1223                 if (isempty(old_owner))
1224                         return 0;
1225
1226                 new_owner[0] = 0;
1227         } else
1228                 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1229
1230         return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner, ts);
1231 }
1232
1233 static int translate_id_change(
1234                 sd_bus *bus,
1235                 const struct kdbus_msg *k,
1236                 const struct kdbus_item *d,
1237                 const struct kdbus_timestamp *ts) {
1238
1239         char owner[UNIQUE_NAME_MAX];
1240
1241         assert(bus);
1242         assert(k);
1243         assert(d);
1244
1245         sprintf(owner, ":1.%llu", d->id_change.id);
1246
1247         return push_name_owner_changed(
1248                         bus, owner,
1249                         d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1250                         d->type == KDBUS_ITEM_ID_ADD ? owner : NULL,
1251                         ts);
1252 }
1253
1254 static int translate_reply(
1255                 sd_bus *bus,
1256                 const struct kdbus_msg *k,
1257                 const struct kdbus_item *d,
1258                 const struct kdbus_timestamp *ts) {
1259
1260         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1261         int r;
1262
1263         assert(bus);
1264         assert(k);
1265         assert(d);
1266
1267         r = bus_message_new_synthetic_error(
1268                         bus,
1269                         k->cookie_reply,
1270                         d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1271                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1272                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1273                         &m);
1274         if (r < 0)
1275                 return r;
1276
1277         message_set_timestamp(bus, m, ts);
1278
1279         r = bus_seal_synthetic_message(bus, m);
1280         if (r < 0)
1281                 return r;
1282
1283         bus->rqueue[bus->rqueue_size++] = m;
1284         m = NULL;
1285
1286         return 1;
1287 }
1288
1289 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1290         static int (* const translate[])(sd_bus *bus, const struct kdbus_msg *k, const struct kdbus_item *d, const struct kdbus_timestamp *ts) = {
1291                 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1292                 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1293                 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1294
1295                 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1296                 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1297
1298                 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1299                 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1300         };
1301
1302         struct kdbus_item *d, *found = NULL;
1303         struct kdbus_timestamp *ts = NULL;
1304
1305         assert(bus);
1306         assert(k);
1307         assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1308
1309         KDBUS_ITEM_FOREACH(d, k, items) {
1310                 if (d->type == KDBUS_ITEM_TIMESTAMP)
1311                         ts = &d->timestamp;
1312
1313                 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1314                         if (found)
1315                                 return -EBADMSG;
1316                         found = d;
1317                 } else
1318                         log_debug("Got unknown field from kernel %llu", d->type);
1319         }
1320
1321         if (!found) {
1322                 log_debug("Didn't find a kernel message to translate.");
1323                 return 0;
1324         }
1325
1326         return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found, ts);
1327 }
1328
1329 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1330         struct kdbus_cmd_recv recv = { .size = sizeof(recv) };
1331         struct kdbus_msg *k;
1332         int r;
1333
1334         assert(bus);
1335
1336         r = bus_rqueue_make_room(bus);
1337         if (r < 0)
1338                 return r;
1339
1340         if (hint_priority) {
1341                 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1342                 recv.priority = priority;
1343         }
1344
1345         r = ioctl(bus->input_fd, KDBUS_CMD_RECV, &recv);
1346         if (recv.return_flags & KDBUS_RECV_RETURN_DROPPED_MSGS)
1347                 log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1348         if (r < 0) {
1349                 if (errno == EAGAIN)
1350                         return 0;
1351
1352                 return -errno;
1353         }
1354
1355         k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.msg.offset);
1356         if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1357                 r = bus_kernel_make_message(bus, k);
1358
1359                 /* Anybody can send us invalid messages, let's just drop them. */
1360                 if (r == -EBADMSG || r == -EPROTOTYPE) {
1361                         log_debug_errno(r, "Ignoring invalid message: %m");
1362                         r = 0;
1363                 }
1364
1365         } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1366                 r = bus_kernel_translate_message(bus, k);
1367         else {
1368                 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1369                 r = 0;
1370         }
1371
1372         if (r <= 0)
1373                 close_kdbus_msg(bus, k);
1374
1375         return r < 0 ? r : 1;
1376 }
1377
1378 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1379         struct memfd_cache *c;
1380         int fd;
1381
1382         assert(address);
1383         assert(mapped);
1384         assert(allocated);
1385
1386         if (!bus || !bus->is_kernel)
1387                 return -ENOTSUP;
1388
1389         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1390
1391         if (bus->n_memfd_cache <= 0) {
1392                 int r;
1393
1394                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1395
1396                 r = memfd_new(bus->description);
1397                 if (r < 0)
1398                         return r;
1399
1400                 *address = NULL;
1401                 *mapped = 0;
1402                 *allocated = 0;
1403                 return r;
1404         }
1405
1406         c = &bus->memfd_cache[--bus->n_memfd_cache];
1407
1408         assert(c->fd >= 0);
1409         assert(c->mapped == 0 || c->address);
1410
1411         *address = c->address;
1412         *mapped = c->mapped;
1413         *allocated = c->allocated;
1414         fd = c->fd;
1415
1416         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1417
1418         return fd;
1419 }
1420
1421 static void close_and_munmap(int fd, void *address, size_t size) {
1422         if (size > 0)
1423                 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1424
1425         safe_close(fd);
1426 }
1427
1428 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1429         struct memfd_cache *c;
1430         uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1431
1432         assert(fd >= 0);
1433         assert(mapped == 0 || address);
1434
1435         if (!bus || !bus->is_kernel) {
1436                 close_and_munmap(fd, address, mapped);
1437                 return;
1438         }
1439
1440         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1441
1442         if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1443                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1444
1445                 close_and_munmap(fd, address, mapped);
1446                 return;
1447         }
1448
1449         c = &bus->memfd_cache[bus->n_memfd_cache++];
1450         c->fd = fd;
1451         c->address = address;
1452
1453         /* If overly long, let's return a bit to the OS */
1454         if (mapped > max_mapped) {
1455                 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1456                 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1457                 c->mapped = c->allocated = max_mapped;
1458         } else {
1459                 c->mapped = mapped;
1460                 c->allocated = allocated;
1461         }
1462
1463         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1464 }
1465
1466 void bus_kernel_flush_memfd(sd_bus *b) {
1467         unsigned i;
1468
1469         assert(b);
1470
1471         for (i = 0; i < b->n_memfd_cache; i++)
1472                 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1473 }
1474
1475 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1476         uint64_t f = 0;
1477
1478         if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1479                 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1480
1481         if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1482                 f |= KDBUS_NAME_REPLACE_EXISTING;
1483
1484         if (flags & SD_BUS_NAME_QUEUE)
1485                 f |= KDBUS_NAME_QUEUE;
1486
1487         return f;
1488 }
1489
1490 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1491         uint64_t m = 0;
1492
1493         if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1494                     SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1495                 m |= KDBUS_ATTACH_CREDS;
1496
1497         if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_TID))
1498                 m |= KDBUS_ATTACH_PIDS;
1499
1500         if (mask & SD_BUS_CREDS_COMM)
1501                 m |= KDBUS_ATTACH_PID_COMM;
1502
1503         if (mask & SD_BUS_CREDS_TID_COMM)
1504                 m |= KDBUS_ATTACH_TID_COMM;
1505
1506         if (mask & SD_BUS_CREDS_EXE)
1507                 m |= KDBUS_ATTACH_EXE;
1508
1509         if (mask & SD_BUS_CREDS_CMDLINE)
1510                 m |= KDBUS_ATTACH_CMDLINE;
1511
1512         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))
1513                 m |= KDBUS_ATTACH_CGROUP;
1514
1515         if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1516                 m |= KDBUS_ATTACH_CAPS;
1517
1518         if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1519                 m |= KDBUS_ATTACH_SECLABEL;
1520
1521         if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1522                 m |= KDBUS_ATTACH_AUDIT;
1523
1524         if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1525                 m |= KDBUS_ATTACH_NAMES;
1526
1527         if (mask & SD_BUS_CREDS_DESCRIPTION)
1528                 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1529
1530         if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1531                 m |= KDBUS_ATTACH_AUXGROUPS;
1532
1533         return m;
1534 }
1535
1536 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1537         struct kdbus_cmd *make;
1538         struct kdbus_item *n;
1539         size_t l;
1540         int fd;
1541
1542         assert(name);
1543         assert(s);
1544
1545         fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1546         if (fd < 0)
1547                 return -errno;
1548
1549         l = strlen(name);
1550         make = alloca0_align(offsetof(struct kdbus_cmd, items) +
1551                              ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1552                              ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1553                              ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1554                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1555                              8);
1556
1557         make->size = offsetof(struct kdbus_cmd, items);
1558
1559         /* Set the bloom parameters */
1560         n = make->items;
1561         n->size = offsetof(struct kdbus_item, bloom_parameter) +
1562                   sizeof(struct kdbus_bloom_parameter);
1563         n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1564         n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1565         n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1566
1567         assert_cc(DEFAULT_BLOOM_SIZE > 0);
1568         assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1569
1570         make->size += ALIGN8(n->size);
1571
1572         /* The busses we create make no restrictions on what metadata
1573          * peers can read from incoming messages. */
1574         n = KDBUS_ITEM_NEXT(n);
1575         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1576         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1577         n->data64[0] = _KDBUS_ATTACH_ANY;
1578         make->size += ALIGN8(n->size);
1579
1580         /* Provide all metadata via bus-owner queries */
1581         n = KDBUS_ITEM_NEXT(n);
1582         n->type = KDBUS_ITEM_ATTACH_FLAGS_SEND;
1583         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1584         n->data64[0] = _KDBUS_ATTACH_ANY;
1585         make->size += ALIGN8(n->size);
1586
1587         /* Set the a good name */
1588         n = KDBUS_ITEM_NEXT(n);
1589         sprintf(n->str, UID_FMT "-%s", getuid(), name);
1590         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1591         n->type = KDBUS_ITEM_MAKE_NAME;
1592         make->size += ALIGN8(n->size);
1593
1594         make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1595
1596         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1597                 safe_close(fd);
1598                 return -errno;
1599         }
1600
1601         if (s) {
1602                 char *p;
1603
1604                 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1605                 if (!p) {
1606                         safe_close(fd);
1607                         return -ENOMEM;
1608                 }
1609
1610                 *s = p;
1611         }
1612
1613         return fd;
1614 }
1615
1616 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1617         char *p;
1618         int fd;
1619         size_t len;
1620
1621         assert(bus);
1622
1623         len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1624
1625         if (path) {
1626                 p = new(char, len);
1627                 if (!p)
1628                         return -ENOMEM;
1629         } else
1630                 p = newa(char, len);
1631
1632         sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1633
1634         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1635         if (fd < 0) {
1636                 if (path)
1637                         free(p);
1638
1639                 return -errno;
1640         }
1641
1642         if (path)
1643                 *path = p;
1644
1645         return fd;
1646 }
1647
1648 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1649         _cleanup_free_ char *path = NULL;
1650         struct kdbus_cmd *make;
1651         struct kdbus_item *n;
1652         const char *name;
1653         int fd;
1654
1655         fd = bus_kernel_open_bus_fd(bus_name, &path);
1656         if (fd < 0)
1657                 return fd;
1658
1659         make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd, items)) +
1660                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1661                              8);
1662         make->size = ALIGN8(offsetof(struct kdbus_cmd, items));
1663         make->flags = KDBUS_MAKE_ACCESS_WORLD;
1664
1665         n = make->items;
1666         sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1667         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1668         n->type = KDBUS_ITEM_MAKE_NAME;
1669         make->size += ALIGN8(n->size);
1670         name = n->str;
1671
1672         if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1673                 safe_close(fd);
1674                 return -errno;
1675         }
1676
1677         if (ep_path) {
1678                 char *p;
1679
1680                 p = strjoin(dirname(path), "/", name, NULL);
1681                 if (!p) {
1682                         safe_close(fd);
1683                         return -ENOMEM;
1684                 }
1685
1686                 *ep_path = p;
1687         }
1688
1689         return fd;
1690 }
1691
1692 int bus_kernel_try_close(sd_bus *bus) {
1693         struct kdbus_cmd byebye = { .size = sizeof(byebye) };
1694
1695         assert(bus);
1696         assert(bus->is_kernel);
1697
1698         if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE, &byebye) < 0)
1699                 return -errno;
1700
1701         return 0;
1702 }
1703
1704 int bus_kernel_drop_one(int fd) {
1705         struct kdbus_cmd_recv recv = {
1706                 .size = sizeof(recv),
1707                 .flags = KDBUS_RECV_DROP,
1708         };
1709
1710         assert(fd >= 0);
1711
1712         if (ioctl(fd, KDBUS_CMD_RECV, &recv) < 0)
1713                 return -errno;
1714
1715         return 0;
1716 }
1717
1718 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1719         struct kdbus_cmd *update;
1720         struct kdbus_item *n;
1721
1722         assert(bus);
1723         assert(bus->is_kernel);
1724
1725         update = alloca0_align(offsetof(struct kdbus_cmd, items) +
1726                                ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1727                                8);
1728
1729         n = update->items;
1730         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1731         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1732         n->data64[0] = bus->attach_flags;
1733
1734         update->size =
1735                 offsetof(struct kdbus_cmd, items) +
1736                 ALIGN8(n->size);
1737
1738         if (ioctl(bus->input_fd, KDBUS_CMD_UPDATE, update) < 0)
1739                 return -errno;
1740
1741         return 0;
1742 }
1743
1744 int bus_kernel_fix_attach_mask(void) {
1745         _cleanup_free_ char *mask = NULL;
1746         uint64_t m = (uint64_t) -1;
1747         char buf[2+16+2];
1748         int r;
1749
1750         /* By default we don't want any kdbus metadata fields to be
1751          * suppressed, hence we reset the kernel mask for it to
1752          * (uint64_t) -1. If the module argument was overwritten by
1753          * the kernel cmdline, we leave it as is. */
1754
1755         r = get_proc_cmdline_key("kdbus.attach_flags_mask=", &mask);
1756         if (r < 0)
1757                 return log_warning_errno(r, "Failed to read kernel command line: %m");
1758
1759         if (r == 0) {
1760                 sprintf(buf, "0x%" PRIx64 "\n", m);
1761                 r = write_string_file("/sys/module/kdbus/parameters/attach_flags_mask", buf);
1762                 if (r < 0)
1763                         return log_full_errno(IN_SET(r, -ENOENT, -EROFS) ? LOG_DEBUG : LOG_WARNING, r,
1764                                               "Failed to write kdbus attach mask: %m");
1765         }
1766
1767         return 0;
1768 }
1769
1770 int bus_kernel_get_bus_name(sd_bus *bus, char **name) {
1771         struct kdbus_cmd_info cmd = {
1772                 .size = sizeof(struct kdbus_cmd_info),
1773         };
1774         struct kdbus_info *info;
1775         struct kdbus_item *item;
1776         char *n = NULL;
1777         int r;
1778
1779         assert(bus);
1780         assert(name);
1781         assert(bus->is_kernel);
1782
1783         r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
1784         if (r < 0)
1785                 return -errno;
1786
1787         info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset);
1788
1789         KDBUS_ITEM_FOREACH(item, info, items)
1790                 if (item->type == KDBUS_ITEM_MAKE_NAME) {
1791                         r = free_and_strdup(&n, item->str);
1792                         break;
1793                 }
1794
1795         bus_kernel_cmd_free(bus, cmd.offset);
1796
1797         if (r < 0)
1798                 return r;
1799         if (!n)
1800                 return -EIO;
1801
1802         *name = n;
1803         return 0;
1804 }