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