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