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 POSIX
  33  * version which is really broken. We prefer GNU basename(). */
  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                         seclabel, 0, &m);
 502         if (r < 0)
 503                 return r;
 504
 505         /* The well-known names list is different from the other
 506         credentials. If we asked for it, but nothing is there, this
 507         means that the list of well-known names is simply empty, not
 508         that we lack any data */
 509
 510         m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
 511
 512         KDBUS_ITEM_FOREACH(d, k, items) {
 513                 size_t l;
 514
 515                 l = d->size - offsetof(struct kdbus_item, data);
 516
 517                 switch (d->type) {
 518
 519                 case KDBUS_ITEM_PAYLOAD_OFF: {
 520                         size_t begin_body;
 521
 522                         begin_body = BUS_MESSAGE_BODY_BEGIN(m);
 523
 524                         if (idx + d->vec.size > begin_body) {
 525                                 struct bus_body_part *part;
 526
 527                                 /* Contains body material */
 528
 529                                 part = message_append_part(m);
 530                                 if (!part) {
 531                                         r = -ENOMEM;
 532                                         goto fail;
 533                                 }
 534
 535                                 /* A -1 offset is NUL padding. */
 536                                 part->is_zero = d->vec.offset == ~0ULL;
 537
 538                                 if (idx >= begin_body) {
 539                                         if (!part->is_zero)
 540                                                 part->data = (uint8_t* )k + d->vec.offset;
 541                                         part->size = d->vec.size;
 542                                 } else {
 543                                         if (!part->is_zero)
 544                                                 part->data = (uint8_t*) k + d->vec.offset + (begin_body - idx);
 545                                         part->size = d->vec.size - (begin_body - idx);
 546                                 }
 547
 548                                 part->sealed = true;
 549                         }
 550
 551                         idx += d->vec.size;
 552                         break;
 553                 }
 554
 555                 case KDBUS_ITEM_PAYLOAD_MEMFD: {
 556                         struct bus_body_part *part;
 557
 558                         if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
 559                                 r = -EBADMSG;
 560                                 goto fail;
 561                         }
 562
 563                         part = message_append_part(m);
 564                         if (!part) {
 565                                 r = -ENOMEM;
 566                                 goto fail;
 567                         }
 568
 569                         part->memfd = d->memfd.fd;
 570                         part->memfd_offset = d->memfd.start;
 571                         part->size = d->memfd.size;
 572                         part->sealed = true;
 573
 574                         idx += d->memfd.size;
 575                         break;
 576                 }
 577
 578                 case KDBUS_ITEM_PIDS:
 579
 580                         /* The PID/TID might be missing, when the data
 581                          * is faked by a bus proxy and it lacks that
 582                          * information about the real client (since
 583                          * SO_PEERCRED is used for that). Also kernel
 584                          * namespacing might make some of this data
 585                          * unavailable when untranslatable. */
 586
 587                         if (d->pids.pid > 0) {
 588                                 m->creds.pid = (pid_t) d->pids.pid;
 589                                 m->creds.mask |= SD_BUS_CREDS_PID & bus->creds_mask;
 590                         }
 591
 592                         if (d->pids.tid > 0) {
 593                                 m->creds.tid = (pid_t) d->pids.tid;
 594                                 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
 595                         }
 596
 597                         if (d->pids.ppid > 0) {
 598                                 m->creds.ppid = (pid_t) d->pids.ppid;
 599                                 m->creds.mask |= SD_BUS_CREDS_PPID & bus->creds_mask;
 600                         } else if (d->pids.pid == 1) {
 601                                 m->creds.ppid = 0;
 602                                 m->creds.mask |= SD_BUS_CREDS_PPID & bus->creds_mask;
 603                         }
 604
 605                         break;
 606
 607                 case KDBUS_ITEM_CREDS:
 608
 609                         /* EUID/SUID/FSUID/EGID/SGID/FSGID might be
 610                          * missing too (see above). */
 611
 612                         if ((uid_t) d->creds.uid != UID_INVALID) {
 613                                 m->creds.uid = (uid_t) d->creds.uid;
 614                                 m->creds.mask |= SD_BUS_CREDS_UID & bus->creds_mask;
 615                         }
 616
 617                         if ((uid_t) d->creds.euid != UID_INVALID) {
 618                                 m->creds.euid = (uid_t) d->creds.euid;
 619                                 m->creds.mask |= SD_BUS_CREDS_EUID & bus->creds_mask;
 620                         }
 621
 622                         if ((uid_t) d->creds.suid != UID_INVALID) {
 623                                 m->creds.suid = (uid_t) d->creds.suid;
 624                                 m->creds.mask |= SD_BUS_CREDS_SUID & bus->creds_mask;
 625                         }
 626
 627                         if ((uid_t) d->creds.fsuid != UID_INVALID) {
 628                                 m->creds.fsuid = (uid_t) d->creds.fsuid;
 629                                 m->creds.mask |= SD_BUS_CREDS_FSUID & bus->creds_mask;
 630                         }
 631
 632                         if ((gid_t) d->creds.gid != GID_INVALID) {
 633                                 m->creds.gid = (gid_t) d->creds.gid;
 634                                 m->creds.mask |= SD_BUS_CREDS_GID & bus->creds_mask;
 635                         }
 636
 637                         if ((gid_t) d->creds.egid != GID_INVALID) {
 638                                 m->creds.egid = (gid_t) d->creds.egid;
 639                                 m->creds.mask |= SD_BUS_CREDS_EGID & bus->creds_mask;
 640                         }
 641
 642                         if ((gid_t) d->creds.sgid != GID_INVALID) {
 643                                 m->creds.sgid = (gid_t) d->creds.sgid;
 644                                 m->creds.mask |= SD_BUS_CREDS_SGID & bus->creds_mask;
 645                         }
 646
 647                         if ((gid_t) d->creds.fsgid != GID_INVALID) {
 648                                 m->creds.fsgid = (gid_t) d->creds.fsgid;
 649                                 m->creds.mask |= SD_BUS_CREDS_FSGID & bus->creds_mask;
 650                         }
 651
 652                         break;
 653
 654                 case KDBUS_ITEM_TIMESTAMP:
 655                         message_set_timestamp(bus, m, &d->timestamp);
 656                         break;
 657
 658                 case KDBUS_ITEM_PID_COMM:
 659                         m->creds.comm = d->str;
 660                         m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
 661                         break;
 662
 663                 case KDBUS_ITEM_TID_COMM:
 664                         m->creds.tid_comm = d->str;
 665                         m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
 666                         break;
 667
 668                 case KDBUS_ITEM_EXE:
 669                         m->creds.exe = d->str;
 670                         m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
 671                         break;
 672
 673                 case KDBUS_ITEM_CMDLINE:
 674                         m->creds.cmdline = d->str;
 675                         m->creds.cmdline_size = l;
 676                         m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
 677                         break;
 678
 679                 case KDBUS_ITEM_CGROUP:
 680                         m->creds.cgroup = d->str;
 681                         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;
 682
 683                         r = bus_get_root_path(bus);
 684                         if (r < 0)
 685                                 goto fail;
 686
 687                         m->creds.cgroup_root = bus->cgroup_root;
 688                         break;
 689
 690                 case KDBUS_ITEM_AUDIT:
 691                         m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
 692                         m->creds.mask |= SD_BUS_CREDS_AUDIT_SESSION_ID & bus->creds_mask;
 693
 694                         m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
 695                         m->creds.mask |= SD_BUS_CREDS_AUDIT_LOGIN_UID & bus->creds_mask;
 696                         break;
 697
 698                 case KDBUS_ITEM_CAPS:
 699                         if (d->caps.last_cap != cap_last_cap() ||
 700                             d->size - offsetof(struct kdbus_item, caps.caps) < DIV_ROUND_UP(d->caps.last_cap, 32U) * 4 * 4) {
 701                                 r = -EBADMSG;
 702                                 goto fail;
 703                         }
 704
 705                         m->creds.capability = d->caps.caps;
 706                         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;
 707                         break;
 708
 709                 case KDBUS_ITEM_DST_NAME:
 710                         if (!service_name_is_valid(d->str)) {
 711                                 r = -EBADMSG;
 712                                 goto fail;
 713                         }
 714
 715                         destination = d->str;
 716                         break;
 717
 718                 case KDBUS_ITEM_OWNED_NAME:
 719                         if (!service_name_is_valid(d->name.name)) {
 720                                 r = -EBADMSG;
 721                                 goto fail;
 722                         }
 723
 724                         if (bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES) {
 725                                 char **wkn;
 726                                 size_t n;
 727
 728                                 /* We just extend the array here, but
 729                                  * do not allocate the strings inside
 730                                  * of it, instead we just point to our
 731                                  * buffer directly. */
 732                                 n = strv_length(m->creds.well_known_names);
 733                                 wkn = realloc(m->creds.well_known_names, (n + 2) * sizeof(char*));
 734                                 if (!wkn) {
 735                                         r = -ENOMEM;
 736                                         goto fail;
 737                                 }
 738
 739                                 wkn[n] = d->name.name;
 740                                 wkn[n+1] = NULL;
 741                                 m->creds.well_known_names = wkn;
 742
 743                                 m->creds.mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES;
 744                         }
 745                         break;
 746
 747                 case KDBUS_ITEM_CONN_DESCRIPTION:
 748                         m->creds.description = d->str;
 749                         m->creds.mask |= SD_BUS_CREDS_DESCRIPTION & bus->creds_mask;
 750                         break;
 751
 752                 case KDBUS_ITEM_AUXGROUPS:
 753
 754                         if (bus->creds_mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS) {
 755                                 size_t i, n;
 756                                 gid_t *g;
 757
 758                                 n = (d->size - offsetof(struct kdbus_item, data64)) / sizeof(uint64_t);
 759                                 g = new(gid_t, n);
 760                                 if (!g) {
 761                                         r = -ENOMEM;
 762                                         goto fail;
 763                                 }
 764
 765                                 for (i = 0; i < n; i++)
 766                                         g[i] = d->data64[i];
 767
 768                                 m->creds.supplementary_gids = g;
 769                                 m->creds.n_supplementary_gids = n;
 770                                 m->creds.mask |= SD_BUS_CREDS_SUPPLEMENTARY_GIDS;
 771                         }
 772
 773                         break;
 774
 775                 case KDBUS_ITEM_FDS:
 776                 case KDBUS_ITEM_SECLABEL:
 777                         break;
 778
 779                 default:
 780                         log_debug("Got unknown field from kernel %llu", d->type);
 781                 }
 782         }
 783
 784         /* If we requested the list of well-known names to be appended
 785          * and the sender had none no item for it will be
 786          * attached. However, this does *not* mean that the kernel
 787          * didn't want to provide this information to us. Hence, let's
 788          * explicitly mark this information as available if it was
 789          * requested. */
 790         m->creds.mask |= bus->creds_mask & SD_BUS_CREDS_WELL_KNOWN_NAMES;
 791
 792         r = bus_message_parse_fields(m);
 793         if (r < 0)
 794                 goto fail;
 795
 796         /* Refuse messages if kdbus and dbus1 cookie doesn't match up */
 797         if ((uint64_t) m->header->dbus2.cookie != k->cookie) {
 798                 r = -EBADMSG;
 799                 goto fail;
 800         }
 801
 802         /* Refuse messages where the reply flag doesn't match up */
 803         if (!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) != !!(k->flags & KDBUS_MSG_EXPECT_REPLY)) {
 804                 r = -EBADMSG;
 805                 goto fail;
 806         }
 807
 808         /* Refuse reply messages where the reply cookie doesn't match up */
 809         if ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) && m->reply_cookie != k->cookie_reply) {
 810                 r = -EBADMSG;
 811                 goto fail;
 812         }
 813
 814         /* Refuse messages where the autostart flag doesn't match up */
 815         if (!(m->header->flags & BUS_MESSAGE_NO_AUTO_START) != !(k->flags & KDBUS_MSG_NO_AUTO_START)) {
 816                 r = -EBADMSG;
 817                 goto fail;
 818         }
 819
 820         /* Override information from the user header with data from the kernel */
 821         if (k->src_id == KDBUS_SRC_ID_KERNEL)
 822                 bus_message_set_sender_driver(bus, m);
 823         else {
 824                 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
 825                 m->sender = m->creds.unique_name = m->sender_buffer;
 826         }
 827
 828         if (destination)
 829                 m->destination = destination;
 830         else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
 831                 m->destination = NULL;
 832         else if (k->dst_id == KDBUS_DST_ID_NAME)
 833                 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
 834         else {
 835                 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
 836                 m->destination = m->destination_buffer;
 837         }
 838
 839         /* We take possession of the kmsg struct now */
 840         m->kdbus = k;
 841         m->release_kdbus = true;
 842         m->free_fds = true;
 843         fds = NULL;
 844
 845         bus->rqueue[bus->rqueue_size++] = m;
 846
 847         return 1;
 848
 849 fail:
 850         unset_memfds(m);
 851         sd_bus_message_unref(m);
 852
 853         return r;
 854 }
 855
 856 int bus_kernel_take_fd(sd_bus *b) {
 857         struct kdbus_bloom_parameter *bloom = NULL;
 858         struct kdbus_item *items, *item;
 859         struct kdbus_cmd_hello *hello;
 860         _cleanup_free_ char *g = NULL;
 861         const char *name;
 862         size_t l = 0, m = 0, sz;
 863         int r;
 864
 865         assert(b);
 866
 867         if (b->is_server)
 868                 return -EINVAL;
 869
 870         b->use_memfd = 1;
 871
 872         if (b->description) {
 873                 g = bus_label_escape(b->description);
 874                 if (!g)
 875                         return -ENOMEM;
 876
 877                 name = g;
 878         } else {
 879                 char pr[17] = {};
 880
 881                 /* If no name is explicitly set, we'll include a hint
 882                  * indicating the library implementation, a hint which
 883                  * kind of bus this is and the thread name */
 884
 885                 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
 886
 887                 if (isempty(pr)) {
 888                         name = b->is_system ? "sd-system" :
 889                                 b->is_user ? "sd-user" : "sd";
 890                 } else {
 891                         _cleanup_free_ char *e = NULL;
 892
 893                         e = bus_label_escape(pr);
 894                         if (!e)
 895                                 return -ENOMEM;
 896
 897                         g = strappend(b->is_system ? "sd-system-" :
 898                                       b->is_user ? "sd-user-" : "sd-",
 899                                       e);
 900                         if (!g)
 901                                 return -ENOMEM;
 902
 903                         name = g;
 904                 }
 905
 906                 b->description = bus_label_unescape(name);
 907                 if (!b->description)
 908                         return -ENOMEM;
 909         }
 910
 911         m = strlen(name);
 912
 913         sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
 914                 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
 915
 916         if (b->fake_creds_valid)
 917                 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
 918
 919         if (b->fake_pids_valid)
 920                 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
 921
 922         if (b->fake_label) {
 923                 l = strlen(b->fake_label);
 924                 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
 925         }
 926
 927         hello = alloca0_align(sz, 8);
 928         hello->size = sz;
 929         hello->flags = b->hello_flags;
 930         hello->attach_flags_send = _KDBUS_ATTACH_ANY;
 931         hello->attach_flags_recv = b->attach_flags;
 932         hello->pool_size = KDBUS_POOL_SIZE;
 933
 934         item = hello->items;
 935
 936         item->size = offsetof(struct kdbus_item, str) + m + 1;
 937         item->type = KDBUS_ITEM_CONN_DESCRIPTION;
 938         memcpy(item->str, name, m + 1);
 939         item = KDBUS_ITEM_NEXT(item);
 940
 941         if (b->fake_creds_valid) {
 942                 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
 943                 item->type = KDBUS_ITEM_CREDS;
 944                 item->creds = b->fake_creds;
 945
 946                 item = KDBUS_ITEM_NEXT(item);
 947         }
 948
 949         if (b->fake_pids_valid) {
 950                 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
 951                 item->type = KDBUS_ITEM_PIDS;
 952                 item->pids = b->fake_pids;
 953
 954                 item = KDBUS_ITEM_NEXT(item);
 955         }
 956
 957         if (b->fake_label) {
 958                 item->size = offsetof(struct kdbus_item, str) + l + 1;
 959                 item->type = KDBUS_ITEM_SECLABEL;
 960                 memcpy(item->str, b->fake_label, l+1);
 961         }
 962
 963         r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
 964         if (r < 0) {
 965                 if (errno == ENOTTY)
 966                         /* If the ioctl is not supported we assume that the
 967                          * API version changed in a major incompatible way,
 968                          * let's indicate an API incompatibility in this
 969                          * case. */
 970                         return -ESOCKTNOSUPPORT;
 971
 972                 return -errno;
 973         }
 974
 975         if (!b->kdbus_buffer) {
 976                 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
 977                 if (b->kdbus_buffer == MAP_FAILED) {
 978                         b->kdbus_buffer = NULL;
 979                         r = -errno;
 980                         goto fail;
 981                 }
 982         }
 983
 984         /* The higher 32bit of the bus_flags fields are considered
 985          * 'incompatible flags'. Refuse them all for now. */
 986         if (hello->bus_flags > 0xFFFFFFFFULL) {
 987                 r = -ESOCKTNOSUPPORT;
 988                 goto fail;
 989         }
 990
 991         /* extract bloom parameters from items */
 992         items = (void*)((uint8_t*)b->kdbus_buffer + hello->offset);
 993         KDBUS_FOREACH(item, items, hello->items_size) {
 994                 switch (item->type) {
 995                 case KDBUS_ITEM_BLOOM_PARAMETER:
 996                         bloom = &item->bloom_parameter;
 997                         break;
 998                 }
 999         }
1000
1001         if (!bloom || !bloom_validate_parameters((size_t) bloom->size, (unsigned) bloom->n_hash)) {
1002                 r = -EOPNOTSUPP;
1003                 goto fail;
1004         }
1005
1006         b->bloom_size = (size_t) bloom->size;
1007         b->bloom_n_hash = (unsigned) bloom->n_hash;
1008
1009         if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0) {
1010                 r = -ENOMEM;
1011                 goto fail;
1012         }
1013
1014         b->unique_id = hello->id;
1015
1016         b->is_kernel = true;
1017         b->bus_client = true;
1018         b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
1019         b->message_version = 2;
1020         b->message_endian = BUS_NATIVE_ENDIAN;
1021
1022         /* the kernel told us the UUID of the underlying bus */
1023         memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
1024
1025         /* free returned items */
1026         (void) bus_kernel_cmd_free(b, hello->offset);
1027         return bus_start_running(b);
1028
1029 fail:
1030         (void) bus_kernel_cmd_free(b, hello->offset);
1031         return r;
1032 }
1033
1034 int bus_kernel_connect(sd_bus *b) {
1035         assert(b);
1036         assert(b->input_fd < 0);
1037         assert(b->output_fd < 0);
1038         assert(b->kernel);
1039
1040         if (b->is_server)
1041                 return -EINVAL;
1042
1043         b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
1044         if (b->input_fd < 0)
1045                 return -errno;
1046
1047         b->output_fd = b->input_fd;
1048
1049         return bus_kernel_take_fd(b);
1050 }
1051
1052 int bus_kernel_cmd_free(sd_bus *bus, uint64_t offset) {
1053         struct kdbus_cmd_free cmd = {
1054                 .size = sizeof(cmd),
1055                 .offset = offset,
1056         };
1057         int r;
1058
1059         assert(bus);
1060         assert(bus->is_kernel);
1061
1062         r = ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
1063         if (r < 0)
1064                 return -errno;
1065
1066         return 0;
1067 }
1068
1069 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
1070         struct kdbus_item *d;
1071
1072         assert(bus);
1073         assert(k);
1074
1075         KDBUS_ITEM_FOREACH(d, k, items) {
1076                 if (d->type == KDBUS_ITEM_FDS)
1077                         close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
1078                 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
1079                         safe_close(d->memfd.fd);
1080         }
1081
1082         bus_kernel_cmd_free(bus, (uint8_t*) k - (uint8_t*) bus->kdbus_buffer);
1083 }
1084
1085 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
1086         struct kdbus_cmd_send cmd = { };
1087         int r;
1088
1089         assert(bus);
1090         assert(m);
1091         assert(bus->state == BUS_RUNNING);
1092
1093         /* If we can't deliver, we want room for the error message */
1094         r = bus_rqueue_make_room(bus);
1095         if (r < 0)
1096                 return r;
1097
1098         r = bus_message_setup_kmsg(bus, m);
1099         if (r < 0)
1100                 return r;
1101
1102         cmd.size = sizeof(cmd);
1103         cmd.msg_address = (uintptr_t)m->kdbus;
1104
1105         /* If this is a synchronous method call, then let's tell the
1106          * kernel, so that it can pass CPU time/scheduling to the
1107          * destination for the time, if it wants to. If we
1108          * synchronously wait for the result anyway, we won't need CPU
1109          * anyway. */
1110         if (hint_sync_call) {
1111                 m->kdbus->flags |= KDBUS_MSG_EXPECT_REPLY;
1112                 cmd.flags |= KDBUS_SEND_SYNC_REPLY;
1113         }
1114
1115         r = ioctl(bus->output_fd, KDBUS_CMD_SEND, &cmd);
1116         if (r < 0) {
1117                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1118                 sd_bus_message *reply;
1119
1120                 if (errno == EAGAIN || errno == EINTR)
1121                         return 0;
1122                 else if (errno == ENXIO || errno == ESRCH) {
1123
1124                         /* ENXIO: unique name not known
1125                          * ESRCH: well-known name not known */
1126
1127                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1128                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
1129                         else {
1130                                 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
1131                                 return 0;
1132                         }
1133
1134                 } else if (errno == EADDRNOTAVAIL) {
1135
1136                         /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
1137
1138                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1139                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
1140                         else {
1141                                 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
1142                                 return 0;
1143                         }
1144                 } else
1145                         return -errno;
1146
1147                 r = bus_message_new_synthetic_error(
1148                                 bus,
1149                                 BUS_MESSAGE_COOKIE(m),
1150                                 &error,
1151                                 &reply);
1152
1153                 if (r < 0)
1154                         return r;
1155
1156                 r = bus_seal_synthetic_message(bus, reply);
1157                 if (r < 0)
1158                         return r;
1159
1160                 bus->rqueue[bus->rqueue_size++] = reply;
1161
1162         } else if (hint_sync_call) {
1163                 struct kdbus_msg *k;
1164
1165                 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + cmd.reply.offset);
1166                 assert(k);
1167
1168                 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1169
1170                         r = bus_kernel_make_message(bus, k);
1171                         if (r < 0) {
1172                                 close_kdbus_msg(bus, k);
1173
1174                                 /* Anybody can send us invalid messages, let's just drop them. */
1175                                 if (r == -EBADMSG || r == -EPROTOTYPE)
1176                                         log_debug_errno(r, "Ignoring invalid synchronous reply: %m");
1177                                 else
1178                                         return r;
1179                         }
1180                 } else {
1181                         log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1182                         close_kdbus_msg(bus, k);
1183                 }
1184         }
1185
1186         return 1;
1187 }
1188
1189 static int push_name_owner_changed(
1190                 sd_bus *bus,
1191                 const char *name,
1192                 const char *old_owner,
1193                 const char *new_owner,
1194                 const struct kdbus_timestamp *ts) {
1195
1196         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1197         int r;
1198
1199         assert(bus);
1200
1201         r = sd_bus_message_new_signal(
1202                         bus,
1203                         &m,
1204                         "/org/freedesktop/DBus",
1205                         "org.freedesktop.DBus",
1206                         "NameOwnerChanged");
1207         if (r < 0)
1208                 return r;
1209
1210         r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1211         if (r < 0)
1212                 return r;
1213
1214         bus_message_set_sender_driver(bus, m);
1215         message_set_timestamp(bus, m, ts);
1216
1217         r = bus_seal_synthetic_message(bus, m);
1218         if (r < 0)
1219                 return r;
1220
1221         bus->rqueue[bus->rqueue_size++] = m;
1222         m = NULL;
1223
1224         return 1;
1225 }
1226
1227 static int translate_name_change(
1228                 sd_bus *bus,
1229                 const struct kdbus_msg *k,
1230                 const struct kdbus_item *d,
1231                 const struct kdbus_timestamp *ts) {
1232
1233         char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1234
1235         assert(bus);
1236         assert(k);
1237         assert(d);
1238
1239         if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1240                 old_owner[0] = 0;
1241         else
1242                 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1243
1244         if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1245
1246                 if (isempty(old_owner))
1247                         return 0;
1248
1249                 new_owner[0] = 0;
1250         } else
1251                 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1252
1253         return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner, ts);
1254 }
1255
1256 static int translate_id_change(
1257                 sd_bus *bus,
1258                 const struct kdbus_msg *k,
1259                 const struct kdbus_item *d,
1260                 const struct kdbus_timestamp *ts) {
1261
1262         char owner[UNIQUE_NAME_MAX];
1263
1264         assert(bus);
1265         assert(k);
1266         assert(d);
1267
1268         sprintf(owner, ":1.%llu", d->id_change.id);
1269
1270         return push_name_owner_changed(
1271                         bus, owner,
1272                         d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1273                         d->type == KDBUS_ITEM_ID_ADD ? owner : NULL,
1274                         ts);
1275 }
1276
1277 static int translate_reply(
1278                 sd_bus *bus,
1279                 const struct kdbus_msg *k,
1280                 const struct kdbus_item *d,
1281                 const struct kdbus_timestamp *ts) {
1282
1283         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1284         int r;
1285
1286         assert(bus);
1287         assert(k);
1288         assert(d);
1289
1290         r = bus_message_new_synthetic_error(
1291                         bus,
1292                         k->cookie_reply,
1293                         d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1294                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1295                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1296                         &m);
1297         if (r < 0)
1298                 return r;
1299
1300         message_set_timestamp(bus, m, ts);
1301
1302         r = bus_seal_synthetic_message(bus, m);
1303         if (r < 0)
1304                 return r;
1305
1306         bus->rqueue[bus->rqueue_size++] = m;
1307         m = NULL;
1308
1309         return 1;
1310 }
1311
1312 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1313         static int (* const translate[])(sd_bus *bus, const struct kdbus_msg *k, const struct kdbus_item *d, const struct kdbus_timestamp *ts) = {
1314                 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1315                 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1316                 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1317
1318                 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1319                 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1320
1321                 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1322                 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1323         };
1324
1325         struct kdbus_item *d, *found = NULL;
1326         struct kdbus_timestamp *ts = NULL;
1327
1328         assert(bus);
1329         assert(k);
1330         assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1331
1332         KDBUS_ITEM_FOREACH(d, k, items) {
1333                 if (d->type == KDBUS_ITEM_TIMESTAMP)
1334                         ts = &d->timestamp;
1335
1336                 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1337                         if (found)
1338                                 return -EBADMSG;
1339                         found = d;
1340                 } else
1341                         log_debug("Got unknown field from kernel %llu", d->type);
1342         }
1343
1344         if (!found) {
1345                 log_debug("Didn't find a kernel message to translate.");
1346                 return 0;
1347         }
1348
1349         return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found, ts);
1350 }
1351
1352 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1353         struct kdbus_cmd_recv recv = { .size = sizeof(recv) };
1354         struct kdbus_msg *k;
1355         int r;
1356
1357         assert(bus);
1358
1359         r = bus_rqueue_make_room(bus);
1360         if (r < 0)
1361                 return r;
1362
1363         if (hint_priority) {
1364                 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1365                 recv.priority = priority;
1366         }
1367
1368         r = ioctl(bus->input_fd, KDBUS_CMD_RECV, &recv);
1369         if (recv.return_flags & KDBUS_RECV_RETURN_DROPPED_MSGS)
1370                 log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1371         if (r < 0) {
1372                 if (errno == EAGAIN)
1373                         return 0;
1374
1375                 return -errno;
1376         }
1377
1378         k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.msg.offset);
1379         if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1380                 r = bus_kernel_make_message(bus, k);
1381
1382                 /* Anybody can send us invalid messages, let's just drop them. */
1383                 if (r == -EBADMSG || r == -EPROTOTYPE) {
1384                         log_debug_errno(r, "Ignoring invalid message: %m");
1385                         r = 0;
1386                 }
1387
1388                 if (r <= 0)
1389                         close_kdbus_msg(bus, k);
1390         } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL) {
1391                 r = bus_kernel_translate_message(bus, k);
1392                 close_kdbus_msg(bus, k);
1393         } else {
1394                 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1395                 r = 0;
1396                 close_kdbus_msg(bus, k);
1397         }
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, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1578                              8);
1579
1580         make->size = offsetof(struct kdbus_cmd, items);
1581
1582         /* Set the bloom parameters */
1583         n = make->items;
1584         n->size = offsetof(struct kdbus_item, bloom_parameter) +
1585                   sizeof(struct kdbus_bloom_parameter);
1586         n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1587         n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1588         n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1589
1590         assert_cc(DEFAULT_BLOOM_SIZE > 0);
1591         assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1592
1593         make->size += ALIGN8(n->size);
1594
1595         /* Provide all metadata via bus-owner queries */
1596         n = KDBUS_ITEM_NEXT(n);
1597         n->type = KDBUS_ITEM_ATTACH_FLAGS_SEND;
1598         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1599         n->data64[0] = _KDBUS_ATTACH_ANY;
1600         make->size += ALIGN8(n->size);
1601
1602         /* Set the a good name */
1603         n = KDBUS_ITEM_NEXT(n);
1604         sprintf(n->str, UID_FMT "-%s", getuid(), name);
1605         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1606         n->type = KDBUS_ITEM_MAKE_NAME;
1607         make->size += ALIGN8(n->size);
1608
1609         make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1610
1611         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1612                 safe_close(fd);
1613
1614                 /* Major API change? then the ioctls got shuffled around. */
1615                 if (errno == ENOTTY)
1616                         return -ESOCKTNOSUPPORT;
1617
1618                 return -errno;
1619         }
1620
1621         if (s) {
1622                 char *p;
1623
1624                 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1625                 if (!p) {
1626                         safe_close(fd);
1627                         return -ENOMEM;
1628                 }
1629
1630                 *s = p;
1631         }
1632
1633         return fd;
1634 }
1635
1636 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1637         char *p;
1638         int fd;
1639         size_t len;
1640
1641         assert(bus);
1642
1643         len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1644
1645         if (path) {
1646                 p = new(char, len);
1647                 if (!p)
1648                         return -ENOMEM;
1649         } else
1650                 p = newa(char, len);
1651
1652         sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1653
1654         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1655         if (fd < 0) {
1656                 if (path)
1657                         free(p);
1658
1659                 return -errno;
1660         }
1661
1662         if (path)
1663                 *path = p;
1664
1665         return fd;
1666 }
1667
1668 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1669         _cleanup_free_ char *path = NULL;
1670         struct kdbus_cmd *make;
1671         struct kdbus_item *n;
1672         const char *name;
1673         int fd;
1674
1675         fd = bus_kernel_open_bus_fd(bus_name, &path);
1676         if (fd < 0)
1677                 return fd;
1678
1679         make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd, items)) +
1680                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1681                              8);
1682         make->size = ALIGN8(offsetof(struct kdbus_cmd, items));
1683         make->flags = KDBUS_MAKE_ACCESS_WORLD;
1684
1685         n = make->items;
1686         sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1687         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1688         n->type = KDBUS_ITEM_MAKE_NAME;
1689         make->size += ALIGN8(n->size);
1690         name = n->str;
1691
1692         if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1693                 safe_close(fd);
1694                 return -errno;
1695         }
1696
1697         if (ep_path) {
1698                 char *p;
1699
1700                 p = strjoin(dirname(path), "/", name, NULL);
1701                 if (!p) {
1702                         safe_close(fd);
1703                         return -ENOMEM;
1704                 }
1705
1706                 *ep_path = p;
1707         }
1708
1709         return fd;
1710 }
1711
1712 int bus_kernel_try_close(sd_bus *bus) {
1713         struct kdbus_cmd byebye = { .size = sizeof(byebye) };
1714
1715         assert(bus);
1716         assert(bus->is_kernel);
1717
1718         if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE, &byebye) < 0)
1719                 return -errno;
1720
1721         return 0;
1722 }
1723
1724 int bus_kernel_drop_one(int fd) {
1725         struct kdbus_cmd_recv recv = {
1726                 .size = sizeof(recv),
1727                 .flags = KDBUS_RECV_DROP,
1728         };
1729
1730         assert(fd >= 0);
1731
1732         if (ioctl(fd, KDBUS_CMD_RECV, &recv) < 0)
1733                 return -errno;
1734
1735         return 0;
1736 }
1737
1738 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1739         struct kdbus_cmd *update;
1740         struct kdbus_item *n;
1741
1742         assert(bus);
1743         assert(bus->is_kernel);
1744
1745         update = alloca0_align(offsetof(struct kdbus_cmd, items) +
1746                                ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1747                                8);
1748
1749         n = update->items;
1750         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1751         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1752         n->data64[0] = bus->attach_flags;
1753
1754         update->size =
1755                 offsetof(struct kdbus_cmd, items) +
1756                 ALIGN8(n->size);
1757
1758         if (ioctl(bus->input_fd, KDBUS_CMD_UPDATE, update) < 0)
1759                 return -errno;
1760
1761         return 0;
1762 }
1763
1764 int bus_kernel_get_bus_name(sd_bus *bus, char **name) {
1765         struct kdbus_cmd_info cmd = {
1766                 .size = sizeof(struct kdbus_cmd_info),
1767         };
1768         struct kdbus_info *info;
1769         struct kdbus_item *item;
1770         char *n = NULL;
1771         int r;
1772
1773         assert(bus);
1774         assert(name);
1775         assert(bus->is_kernel);
1776
1777         r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
1778         if (r < 0)
1779                 return -errno;
1780
1781         info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset);
1782
1783         KDBUS_ITEM_FOREACH(item, info, items)
1784                 if (item->type == KDBUS_ITEM_MAKE_NAME) {
1785                         r = free_and_strdup(&n, item->str);
1786                         break;
1787                 }
1788
1789         bus_kernel_cmd_free(bus, cmd.offset);
1790
1791         if (r < 0)
1792                 return r;
1793         if (!n)
1794                 return -EIO;
1795
1796         *name = n;
1797         return 0;
1798 }