src/libsystemd/sd-bus/bus-kernel.c

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