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

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