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                         }
 602
 603                         break;
 604
 605                 case KDBUS_ITEM_CREDS:
 606
 607                         /* EUID/SUID/FSUID/EGID/SGID/FSGID might be
 608                          * missing too (see above). */
 609
 610                         if ((uid_t) d->creds.uid != UID_INVALID) {
 611                                 m->creds.uid = (uid_t) d->creds.uid;
 612                                 m->creds.mask |= SD_BUS_CREDS_UID & bus->creds_mask;
 613                         }
 614
 615                         if ((uid_t) d->creds.euid != UID_INVALID) {
 616                                 m->creds.euid = (uid_t) d->creds.euid;
 617                                 m->creds.mask |= SD_BUS_CREDS_EUID & bus->creds_mask;
 618                         }
 619
 620                         if ((uid_t) d->creds.suid != UID_INVALID) {
 621                                 m->creds.suid = (uid_t) d->creds.suid;
 622                                 m->creds.mask |= SD_BUS_CREDS_SUID & bus->creds_mask;
 623                         }
 624
 625                         if ((uid_t) d->creds.fsuid != UID_INVALID) {
 626                                 m->creds.fsuid = (uid_t) d->creds.fsuid;
 627                                 m->creds.mask |= SD_BUS_CREDS_FSUID & bus->creds_mask;
 628                         }
 629
 630                         if ((gid_t) d->creds.gid != GID_INVALID) {
 631                                 m->creds.gid = (gid_t) d->creds.gid;
 632                                 m->creds.mask |= SD_BUS_CREDS_GID & bus->creds_mask;
 633                         }
 634
 635                         if ((gid_t) d->creds.egid != GID_INVALID) {
 636                                 m->creds.egid = (gid_t) d->creds.egid;
 637                                 m->creds.mask |= SD_BUS_CREDS_EGID & bus->creds_mask;
 638                         }
 639
 640                         if ((gid_t) d->creds.sgid != GID_INVALID) {
 641                                 m->creds.sgid = (gid_t) d->creds.sgid;
 642                                 m->creds.mask |= SD_BUS_CREDS_SGID & bus->creds_mask;
 643                         }
 644
 645                         if ((gid_t) d->creds.fsgid != GID_INVALID) {
 646                                 m->creds.fsgid = (gid_t) d->creds.fsgid;
 647                                 m->creds.mask |= SD_BUS_CREDS_FSGID & bus->creds_mask;
 648                         }
 649
 650                         break;
 651
 652                 case KDBUS_ITEM_TIMESTAMP:
 653                         message_set_timestamp(bus, m, &d->timestamp);
 654                         break;
 655
 656                 case KDBUS_ITEM_PID_COMM:
 657                         m->creds.comm = d->str;
 658                         m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
 659                         break;
 660
 661                 case KDBUS_ITEM_TID_COMM:
 662                         m->creds.tid_comm = d->str;
 663                         m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
 664                         break;
 665
 666                 case KDBUS_ITEM_EXE:
 667                         m->creds.exe = d->str;
 668                         m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
 669                         break;
 670
 671                 case KDBUS_ITEM_CMDLINE:
 672                         m->creds.cmdline = d->str;
 673                         m->creds.cmdline_size = l;
 674                         m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
 675                         break;
 676
 677                 case KDBUS_ITEM_CGROUP:
 678                         m->creds.cgroup = d->str;
 679                         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;
 680
 681                         r = bus_get_root_path(bus);
 682                         if (r < 0)
 683                                 goto fail;
 684
 685                         m->creds.cgroup_root = bus->cgroup_root;
 686                         break;
 687
 688                 case KDBUS_ITEM_AUDIT:
 689                         if ((uint32_t) d->audit.sessionid != (uint32_t) -1) {
 690                                 m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
 691                                 m->creds.mask |= SD_BUS_CREDS_AUDIT_SESSION_ID & bus->creds_mask;
 692                         }
 693
 694                         if ((uid_t) d->audit.loginuid != UID_INVALID) {
 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                         }
 698                         break;
 699
 700                 case KDBUS_ITEM_CAPS:
 701                         if (d->caps.last_cap != cap_last_cap() ||
 702                             d->size - offsetof(struct kdbus_item, caps.caps) < DIV_ROUND_UP(d->caps.last_cap, 32U) * 4 * 4) {
 703                                 r = -EBADMSG;
 704                                 goto fail;
 705                         }
 706
 707                         m->creds.capability = d->caps.caps;
 708                         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;
 709                         break;
 710
 711                 case KDBUS_ITEM_DST_NAME:
 712                         if (!service_name_is_valid(d->str)) {
 713                                 r = -EBADMSG;
 714                                 goto fail;
 715                         }
 716
 717                         destination = d->str;
 718                         break;
 719
 720                 case KDBUS_ITEM_OWNED_NAME:
 721                         if (!service_name_is_valid(d->name.name)) {
 722                                 r = -EBADMSG;
 723                                 goto fail;
 724                         }
 725
 726                         if (bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) {
 727                                 char **wkn;
 728                                 size_t n;
 729
 730                                 /* We just extend the array here, but
 731                                  * do not allocate the strings inside
 732                                  * of it, instead we just point to our
 733                                  * buffer directly. */
 734                                 n = strv_length(m->creds.well_known_names);
 735                                 wkn = realloc(m->creds.well_known_names, (n + 2) * sizeof(char*));
 736                                 if (!wkn) {
 737                                         r = -ENOMEM;
 738                                         goto fail;
 739                                 }
 740
 741                                 wkn[n] = d->name.name;
 742                                 wkn[n+1] = NULL;
 743                                 m->creds.well_known_names = wkn;
 744
 745                                 m->creds.mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES;
 746                         }
 747                         break;
 748
 749                 case KDBUS_ITEM_CONN_DESCRIPTION:
 750                         m->creds.description = d->str;
 751                         m->creds.mask |= SD_BUS_CREDS_DESCRIPTION & bus->creds_mask;
 752                         break;
 753
 754                 case KDBUS_ITEM_AUXGROUPS:
 755
 756                         if (bus->creds_mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS) {
 757                                 size_t i, n;
 758                                 gid_t *g;
 759
 760                                 n = (d->size - offsetof(struct kdbus_item, data64)) / sizeof(uint64_t);
 761                                 g = new(gid_t, n);
 762                                 if (!g) {
 763                                         r = -ENOMEM;
 764                                         goto fail;
 765                                 }
 766
 767                                 for (i = 0; i < n; i++)
 768                                         g[i] = d->data64[i];
 769
 770                                 m->creds.supplementary_gids = g;
 771                                 m->creds.n_supplementary_gids = n;
 772                                 m->creds.mask |= SD_BUS_CREDS_SUPPLEMENTARY_GIDS;
 773                         }
 774
 775                         break;
 776
 777                 case KDBUS_ITEM_FDS:
 778                 case KDBUS_ITEM_SECLABEL:
 779                         break;
 780
 781                 default:
 782                         log_debug("Got unknown field from kernel %llu", d->type);
 783                 }
 784         }
 785
 786         /* If we requested the list of well-known names to be appended
 787          * and the sender had none no item for it will be
 788          * attached. However, this does *not* mean that the kernel
 789          * didn't want to provide this information to us. Hence, let's
 790          * explicitly mark this information as available if it was
 791          * requested. */
 792         m->creds.mask |= bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES;
 793
 794         r = bus_message_parse_fields(m);
 795         if (r < 0)
 796                 goto fail;
 797
 798         /* Refuse messages if kdbus and dbus1 cookie doesn't match up */
 799         if ((uint64_t) m->header->dbus2.cookie != k->cookie) {
 800                 r = -EBADMSG;
 801                 goto fail;
 802         }
 803
 804         /* Refuse messages where the reply flag doesn't match up */
 805         if (!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) != !!(k->flags & KDBUS_MSG_EXPECT_REPLY)) {
 806                 r = -EBADMSG;
 807                 goto fail;
 808         }
 809
 810         /* Refuse reply messages where the reply cookie doesn't match up */
 811         if ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) && m->reply_cookie != k->cookie_reply) {
 812                 r = -EBADMSG;
 813                 goto fail;
 814         }
 815
 816         /* Refuse messages where the autostart flag doesn't match up */
 817         if (!(m->header->flags & BUS_MESSAGE_NO_AUTO_START) != !(k->flags & KDBUS_MSG_NO_AUTO_START)) {
 818                 r = -EBADMSG;
 819                 goto fail;
 820         }
 821
 822         /* Override information from the user header with data from the kernel */
 823         if (k->src_id == KDBUS_SRC_ID_KERNEL)
 824                 bus_message_set_sender_driver(bus, m);
 825         else {
 826                 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
 827                 m->sender = m->creds.unique_name = m->sender_buffer;
 828         }
 829
 830         if (destination)
 831                 m->destination = destination;
 832         else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
 833                 m->destination = NULL;
 834         else if (k->dst_id == KDBUS_DST_ID_NAME)
 835                 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
 836         else {
 837                 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
 838                 m->destination = m->destination_buffer;
 839         }
 840
 841         /* We take possession of the kmsg struct now */
 842         m->kdbus = k;
 843         m->release_kdbus = true;
 844         m->free_fds = true;
 845         fds = NULL;
 846
 847         bus->rqueue[bus->rqueue_size++] = m;
 848
 849         return 1;
 850
 851 fail:
 852         unset_memfds(m);
 853         sd_bus_message_unref(m);
 854
 855         return r;
 856 }
 857
 858 int bus_kernel_take_fd(sd_bus *b) {
 859         struct kdbus_bloom_parameter *bloom = NULL;
 860         struct kdbus_item *items, *item;
 861         struct kdbus_cmd_hello *hello;
 862         _cleanup_free_ char *g = NULL;
 863         const char *name;
 864         size_t l = 0, m = 0, sz;
 865         int r;
 866
 867         assert(b);
 868
 869         if (b->is_server)
 870                 return -EINVAL;
 871
 872         b->use_memfd = 1;
 873
 874         if (b->description) {
 875                 g = bus_label_escape(b->description);
 876                 if (!g)
 877                         return -ENOMEM;
 878
 879                 name = g;
 880         } else {
 881                 char pr[17] = {};
 882
 883                 /* If no name is explicitly set, we'll include a hint
 884                  * indicating the library implementation, a hint which
 885                  * kind of bus this is and the thread name */
 886
 887                 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
 888
 889                 if (isempty(pr)) {
 890                         name = b->is_system ? "sd-system" :
 891                                 b->is_user ? "sd-user" : "sd";
 892                 } else {
 893                         _cleanup_free_ char *e = NULL;
 894
 895                         e = bus_label_escape(pr);
 896                         if (!e)
 897                                 return -ENOMEM;
 898
 899                         g = strappend(b->is_system ? "sd-system-" :
 900                                       b->is_user ? "sd-user-" : "sd-",
 901                                       e);
 902                         if (!g)
 903                                 return -ENOMEM;
 904
 905                         name = g;
 906                 }
 907
 908                 b->description = bus_label_unescape(name);
 909                 if (!b->description)
 910                         return -ENOMEM;
 911         }
 912
 913         m = strlen(name);
 914
 915         sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
 916                 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
 917
 918         if (b->fake_creds_valid)
 919                 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
 920
 921         if (b->fake_pids_valid)
 922                 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
 923
 924         if (b->fake_label) {
 925                 l = strlen(b->fake_label);
 926                 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
 927         }
 928
 929         hello = alloca0_align(sz, 8);
 930         hello->size = sz;
 931         hello->flags = b->hello_flags;
 932         hello->attach_flags_send = _KDBUS_ATTACH_ANY;
 933         hello->attach_flags_recv = b->attach_flags;
 934         hello->pool_size = KDBUS_POOL_SIZE;
 935
 936         item = hello->items;
 937
 938         item->size = offsetof(struct kdbus_item, str) + m + 1;
 939         item->type = KDBUS_ITEM_CONN_DESCRIPTION;
 940         memcpy(item->str, name, m + 1);
 941         item = KDBUS_ITEM_NEXT(item);
 942
 943         if (b->fake_creds_valid) {
 944                 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
 945                 item->type = KDBUS_ITEM_CREDS;
 946                 item->creds = b->fake_creds;
 947
 948                 item = KDBUS_ITEM_NEXT(item);
 949         }
 950
 951         if (b->fake_pids_valid) {
 952                 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
 953                 item->type = KDBUS_ITEM_PIDS;
 954                 item->pids = b->fake_pids;
 955
 956                 item = KDBUS_ITEM_NEXT(item);
 957         }
 958
 959         if (b->fake_label) {
 960                 item->size = offsetof(struct kdbus_item, str) + l + 1;
 961                 item->type = KDBUS_ITEM_SECLABEL;
 962                 memcpy(item->str, b->fake_label, l+1);
 963         }
 964
 965         r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
 966         if (r < 0)
 967                 return -errno;
 968
 969         if (!b->kdbus_buffer) {
 970                 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
 971                 if (b->kdbus_buffer == MAP_FAILED) {
 972                         b->kdbus_buffer = NULL;
 973                         r = -errno;
 974                         goto fail;
 975                 }
 976         }
 977
 978         /* The higher 32bit of the bus_flags fields are considered
 979          * 'incompatible flags'. Refuse them all for now. */
 980         if (hello->bus_flags > 0xFFFFFFFFULL) {
 981                 r = -EOPNOTSUPP;
 982                 goto fail;
 983         }
 984
 985         /* extract bloom parameters from items */
 986         items = (void*)((uint8_t*)b->kdbus_buffer + hello->offset);
 987         KDBUS_FOREACH(item, items, hello->items_size) {
 988                 switch (item->type) {
 989                 case KDBUS_ITEM_BLOOM_PARAMETER:
 990                         bloom = &item->bloom_parameter;
 991                         break;
 992                 }
 993         }
 994
 995         if (!bloom || !bloom_validate_parameters((size_t) bloom->size, (unsigned) bloom->n_hash)) {
 996                 r = -EOPNOTSUPP;
 997                 goto fail;
 998         }
 999
1000         b->bloom_size = (size_t) bloom->size;
1001         b->bloom_n_hash = (unsigned) bloom->n_hash;
1002
1003         if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0) {
1004                 r = -ENOMEM;
1005                 goto fail;
1006         }
1007
1008         b->unique_id = hello->id;
1009
1010         b->is_kernel = true;
1011         b->bus_client = true;
1012         b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
1013         b->message_version = 2;
1014         b->message_endian = BUS_NATIVE_ENDIAN;
1015
1016         /* the kernel told us the UUID of the underlying bus */
1017         memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
1018
1019         /* free returned items */
1020         (void) bus_kernel_cmd_free(b, hello->offset);
1021         return bus_start_running(b);
1022
1023 fail:
1024         (void) bus_kernel_cmd_free(b, hello->offset);
1025         return r;
1026 }
1027
1028 int bus_kernel_connect(sd_bus *b) {
1029         assert(b);
1030         assert(b->input_fd < 0);
1031         assert(b->output_fd < 0);
1032         assert(b->kernel);
1033
1034         if (b->is_server)
1035                 return -EINVAL;
1036
1037         b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
1038         if (b->input_fd < 0)
1039                 return -errno;
1040
1041         b->output_fd = b->input_fd;
1042
1043         return bus_kernel_take_fd(b);
1044 }
1045
1046 int bus_kernel_cmd_free(sd_bus *bus, uint64_t offset) {
1047         struct kdbus_cmd_free cmd = {
1048                 .size = sizeof(cmd),
1049                 .offset = offset,
1050         };
1051         int r;
1052
1053         assert(bus);
1054         assert(bus->is_kernel);
1055
1056         r = ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
1057         if (r < 0)
1058                 return -errno;
1059
1060         return 0;
1061 }
1062
1063 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
1064         struct kdbus_item *d;
1065
1066         assert(bus);
1067         assert(k);
1068
1069         KDBUS_ITEM_FOREACH(d, k, items) {
1070                 if (d->type == KDBUS_ITEM_FDS)
1071                         close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
1072                 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
1073                         safe_close(d->memfd.fd);
1074         }
1075
1076         bus_kernel_cmd_free(bus, (uint8_t*) k - (uint8_t*) bus->kdbus_buffer);
1077 }
1078
1079 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
1080         struct kdbus_cmd_send cmd = { };
1081         int r;
1082
1083         assert(bus);
1084         assert(m);
1085         assert(bus->state == BUS_RUNNING);
1086
1087         /* If we can't deliver, we want room for the error message */
1088         r = bus_rqueue_make_room(bus);
1089         if (r < 0)
1090                 return r;
1091
1092         r = bus_message_setup_kmsg(bus, m);
1093         if (r < 0)
1094                 return r;
1095
1096         cmd.size = sizeof(cmd);
1097         cmd.msg_address = (uintptr_t)m->kdbus;
1098
1099         /* If this is a synchronous method call, then let's tell the
1100          * kernel, so that it can pass CPU time/scheduling to the
1101          * destination for the time, if it wants to. If we
1102          * synchronously wait for the result anyway, we won't need CPU
1103          * anyway. */
1104         if (hint_sync_call) {
1105                 m->kdbus->flags |= KDBUS_MSG_EXPECT_REPLY;
1106                 cmd.flags |= KDBUS_SEND_SYNC_REPLY;
1107         }
1108
1109         r = ioctl(bus->output_fd, KDBUS_CMD_SEND, &cmd);
1110         if (r < 0) {
1111                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1112                 sd_bus_message *reply;
1113
1114                 if (errno == EAGAIN || errno == EINTR)
1115                         return 0;
1116                 else if (errno == ENXIO || errno == ESRCH) {
1117
1118                         /* ENXIO: unique name not known
1119                          * ESRCH: well-known name not known */
1120
1121                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1122                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
1123                         else {
1124                                 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
1125                                 return 0;
1126                         }
1127
1128                 } else if (errno == EADDRNOTAVAIL) {
1129
1130                         /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
1131
1132                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1133                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
1134                         else {
1135                                 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
1136                                 return 0;
1137                         }
1138                 } else
1139                         return -errno;
1140
1141                 r = bus_message_new_synthetic_error(
1142                                 bus,
1143                                 BUS_MESSAGE_COOKIE(m),
1144                                 &error,
1145                                 &reply);
1146
1147                 if (r < 0)
1148                         return r;
1149
1150                 r = bus_seal_synthetic_message(bus, reply);
1151                 if (r < 0)
1152                         return r;
1153
1154                 bus->rqueue[bus->rqueue_size++] = reply;
1155
1156         } else if (hint_sync_call) {
1157                 struct kdbus_msg *k;
1158
1159                 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + cmd.reply.offset);
1160                 assert(k);
1161
1162                 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1163
1164                         r = bus_kernel_make_message(bus, k);
1165                         if (r < 0) {
1166                                 close_kdbus_msg(bus, k);
1167
1168                                 /* Anybody can send us invalid messages, let's just drop them. */
1169                                 if (r == -EBADMSG || r == -EPROTOTYPE)
1170                                         log_debug_errno(r, "Ignoring invalid synchronous reply: %m");
1171                                 else
1172                                         return r;
1173                         }
1174                 } else {
1175                         log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1176                         close_kdbus_msg(bus, k);
1177                 }
1178         }
1179
1180         return 1;
1181 }
1182
1183 static int push_name_owner_changed(
1184                 sd_bus *bus,
1185                 const char *name,
1186                 const char *old_owner,
1187                 const char *new_owner,
1188                 const struct kdbus_timestamp *ts) {
1189
1190         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1191         int r;
1192
1193         assert(bus);
1194
1195         r = sd_bus_message_new_signal(
1196                         bus,
1197                         &m,
1198                         "/org/freedesktop/DBus",
1199                         "org.freedesktop.DBus",
1200                         "NameOwnerChanged");
1201         if (r < 0)
1202                 return r;
1203
1204         r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1205         if (r < 0)
1206                 return r;
1207
1208         bus_message_set_sender_driver(bus, m);
1209         message_set_timestamp(bus, m, ts);
1210
1211         r = bus_seal_synthetic_message(bus, m);
1212         if (r < 0)
1213                 return r;
1214
1215         bus->rqueue[bus->rqueue_size++] = m;
1216         m = NULL;
1217
1218         return 1;
1219 }
1220
1221 static int translate_name_change(
1222                 sd_bus *bus,
1223                 const struct kdbus_msg *k,
1224                 const struct kdbus_item *d,
1225                 const struct kdbus_timestamp *ts) {
1226
1227         char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1228
1229         assert(bus);
1230         assert(k);
1231         assert(d);
1232
1233         if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1234                 old_owner[0] = 0;
1235         else
1236                 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1237
1238         if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1239
1240                 if (isempty(old_owner))
1241                         return 0;
1242
1243                 new_owner[0] = 0;
1244         } else
1245                 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1246
1247         return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner, ts);
1248 }
1249
1250 static int translate_id_change(
1251                 sd_bus *bus,
1252                 const struct kdbus_msg *k,
1253                 const struct kdbus_item *d,
1254                 const struct kdbus_timestamp *ts) {
1255
1256         char owner[UNIQUE_NAME_MAX];
1257
1258         assert(bus);
1259         assert(k);
1260         assert(d);
1261
1262         sprintf(owner, ":1.%llu", d->id_change.id);
1263
1264         return push_name_owner_changed(
1265                         bus, owner,
1266                         d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1267                         d->type == KDBUS_ITEM_ID_ADD ? owner : NULL,
1268                         ts);
1269 }
1270
1271 static int translate_reply(
1272                 sd_bus *bus,
1273                 const struct kdbus_msg *k,
1274                 const struct kdbus_item *d,
1275                 const struct kdbus_timestamp *ts) {
1276
1277         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1278         int r;
1279
1280         assert(bus);
1281         assert(k);
1282         assert(d);
1283
1284         r = bus_message_new_synthetic_error(
1285                         bus,
1286                         k->cookie_reply,
1287                         d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1288                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1289                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1290                         &m);
1291         if (r < 0)
1292                 return r;
1293
1294         message_set_timestamp(bus, m, ts);
1295
1296         r = bus_seal_synthetic_message(bus, m);
1297         if (r < 0)
1298                 return r;
1299
1300         bus->rqueue[bus->rqueue_size++] = m;
1301         m = NULL;
1302
1303         return 1;
1304 }
1305
1306 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1307         static int (* const translate[])(sd_bus *bus, const struct kdbus_msg *k, const struct kdbus_item *d, const struct kdbus_timestamp *ts) = {
1308                 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1309                 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1310                 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1311
1312                 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1313                 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1314
1315                 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1316                 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1317         };
1318
1319         struct kdbus_item *d, *found = NULL;
1320         struct kdbus_timestamp *ts = NULL;
1321
1322         assert(bus);
1323         assert(k);
1324         assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1325
1326         KDBUS_ITEM_FOREACH(d, k, items) {
1327                 if (d->type == KDBUS_ITEM_TIMESTAMP)
1328                         ts = &d->timestamp;
1329
1330                 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1331                         if (found)
1332                                 return -EBADMSG;
1333                         found = d;
1334                 } else
1335                         log_debug("Got unknown field from kernel %llu", d->type);
1336         }
1337
1338         if (!found) {
1339                 log_debug("Didn't find a kernel message to translate.");
1340                 return 0;
1341         }
1342
1343         return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found, ts);
1344 }
1345
1346 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1347         struct kdbus_cmd_recv recv = { .size = sizeof(recv) };
1348         struct kdbus_msg *k;
1349         int r;
1350
1351         assert(bus);
1352
1353         r = bus_rqueue_make_room(bus);
1354         if (r < 0)
1355                 return r;
1356
1357         if (hint_priority) {
1358                 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1359                 recv.priority = priority;
1360         }
1361
1362         r = ioctl(bus->input_fd, KDBUS_CMD_RECV, &recv);
1363         if (recv.return_flags & KDBUS_RECV_RETURN_DROPPED_MSGS)
1364                 log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1365         if (r < 0) {
1366                 if (errno == EAGAIN)
1367                         return 0;
1368
1369                 return -errno;
1370         }
1371
1372         k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.msg.offset);
1373         if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1374                 r = bus_kernel_make_message(bus, k);
1375
1376                 /* Anybody can send us invalid messages, let's just drop them. */
1377                 if (r == -EBADMSG || r == -EPROTOTYPE) {
1378                         log_debug_errno(r, "Ignoring invalid message: %m");
1379                         r = 0;
1380                 }
1381
1382         } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1383                 r = bus_kernel_translate_message(bus, k);
1384         else {
1385                 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1386                 r = 0;
1387         }
1388
1389         if (r <= 0)
1390                 close_kdbus_msg(bus, k);
1391
1392         return r < 0 ? r : 1;
1393 }
1394
1395 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1396         struct memfd_cache *c;
1397         int fd;
1398
1399         assert(address);
1400         assert(mapped);
1401         assert(allocated);
1402
1403         if (!bus || !bus->is_kernel)
1404                 return -EOPNOTSUPP;
1405
1406         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1407
1408         if (bus->n_memfd_cache <= 0) {
1409                 int r;
1410
1411                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1412
1413                 r = memfd_new(bus->description);
1414                 if (r < 0)
1415                         return r;
1416
1417                 *address = NULL;
1418                 *mapped = 0;
1419                 *allocated = 0;
1420                 return r;
1421         }
1422
1423         c = &bus->memfd_cache[--bus->n_memfd_cache];
1424
1425         assert(c->fd >= 0);
1426         assert(c->mapped == 0 || c->address);
1427
1428         *address = c->address;
1429         *mapped = c->mapped;
1430         *allocated = c->allocated;
1431         fd = c->fd;
1432
1433         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1434
1435         return fd;
1436 }
1437
1438 static void close_and_munmap(int fd, void *address, size_t size) {
1439         if (size > 0)
1440                 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1441
1442         safe_close(fd);
1443 }
1444
1445 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1446         struct memfd_cache *c;
1447         uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1448
1449         assert(fd >= 0);
1450         assert(mapped == 0 || address);
1451
1452         if (!bus || !bus->is_kernel) {
1453                 close_and_munmap(fd, address, mapped);
1454                 return;
1455         }
1456
1457         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1458
1459         if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1460                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1461
1462                 close_and_munmap(fd, address, mapped);
1463                 return;
1464         }
1465
1466         c = &bus->memfd_cache[bus->n_memfd_cache++];
1467         c->fd = fd;
1468         c->address = address;
1469
1470         /* If overly long, let's return a bit to the OS */
1471         if (mapped > max_mapped) {
1472                 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1473                 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1474                 c->mapped = c->allocated = max_mapped;
1475         } else {
1476                 c->mapped = mapped;
1477                 c->allocated = allocated;
1478         }
1479
1480         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1481 }
1482
1483 void bus_kernel_flush_memfd(sd_bus *b) {
1484         unsigned i;
1485
1486         assert(b);
1487
1488         for (i = 0; i < b->n_memfd_cache; i++)
1489                 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1490 }
1491
1492 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1493         uint64_t f = 0;
1494
1495         if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1496                 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1497
1498         if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1499                 f |= KDBUS_NAME_REPLACE_EXISTING;
1500
1501         if (flags & SD_BUS_NAME_QUEUE)
1502                 f |= KDBUS_NAME_QUEUE;
1503
1504         return f;
1505 }
1506
1507 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1508         uint64_t m = 0;
1509
1510         if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1511                     SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1512                 m |= KDBUS_ATTACH_CREDS;
1513
1514         if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_TID|SD_BUS_CREDS_PPID))
1515                 m |= KDBUS_ATTACH_PIDS;
1516
1517         if (mask & SD_BUS_CREDS_COMM)
1518                 m |= KDBUS_ATTACH_PID_COMM;
1519
1520         if (mask & SD_BUS_CREDS_TID_COMM)
1521                 m |= KDBUS_ATTACH_TID_COMM;
1522
1523         if (mask & SD_BUS_CREDS_EXE)
1524                 m |= KDBUS_ATTACH_EXE;
1525
1526         if (mask & SD_BUS_CREDS_CMDLINE)
1527                 m |= KDBUS_ATTACH_CMDLINE;
1528
1529         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))
1530                 m |= KDBUS_ATTACH_CGROUP;
1531
1532         if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1533                 m |= KDBUS_ATTACH_CAPS;
1534
1535         if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1536                 m |= KDBUS_ATTACH_SECLABEL;
1537
1538         if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1539                 m |= KDBUS_ATTACH_AUDIT;
1540
1541         if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1542                 m |= KDBUS_ATTACH_NAMES;
1543
1544         if (mask & SD_BUS_CREDS_DESCRIPTION)
1545                 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1546
1547         if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1548                 m |= KDBUS_ATTACH_AUXGROUPS;
1549
1550         return m;
1551 }
1552
1553 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1554         struct kdbus_cmd *make;
1555         struct kdbus_item *n;
1556         size_t l;
1557         int fd;
1558
1559         assert(name);
1560         assert(s);
1561
1562         fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1563         if (fd < 0)
1564                 return -errno;
1565
1566         l = strlen(name);
1567         make = alloca0_align(offsetof(struct kdbus_cmd, items) +
1568                              ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1569                              ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1570                              ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1571                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1572                              8);
1573
1574         make->size = offsetof(struct kdbus_cmd, items);
1575
1576         /* Set the bloom parameters */
1577         n = make->items;
1578         n->size = offsetof(struct kdbus_item, bloom_parameter) +
1579                   sizeof(struct kdbus_bloom_parameter);
1580         n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1581         n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1582         n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1583
1584         assert_cc(DEFAULT_BLOOM_SIZE > 0);
1585         assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1586
1587         make->size += ALIGN8(n->size);
1588
1589         /* The busses we create make no restrictions on what metadata
1590          * peers can read from incoming messages. */
1591         n = KDBUS_ITEM_NEXT(n);
1592         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1593         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1594         n->data64[0] = _KDBUS_ATTACH_ANY;
1595         make->size += ALIGN8(n->size);
1596
1597         /* Provide all metadata via bus-owner queries */
1598         n = KDBUS_ITEM_NEXT(n);
1599         n->type = KDBUS_ITEM_ATTACH_FLAGS_SEND;
1600         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1601         n->data64[0] = _KDBUS_ATTACH_ANY;
1602         make->size += ALIGN8(n->size);
1603
1604         /* Set the a good name */
1605         n = KDBUS_ITEM_NEXT(n);
1606         sprintf(n->str, UID_FMT "-%s", getuid(), name);
1607         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1608         n->type = KDBUS_ITEM_MAKE_NAME;
1609         make->size += ALIGN8(n->size);
1610
1611         make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1612
1613         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1614                 safe_close(fd);
1615                 return -errno;
1616         }
1617
1618         if (s) {
1619                 char *p;
1620
1621                 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1622                 if (!p) {
1623                         safe_close(fd);
1624                         return -ENOMEM;
1625                 }
1626
1627                 *s = p;
1628         }
1629
1630         return fd;
1631 }
1632
1633 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1634         char *p;
1635         int fd;
1636         size_t len;
1637
1638         assert(bus);
1639
1640         len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1641
1642         if (path) {
1643                 p = new(char, len);
1644                 if (!p)
1645                         return -ENOMEM;
1646         } else
1647                 p = newa(char, len);
1648
1649         sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1650
1651         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1652         if (fd < 0) {
1653                 if (path)
1654                         free(p);
1655
1656                 return -errno;
1657         }
1658
1659         if (path)
1660                 *path = p;
1661
1662         return fd;
1663 }
1664
1665 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1666         _cleanup_free_ char *path = NULL;
1667         struct kdbus_cmd *make;
1668         struct kdbus_item *n;
1669         const char *name;
1670         int fd;
1671
1672         fd = bus_kernel_open_bus_fd(bus_name, &path);
1673         if (fd < 0)
1674                 return fd;
1675
1676         make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd, items)) +
1677                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1678                              8);
1679         make->size = ALIGN8(offsetof(struct kdbus_cmd, items));
1680         make->flags = KDBUS_MAKE_ACCESS_WORLD;
1681
1682         n = make->items;
1683         sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1684         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1685         n->type = KDBUS_ITEM_MAKE_NAME;
1686         make->size += ALIGN8(n->size);
1687         name = n->str;
1688
1689         if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1690                 safe_close(fd);
1691                 return -errno;
1692         }
1693
1694         if (ep_path) {
1695                 char *p;
1696
1697                 p = strjoin(dirname(path), "/", name, NULL);
1698                 if (!p) {
1699                         safe_close(fd);
1700                         return -ENOMEM;
1701                 }
1702
1703                 *ep_path = p;
1704         }
1705
1706         return fd;
1707 }
1708
1709 int bus_kernel_try_close(sd_bus *bus) {
1710         struct kdbus_cmd byebye = { .size = sizeof(byebye) };
1711
1712         assert(bus);
1713         assert(bus->is_kernel);
1714
1715         if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE, &byebye) < 0)
1716                 return -errno;
1717
1718         return 0;
1719 }
1720
1721 int bus_kernel_drop_one(int fd) {
1722         struct kdbus_cmd_recv recv = {
1723                 .size = sizeof(recv),
1724                 .flags = KDBUS_RECV_DROP,
1725         };
1726
1727         assert(fd >= 0);
1728
1729         if (ioctl(fd, KDBUS_CMD_RECV, &recv) < 0)
1730                 return -errno;
1731
1732         return 0;
1733 }
1734
1735 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1736         struct kdbus_cmd *update;
1737         struct kdbus_item *n;
1738
1739         assert(bus);
1740         assert(bus->is_kernel);
1741
1742         update = alloca0_align(offsetof(struct kdbus_cmd, items) +
1743                                ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1744                                8);
1745
1746         n = update->items;
1747         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1748         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1749         n->data64[0] = bus->attach_flags;
1750
1751         update->size =
1752                 offsetof(struct kdbus_cmd, items) +
1753                 ALIGN8(n->size);
1754
1755         if (ioctl(bus->input_fd, KDBUS_CMD_UPDATE, update) < 0)
1756                 return -errno;
1757
1758         return 0;
1759 }
1760
1761 int bus_kernel_fix_attach_mask(void) {
1762         _cleanup_free_ char *mask = NULL;
1763         uint64_t m = (uint64_t) -1;
1764         char buf[2+16+2];
1765         int r;
1766
1767         /* By default we don't want any kdbus metadata fields to be
1768          * suppressed, hence we reset the kernel mask for it to
1769          * (uint64_t) -1. If the module argument was overwritten by
1770          * the kernel cmdline, we leave it as is. */
1771
1772         r = get_proc_cmdline_key("kdbus.attach_flags_mask=", &mask);
1773         if (r < 0)
1774                 return log_warning_errno(r, "Failed to read kernel command line: %m");
1775
1776         if (r == 0) {
1777                 sprintf(buf, "0x%" PRIx64 "\n", m);
1778                 r = write_string_file("/sys/module/kdbus/parameters/attach_flags_mask", buf);
1779                 if (r < 0)
1780                         return log_full_errno(IN_SET(r, -ENOENT, -EROFS) ? LOG_DEBUG : LOG_WARNING, r,
1781                                               "Failed to write kdbus attach mask: %m");
1782         }
1783
1784         return 0;
1785 }
1786
1787 int bus_kernel_get_bus_name(sd_bus *bus, char **name) {
1788         struct kdbus_cmd_info cmd = {
1789                 .size = sizeof(struct kdbus_cmd_info),
1790         };
1791         struct kdbus_info *info;
1792         struct kdbus_item *item;
1793         char *n = NULL;
1794         int r;
1795
1796         assert(bus);
1797         assert(name);
1798         assert(bus->is_kernel);
1799
1800         r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
1801         if (r < 0)
1802                 return -errno;
1803
1804         info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset);
1805
1806         KDBUS_ITEM_FOREACH(item, info, items)
1807                 if (item->type == KDBUS_ITEM_MAKE_NAME) {
1808                         r = free_and_strdup(&n, item->str);
1809                         break;
1810                 }
1811
1812         bus_kernel_cmd_free(bus, cmd.offset);
1813
1814         if (r < 0)
1815                 return r;
1816         if (!n)
1817                 return -EIO;
1818
1819         *name = n;
1820         return 0;
1821 }