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