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