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

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