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->header->type == SD_BUS_MESSAGE_SIGNAL) {
 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 unset_memfds(struct sd_bus_message *m) {
 383         struct bus_body_part *part;
 384         unsigned i;
 385
 386         assert(m);
 387
 388         /* Make sure the memfds are not freed twice */
 389         MESSAGE_FOREACH_PART(part, i, m)
 390                 if (part->memfd >= 0)
 391                         part->memfd = -1;
 392 }
 393
 394 static void message_set_timestamp(sd_bus *bus, sd_bus_message *m, const struct kdbus_timestamp *ts) {
 395         assert(bus);
 396         assert(m);
 397
 398         if (!ts)
 399                 return;
 400
 401         if (!(bus->attach_flags & KDBUS_ATTACH_TIMESTAMP))
 402                 return;
 403
 404         m->realtime = ts->realtime_ns / NSEC_PER_USEC;
 405         m->monotonic = ts->monotonic_ns / NSEC_PER_USEC;
 406         m->seqnum = ts->seqnum;
 407 }
 408
 409 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
 410         sd_bus_message *m = NULL;
 411         struct kdbus_item *d;
 412         unsigned n_fds = 0;
 413         _cleanup_free_ int *fds = NULL;
 414         struct bus_header *h = NULL;
 415         size_t total, n_bytes = 0, idx = 0;
 416         const char *destination = NULL, *seclabel = NULL;
 417         int r;
 418
 419         assert(bus);
 420         assert(k);
 421         assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
 422
 423         KDBUS_ITEM_FOREACH(d, k, items) {
 424                 size_t l;
 425
 426                 l = d->size - offsetof(struct kdbus_item, data);
 427
 428                 switch (d->type) {
 429
 430                 case KDBUS_ITEM_PAYLOAD_OFF:
 431                         if (!h) {
 432                                 h = (struct bus_header *)((uint8_t *)bus->kdbus_buffer + d->vec.offset);
 433
 434                                 if (!bus_header_is_complete(h, d->vec.size))
 435                                         return -EBADMSG;
 436                         }
 437
 438                         n_bytes += d->vec.size;
 439                         break;
 440
 441                 case KDBUS_ITEM_PAYLOAD_MEMFD:
 442                         if (!h)
 443                                 return -EBADMSG;
 444
 445                         n_bytes += d->memfd.size;
 446                         break;
 447
 448                 case KDBUS_ITEM_FDS: {
 449                         int *f;
 450                         unsigned j;
 451
 452                         j = l / sizeof(int);
 453                         f = realloc(fds, sizeof(int) * (n_fds + j));
 454                         if (!f)
 455                                 return -ENOMEM;
 456
 457                         fds = f;
 458                         memcpy(fds + n_fds, d->fds, sizeof(int) * j);
 459                         n_fds += j;
 460                         break;
 461                 }
 462
 463                 case KDBUS_ITEM_SECLABEL:
 464                         seclabel = d->str;
 465                         break;
 466                 }
 467         }
 468
 469         if (!h)
 470                 return -EBADMSG;
 471
 472         r = bus_header_message_size(h, &total);
 473         if (r < 0)
 474                 return r;
 475
 476         if (n_bytes != total)
 477                 return -EBADMSG;
 478
 479         /* on kdbus we only speak native endian gvariant, never dbus1
 480          * marshalling or reverse endian */
 481         if (h->version != 2 ||
 482             h->endian != BUS_NATIVE_ENDIAN)
 483                 return -EPROTOTYPE;
 484
 485         r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
 486         if (r < 0)
 487                 return r;
 488
 489         /* The well-known names list is different from the other
 490         credentials. If we asked for it, but nothing is there, this
 491         means that the list of well-known names is simply empty, not
 492         that we lack any data */
 493
 494         m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
 495
 496         KDBUS_ITEM_FOREACH(d, k, items) {
 497                 size_t l;
 498
 499                 l = d->size - offsetof(struct kdbus_item, data);
 500
 501                 switch (d->type) {
 502
 503                 case KDBUS_ITEM_PAYLOAD_OFF: {
 504                         size_t begin_body;
 505
 506                         begin_body = BUS_MESSAGE_BODY_BEGIN(m);
 507
 508                         if (idx + d->vec.size > begin_body) {
 509                                 struct bus_body_part *part;
 510
 511                                 /* Contains body material */
 512
 513                                 part = message_append_part(m);
 514                                 if (!part) {
 515                                         r = -ENOMEM;
 516                                         goto fail;
 517                                 }
 518
 519                                 /* A -1 offset is NUL padding. */
 520                                 part->is_zero = d->vec.offset == ~0ULL;
 521
 522                                 if (idx >= begin_body) {
 523                                         if (!part->is_zero)
 524                                                 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset;
 525                                         part->size = d->vec.size;
 526                                 } else {
 527                                         if (!part->is_zero)
 528                                                 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset + (begin_body - idx);
 529                                         part->size = d->vec.size - (begin_body - idx);
 530                                 }
 531
 532                                 part->sealed = true;
 533                         }
 534
 535                         idx += d->vec.size;
 536                         break;
 537                 }
 538
 539                 case KDBUS_ITEM_PAYLOAD_MEMFD: {
 540                         struct bus_body_part *part;
 541
 542                         if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
 543                                 r = -EBADMSG;
 544                                 goto fail;
 545                         }
 546
 547                         part = message_append_part(m);
 548                         if (!part) {
 549                                 r = -ENOMEM;
 550                                 goto fail;
 551                         }
 552
 553                         part->memfd = d->memfd.fd;
 554                         part->memfd_offset = d->memfd.start;
 555                         part->size = d->memfd.size;
 556                         part->sealed = true;
 557
 558                         idx += d->memfd.size;
 559                         break;
 560                 }
 561
 562                 case KDBUS_ITEM_PIDS:
 563
 564                         /* The PID/TID might be missing, when the data
 565                          * is faked by some data bus proxy and it
 566                          * lacks that information about the real
 567                          * client since SO_PEERCRED is used for
 568                          * that. */
 569
 570                         if (d->pids.pid > 0) {
 571                                 m->creds.pid = (pid_t) d->pids.pid;
 572                                 m->creds.mask |= SD_BUS_CREDS_PID & bus->creds_mask;
 573                         }
 574
 575                         if (d->pids.tid > 0) {
 576                                 m->creds.tid = (pid_t) d->pids.tid;
 577                                 m->creds.mask |= SD_BUS_CREDS_TID & bus->creds_mask;
 578                         }
 579
 580                         break;
 581
 582                 case KDBUS_ITEM_CREDS:
 583
 584                         /* EUID/SUID/FSUID/EGID/SGID/FSGID might be missing too (see above). */
 585
 586                         if ((uid_t) d->creds.uid != UID_INVALID) {
 587                                 m->creds.uid = (uid_t) d->creds.uid;
 588                                 m->creds.mask |= SD_BUS_CREDS_UID & bus->creds_mask;
 589                         }
 590
 591                         if ((uid_t) d->creds.euid != UID_INVALID) {
 592                                 m->creds.euid = (uid_t) d->creds.euid;
 593                                 m->creds.mask |= SD_BUS_CREDS_EUID & bus->creds_mask;
 594                         }
 595
 596                         if ((uid_t) d->creds.suid != UID_INVALID) {
 597                                 m->creds.suid = (uid_t) d->creds.suid;
 598                                 m->creds.mask |= SD_BUS_CREDS_SUID & bus->creds_mask;
 599                         }
 600
 601                         if ((uid_t) d->creds.fsuid != UID_INVALID) {
 602                                 m->creds.fsuid = (uid_t) d->creds.fsuid;
 603                                 m->creds.mask |= SD_BUS_CREDS_FSUID & bus->creds_mask;
 604                         }
 605
 606                         if ((gid_t) d->creds.gid != GID_INVALID) {
 607                                 m->creds.gid = (gid_t) d->creds.gid;
 608                                 m->creds.mask |= SD_BUS_CREDS_GID & bus->creds_mask;
 609                         }
 610
 611                         if ((gid_t) d->creds.egid != GID_INVALID) {
 612                                 m->creds.egid = (gid_t) d->creds.egid;
 613                                 m->creds.mask |= SD_BUS_CREDS_EGID & bus->creds_mask;
 614                         }
 615
 616                         if ((gid_t) d->creds.sgid != GID_INVALID) {
 617                                 m->creds.sgid = (gid_t) d->creds.sgid;
 618                                 m->creds.mask |= SD_BUS_CREDS_SGID & bus->creds_mask;
 619                         }
 620
 621                         if ((gid_t) d->creds.fsgid != GID_INVALID) {
 622                                 m->creds.fsgid = (gid_t) d->creds.fsgid;
 623                                 m->creds.mask |= SD_BUS_CREDS_FSGID & bus->creds_mask;
 624                         }
 625
 626                         break;
 627
 628                 case KDBUS_ITEM_TIMESTAMP:
 629                         message_set_timestamp(bus, m, &d->timestamp);
 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(
1158                 sd_bus *bus,
1159                 const char *name,
1160                 const char *old_owner,
1161                 const char *new_owner,
1162                 const struct kdbus_timestamp *ts) {
1163
1164         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1165         int r;
1166
1167         assert(bus);
1168
1169         r = sd_bus_message_new_signal(
1170                         bus,
1171                         &m,
1172                         "/org/freedesktop/DBus",
1173                         "org.freedesktop.DBus",
1174                         "NameOwnerChanged");
1175         if (r < 0)
1176                 return r;
1177
1178         r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1179         if (r < 0)
1180                 return r;
1181
1182         bus_message_set_sender_driver(bus, m);
1183         message_set_timestamp(bus, m, ts);
1184
1185         r = bus_seal_synthetic_message(bus, m);
1186         if (r < 0)
1187                 return r;
1188
1189         bus->rqueue[bus->rqueue_size++] = m;
1190         m = NULL;
1191
1192         return 1;
1193 }
1194
1195 static int translate_name_change(
1196                 sd_bus *bus,
1197                 const struct kdbus_msg *k,
1198                 const struct kdbus_item *d,
1199                 const struct kdbus_timestamp *ts) {
1200
1201         char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1202
1203         assert(bus);
1204         assert(k);
1205         assert(d);
1206
1207         if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1208                 old_owner[0] = 0;
1209         else
1210                 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1211
1212         if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1213
1214                 if (isempty(old_owner))
1215                         return 0;
1216
1217                 new_owner[0] = 0;
1218         } else
1219                 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1220
1221         return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner, ts);
1222 }
1223
1224 static int translate_id_change(
1225                 sd_bus *bus,
1226                 const struct kdbus_msg *k,
1227                 const struct kdbus_item *d,
1228                 const struct kdbus_timestamp *ts) {
1229
1230         char owner[UNIQUE_NAME_MAX];
1231
1232         assert(bus);
1233         assert(k);
1234         assert(d);
1235
1236         sprintf(owner, ":1.%llu", d->id_change.id);
1237
1238         return push_name_owner_changed(
1239                         bus, owner,
1240                         d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1241                         d->type == KDBUS_ITEM_ID_ADD ? owner : NULL,
1242                         ts);
1243 }
1244
1245 static int translate_reply(
1246                 sd_bus *bus,
1247                 const struct kdbus_msg *k,
1248                 const struct kdbus_item *d,
1249                 const struct kdbus_timestamp *ts) {
1250
1251         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1252         int r;
1253
1254         assert(bus);
1255         assert(k);
1256         assert(d);
1257
1258         r = bus_message_new_synthetic_error(
1259                         bus,
1260                         k->cookie_reply,
1261                         d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1262                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1263                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1264                         &m);
1265         if (r < 0)
1266                 return r;
1267
1268         message_set_timestamp(bus, m, ts);
1269
1270         r = bus_seal_synthetic_message(bus, m);
1271         if (r < 0)
1272                 return r;
1273
1274         bus->rqueue[bus->rqueue_size++] = m;
1275         m = NULL;
1276
1277         return 1;
1278 }
1279
1280 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1281         static int (* const translate[])(sd_bus *bus, const struct kdbus_msg *k, const struct kdbus_item *d, const struct kdbus_timestamp *ts) = {
1282                 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1283                 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1284                 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1285
1286                 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1287                 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1288
1289                 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1290                 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1291         };
1292
1293         struct kdbus_item *d, *found = NULL;
1294         struct kdbus_timestamp *ts = NULL;
1295
1296         assert(bus);
1297         assert(k);
1298         assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1299
1300         KDBUS_ITEM_FOREACH(d, k, items) {
1301                 if (d->type == KDBUS_ITEM_TIMESTAMP)
1302                         ts = &d->timestamp;
1303
1304                 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1305                         if (found)
1306                                 return -EBADMSG;
1307                         found = d;
1308                 } else
1309                         log_debug("Got unknown field from kernel %llu", d->type);
1310         }
1311
1312         if (!found) {
1313                 log_debug("Didn't find a kernel message to translate.");
1314                 return 0;
1315         }
1316
1317         return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found, ts);
1318 }
1319
1320 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1321         struct kdbus_cmd_recv recv = { .size = sizeof(recv) };
1322         struct kdbus_msg *k;
1323         int r;
1324
1325         assert(bus);
1326
1327         r = bus_rqueue_make_room(bus);
1328         if (r < 0)
1329                 return r;
1330
1331         if (hint_priority) {
1332                 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1333                 recv.priority = priority;
1334         }
1335
1336         r = ioctl(bus->input_fd, KDBUS_CMD_RECV, &recv);
1337         if (r < 0) {
1338                 if (errno == EAGAIN)
1339                         return 0;
1340
1341                 if (errno == EOVERFLOW) {
1342                         log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1343                         return 0;
1344                 }
1345
1346                 return -errno;
1347         }
1348
1349         k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.msg.offset);
1350         if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1351                 r = bus_kernel_make_message(bus, k);
1352
1353                 /* Anybody can send us invalid messages, let's just drop them. */
1354                 if (r == -EBADMSG || r == -EPROTOTYPE) {
1355                         log_debug_errno(r, "Ignoring invalid message: %m");
1356                         r = 0;
1357                 }
1358
1359         } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1360                 r = bus_kernel_translate_message(bus, k);
1361         else {
1362                 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1363                 r = 0;
1364         }
1365
1366         if (r <= 0)
1367                 close_kdbus_msg(bus, k);
1368
1369         return r < 0 ? r : 1;
1370 }
1371
1372 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1373         struct memfd_cache *c;
1374         int fd;
1375
1376         assert(address);
1377         assert(mapped);
1378         assert(allocated);
1379
1380         if (!bus || !bus->is_kernel)
1381                 return -ENOTSUP;
1382
1383         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1384
1385         if (bus->n_memfd_cache <= 0) {
1386                 int r;
1387
1388                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1389
1390                 r = memfd_new(bus->description);
1391                 if (r < 0)
1392                         return r;
1393
1394                 *address = NULL;
1395                 *mapped = 0;
1396                 *allocated = 0;
1397                 return r;
1398         }
1399
1400         c = &bus->memfd_cache[--bus->n_memfd_cache];
1401
1402         assert(c->fd >= 0);
1403         assert(c->mapped == 0 || c->address);
1404
1405         *address = c->address;
1406         *mapped = c->mapped;
1407         *allocated = c->allocated;
1408         fd = c->fd;
1409
1410         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1411
1412         return fd;
1413 }
1414
1415 static void close_and_munmap(int fd, void *address, size_t size) {
1416         if (size > 0)
1417                 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1418
1419         safe_close(fd);
1420 }
1421
1422 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1423         struct memfd_cache *c;
1424         uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1425
1426         assert(fd >= 0);
1427         assert(mapped == 0 || address);
1428
1429         if (!bus || !bus->is_kernel) {
1430                 close_and_munmap(fd, address, mapped);
1431                 return;
1432         }
1433
1434         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1435
1436         if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1437                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1438
1439                 close_and_munmap(fd, address, mapped);
1440                 return;
1441         }
1442
1443         c = &bus->memfd_cache[bus->n_memfd_cache++];
1444         c->fd = fd;
1445         c->address = address;
1446
1447         /* If overly long, let's return a bit to the OS */
1448         if (mapped > max_mapped) {
1449                 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1450                 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1451                 c->mapped = c->allocated = max_mapped;
1452         } else {
1453                 c->mapped = mapped;
1454                 c->allocated = allocated;
1455         }
1456
1457         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1458 }
1459
1460 void bus_kernel_flush_memfd(sd_bus *b) {
1461         unsigned i;
1462
1463         assert(b);
1464
1465         for (i = 0; i < b->n_memfd_cache; i++)
1466                 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1467 }
1468
1469 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1470         uint64_t f = 0;
1471
1472         if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1473                 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1474
1475         if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1476                 f |= KDBUS_NAME_REPLACE_EXISTING;
1477
1478         if (flags & SD_BUS_NAME_QUEUE)
1479                 f |= KDBUS_NAME_QUEUE;
1480
1481         return f;
1482 }
1483
1484 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1485         uint64_t m = 0;
1486
1487         if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1488                     SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1489                 m |= KDBUS_ATTACH_CREDS;
1490
1491         if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_TID))
1492                 m |= KDBUS_ATTACH_PIDS;
1493
1494         if (mask & SD_BUS_CREDS_COMM)
1495                 m |= KDBUS_ATTACH_PID_COMM;
1496
1497         if (mask & SD_BUS_CREDS_TID_COMM)
1498                 m |= KDBUS_ATTACH_TID_COMM;
1499
1500         if (mask & SD_BUS_CREDS_EXE)
1501                 m |= KDBUS_ATTACH_EXE;
1502
1503         if (mask & SD_BUS_CREDS_CMDLINE)
1504                 m |= KDBUS_ATTACH_CMDLINE;
1505
1506         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))
1507                 m |= KDBUS_ATTACH_CGROUP;
1508
1509         if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1510                 m |= KDBUS_ATTACH_CAPS;
1511
1512         if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1513                 m |= KDBUS_ATTACH_SECLABEL;
1514
1515         if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1516                 m |= KDBUS_ATTACH_AUDIT;
1517
1518         if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1519                 m |= KDBUS_ATTACH_NAMES;
1520
1521         if (mask & SD_BUS_CREDS_DESCRIPTION)
1522                 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1523
1524         if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1525                 m |= KDBUS_ATTACH_AUXGROUPS;
1526
1527         return m;
1528 }
1529
1530 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1531         struct kdbus_cmd_make *make;
1532         struct kdbus_item *n;
1533         size_t l;
1534         int fd;
1535
1536         assert(name);
1537         assert(s);
1538
1539         fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1540         if (fd < 0)
1541                 return -errno;
1542
1543         l = strlen(name);
1544         make = alloca0_align(offsetof(struct kdbus_cmd_make, items) +
1545                              ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1546                              ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1547                              ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1548                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1549                              8);
1550
1551         make->size = offsetof(struct kdbus_cmd_make, items);
1552
1553         /* Set the bloom parameters */
1554         n = make->items;
1555         n->size = offsetof(struct kdbus_item, bloom_parameter) +
1556                   sizeof(struct kdbus_bloom_parameter);
1557         n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1558         n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1559         n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1560
1561         assert_cc(DEFAULT_BLOOM_SIZE > 0);
1562         assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1563
1564         make->size += ALIGN8(n->size);
1565
1566         /* The busses we create make no restrictions on what metadata
1567          * peers can read from incoming messages. */
1568         n = KDBUS_ITEM_NEXT(n);
1569         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1570         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1571         n->data64[0] = _KDBUS_ATTACH_ANY;
1572         make->size += ALIGN8(n->size);
1573
1574         /* Provide all metadata via bus-owner queries */
1575         n = KDBUS_ITEM_NEXT(n);
1576         n->type = KDBUS_ITEM_ATTACH_FLAGS_SEND;
1577         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1578         n->data64[0] = _KDBUS_ATTACH_ANY;
1579         make->size += ALIGN8(n->size);
1580
1581         /* Set the a good name */
1582         n = KDBUS_ITEM_NEXT(n);
1583         sprintf(n->str, UID_FMT "-%s", getuid(), name);
1584         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1585         n->type = KDBUS_ITEM_MAKE_NAME;
1586         make->size += ALIGN8(n->size);
1587
1588         make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1589
1590         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1591                 safe_close(fd);
1592                 return -errno;
1593         }
1594
1595         if (s) {
1596                 char *p;
1597
1598                 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1599                 if (!p) {
1600                         safe_close(fd);
1601                         return -ENOMEM;
1602                 }
1603
1604                 *s = p;
1605         }
1606
1607         return fd;
1608 }
1609
1610 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1611         char *p;
1612         int fd;
1613         size_t len;
1614
1615         assert(bus);
1616
1617         len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1618
1619         if (path) {
1620                 p = new(char, len);
1621                 if (!p)
1622                         return -ENOMEM;
1623         } else
1624                 p = newa(char, len);
1625
1626         sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1627
1628         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1629         if (fd < 0) {
1630                 if (path)
1631                         free(p);
1632
1633                 return -errno;
1634         }
1635
1636         if (path)
1637                 *path = p;
1638
1639         return fd;
1640 }
1641
1642 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1643         _cleanup_free_ char *path = NULL;
1644         struct kdbus_cmd_make *make;
1645         struct kdbus_item *n;
1646         const char *name;
1647         int fd;
1648
1649         fd = bus_kernel_open_bus_fd(bus_name, &path);
1650         if (fd < 0)
1651                 return fd;
1652
1653         make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) +
1654                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1655                              8);
1656         make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1657         make->flags = KDBUS_MAKE_ACCESS_WORLD;
1658
1659         n = make->items;
1660         sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1661         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1662         n->type = KDBUS_ITEM_MAKE_NAME;
1663         make->size += ALIGN8(n->size);
1664         name = n->str;
1665
1666         if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1667                 safe_close(fd);
1668                 return -errno;
1669         }
1670
1671         if (ep_path) {
1672                 char *p;
1673
1674                 p = strjoin(dirname(path), "/", name, NULL);
1675                 if (!p) {
1676                         safe_close(fd);
1677                         return -ENOMEM;
1678                 }
1679
1680                 *ep_path = p;
1681         }
1682
1683         return fd;
1684 }
1685
1686 int bus_kernel_try_close(sd_bus *bus) {
1687         assert(bus);
1688         assert(bus->is_kernel);
1689
1690         if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1691                 return -errno;
1692
1693         return 0;
1694 }
1695
1696 int bus_kernel_drop_one(int fd) {
1697         struct kdbus_cmd_recv recv = {
1698                 .size = sizeof(recv),
1699                 .flags = KDBUS_RECV_DROP,
1700         };
1701
1702         assert(fd >= 0);
1703
1704         if (ioctl(fd, KDBUS_CMD_RECV, &recv) < 0)
1705                 return -errno;
1706
1707         return 0;
1708 }
1709
1710 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1711         struct kdbus_cmd_update *update;
1712         struct kdbus_item *n;
1713
1714         assert(bus);
1715         assert(bus->is_kernel);
1716
1717         update = alloca0_align(offsetof(struct kdbus_cmd_update, items) +
1718                                ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1719                                8);
1720
1721         n = update->items;
1722         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1723         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1724         n->data64[0] = bus->attach_flags;
1725
1726         update->size =
1727                 offsetof(struct kdbus_cmd_update, items) +
1728                 ALIGN8(n->size);
1729
1730         if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0)
1731                 return -errno;
1732
1733         return 0;
1734 }
1735
1736 int bus_kernel_fix_attach_mask(void) {
1737         _cleanup_free_ char *mask = NULL;
1738         uint64_t m = (uint64_t) -1;
1739         char buf[2+16+2];
1740         int r;
1741
1742         /* By default we don't want any kdbus metadata fields to be
1743          * suppressed, hence we reset the kernel mask for it to
1744          * (uint64_t) -1. If the module argument was overwritten by
1745          * the kernel cmdline, we leave it as is. */
1746
1747         r = get_proc_cmdline_key("kdbus.attach_flags_mask=", &mask);
1748         if (r < 0)
1749                 return log_warning_errno(r, "Failed to read kernel command line: %m");
1750
1751         if (r == 0) {
1752                 sprintf(buf, "0x%" PRIx64 "\n", m);
1753                 r = write_string_file("/sys/module/kdbus/parameters/attach_flags_mask", buf);
1754                 if (r < 0)
1755                         return log_full_errno(IN_SET(r, -ENOENT, -EROFS) ? LOG_DEBUG : LOG_WARNING, r,
1756                                               "Failed to write kdbus attach mask: %m");
1757         }
1758
1759         return 0;
1760 }
1761
1762 int bus_kernel_get_bus_name(sd_bus *bus, char **name) {
1763         struct kdbus_cmd_info cmd = {
1764                 .size = sizeof(struct kdbus_cmd_info),
1765         };
1766         struct kdbus_info *info;
1767         struct kdbus_item *item;
1768         char *n = NULL;
1769         int r;
1770
1771         assert(bus);
1772         assert(name);
1773         assert(bus->is_kernel);
1774
1775         r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
1776         if (r < 0)
1777                 return -errno;
1778
1779         info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset);
1780
1781         KDBUS_ITEM_FOREACH(item, info, items)
1782                 if (item->type == KDBUS_ITEM_MAKE_NAME) {
1783                         r = free_and_strdup(&n, item->str);
1784                         break;
1785                 }
1786
1787         bus_kernel_cmd_free(bus, cmd.offset);
1788
1789         if (r < 0)
1790                 return r;
1791         if (!n)
1792                 return -EIO;
1793
1794         *name = n;
1795         return 0;
1796 }