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

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