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