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_bloom_parameter *bloom = NULL;
 826         struct kdbus_cmd_hello *hello;
 827         struct kdbus_item_list *items;
 828         struct kdbus_item *item;
 829         _cleanup_free_ char *g = NULL;
 830         const char *name;
 831         size_t l = 0, m = 0, sz;
 832         int r;
 833
 834         assert(b);
 835
 836         if (b->is_server)
 837                 return -EINVAL;
 838
 839         b->use_memfd = 1;
 840
 841         if (b->description) {
 842                 g = bus_label_escape(b->description);
 843                 if (!g)
 844                         return -ENOMEM;
 845
 846                 name = g;
 847         } else {
 848                 char pr[17] = {};
 849
 850                 /* If no name is explicitly set, we'll include a hint
 851                  * indicating the library implementation, a hint which
 852                  * kind of bus this is and the thread name */
 853
 854                 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
 855
 856                 if (isempty(pr)) {
 857                         name = b->is_system ? "sd-system" :
 858                                 b->is_user ? "sd-user" : "sd";
 859                 } else {
 860                         _cleanup_free_ char *e = NULL;
 861
 862                         e = bus_label_escape(pr);
 863                         if (!e)
 864                                 return -ENOMEM;
 865
 866                         g = strappend(b->is_system ? "sd-system-" :
 867                                       b->is_user ? "sd-user-" : "sd-",
 868                                       e);
 869                         if (!g)
 870                                 return -ENOMEM;
 871
 872                         name = g;
 873                 }
 874
 875                 b->description = bus_label_unescape(name);
 876                 if (!b->description)
 877                         return -ENOMEM;
 878         }
 879
 880         m = strlen(name);
 881
 882         sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
 883                 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
 884
 885         if (b->fake_creds_valid)
 886                 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
 887
 888         if (b->fake_pids_valid)
 889                 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
 890
 891         if (b->fake_label) {
 892                 l = strlen(b->fake_label);
 893                 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
 894         }
 895
 896         hello = alloca0_align(sz, 8);
 897         hello->size = sz;
 898         hello->flags = b->hello_flags;
 899         hello->attach_flags_send = _KDBUS_ATTACH_ANY;
 900         hello->attach_flags_recv = b->attach_flags;
 901         hello->pool_size = KDBUS_POOL_SIZE;
 902
 903         item = hello->items;
 904
 905         item->size = offsetof(struct kdbus_item, str) + m + 1;
 906         item->type = KDBUS_ITEM_CONN_DESCRIPTION;
 907         memcpy(item->str, name, m + 1);
 908         item = KDBUS_ITEM_NEXT(item);
 909
 910         if (b->fake_creds_valid) {
 911                 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
 912                 item->type = KDBUS_ITEM_CREDS;
 913                 item->creds = b->fake_creds;
 914
 915                 item = KDBUS_ITEM_NEXT(item);
 916         }
 917
 918         if (b->fake_pids_valid) {
 919                 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
 920                 item->type = KDBUS_ITEM_PIDS;
 921                 item->pids = b->fake_pids;
 922
 923                 item = KDBUS_ITEM_NEXT(item);
 924         }
 925
 926         if (b->fake_label) {
 927                 item->size = offsetof(struct kdbus_item, str) + l + 1;
 928                 item->type = KDBUS_ITEM_SECLABEL;
 929                 memcpy(item->str, b->fake_label, l+1);
 930         }
 931
 932         r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
 933         if (r < 0)
 934                 return -errno;
 935
 936         if (!b->kdbus_buffer) {
 937                 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
 938                 if (b->kdbus_buffer == MAP_FAILED) {
 939                         b->kdbus_buffer = NULL;
 940                         r = -errno;
 941                         goto fail;
 942                 }
 943         }
 944
 945         /* The higher 32bit of the bus_flags fields are considered
 946          * 'incompatible flags'. Refuse them all for now. */
 947         if (hello->bus_flags > 0xFFFFFFFFULL) {
 948                 r = -ENOTSUP;
 949                 goto fail;
 950         }
 951
 952         /* extract bloom parameters from items */
 953         items = (void*)((uint8_t*)b->kdbus_buffer + hello->offset);
 954         KDBUS_ITEM_FOREACH(item, items, items) {
 955                 switch (item->type) {
 956                 case KDBUS_ITEM_BLOOM_PARAMETER:
 957                         bloom = &item->bloom_parameter;
 958                         break;
 959                 }
 960         }
 961
 962         if (!bloom || !bloom_validate_parameters((size_t) bloom->size, (unsigned) bloom->n_hash)) {
 963                 r = -ENOTSUP;
 964                 goto fail;
 965         }
 966
 967         b->bloom_size = (size_t) bloom->size;
 968         b->bloom_n_hash = (unsigned) bloom->n_hash;
 969
 970         if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0) {
 971                 r = -ENOMEM;
 972                 goto fail;
 973         }
 974
 975         b->unique_id = hello->id;
 976
 977         b->is_kernel = true;
 978         b->bus_client = true;
 979         b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
 980         b->message_version = 2;
 981         b->message_endian = BUS_NATIVE_ENDIAN;
 982
 983         /* the kernel told us the UUID of the underlying bus */
 984         memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
 985
 986         /* free returned items */
 987         (void) bus_kernel_cmd_free(b, hello->offset);
 988         return bus_start_running(b);
 989
 990 fail:
 991         (void) bus_kernel_cmd_free(b, hello->offset);
 992         return r;
 993 }
 994
 995 int bus_kernel_connect(sd_bus *b) {
 996         assert(b);
 997         assert(b->input_fd < 0);
 998         assert(b->output_fd < 0);
 999         assert(b->kernel);
1000
1001         if (b->is_server)
1002                 return -EINVAL;
1003
1004         b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
1005         if (b->input_fd < 0)
1006                 return -errno;
1007
1008         b->output_fd = b->input_fd;
1009
1010         return bus_kernel_take_fd(b);
1011 }
1012
1013 int bus_kernel_cmd_free(sd_bus *bus, uint64_t offset) {
1014         struct kdbus_cmd_free cmd = {
1015                 .size = sizeof(cmd),
1016                 .offset = offset,
1017         };
1018         int r;
1019
1020         assert(bus);
1021         assert(bus->is_kernel);
1022
1023         r = ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
1024         if (r < 0)
1025                 return -errno;
1026
1027         return 0;
1028 }
1029
1030 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
1031         struct kdbus_item *d;
1032
1033         assert(bus);
1034         assert(k);
1035
1036         KDBUS_ITEM_FOREACH(d, k, items) {
1037                 if (d->type == KDBUS_ITEM_FDS)
1038                         close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
1039                 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
1040                         safe_close(d->memfd.fd);
1041         }
1042
1043         bus_kernel_cmd_free(bus, (uint8_t*) k - (uint8_t*) bus->kdbus_buffer);
1044 }
1045
1046 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
1047         struct kdbus_cmd_send cmd = { };
1048         int r;
1049
1050         assert(bus);
1051         assert(m);
1052         assert(bus->state == BUS_RUNNING);
1053
1054         /* If we can't deliver, we want room for the error message */
1055         r = bus_rqueue_make_room(bus);
1056         if (r < 0)
1057                 return r;
1058
1059         r = bus_message_setup_kmsg(bus, m);
1060         if (r < 0)
1061                 return r;
1062
1063         cmd.size = sizeof(cmd);
1064         cmd.msg_address = (uintptr_t)m->kdbus;
1065
1066         /* If this is a synchronous method call, then let's tell the
1067          * kernel, so that it can pass CPU time/scheduling to the
1068          * destination for the time, if it wants to. If we
1069          * synchronously wait for the result anyway, we won't need CPU
1070          * anyway. */
1071         if (hint_sync_call) {
1072                 m->kdbus->flags |= KDBUS_MSG_EXPECT_REPLY;
1073                 cmd.flags |= KDBUS_SEND_SYNC_REPLY;
1074         }
1075
1076         r = ioctl(bus->output_fd, KDBUS_CMD_SEND, &cmd);
1077         if (r < 0) {
1078                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1079                 sd_bus_message *reply;
1080
1081                 if (errno == EAGAIN || errno == EINTR)
1082                         return 0;
1083                 else if (errno == ENXIO || errno == ESRCH) {
1084
1085                         /* ENXIO: unique name not known
1086                          * ESRCH: well-known name not known */
1087
1088                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1089                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
1090                         else {
1091                                 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
1092                                 return 0;
1093                         }
1094
1095                 } else if (errno == EADDRNOTAVAIL) {
1096
1097                         /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
1098
1099                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
1100                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
1101                         else {
1102                                 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
1103                                 return 0;
1104                         }
1105                 } else
1106                         return -errno;
1107
1108                 r = bus_message_new_synthetic_error(
1109                                 bus,
1110                                 BUS_MESSAGE_COOKIE(m),
1111                                 &error,
1112                                 &reply);
1113
1114                 if (r < 0)
1115                         return r;
1116
1117                 r = bus_seal_synthetic_message(bus, reply);
1118                 if (r < 0)
1119                         return r;
1120
1121                 bus->rqueue[bus->rqueue_size++] = reply;
1122
1123         } else if (hint_sync_call) {
1124                 struct kdbus_msg *k;
1125
1126                 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + cmd.reply.offset);
1127                 assert(k);
1128
1129                 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1130
1131                         r = bus_kernel_make_message(bus, k);
1132                         if (r < 0) {
1133                                 close_kdbus_msg(bus, k);
1134
1135                                 /* Anybody can send us invalid messages, let's just drop them. */
1136                                 if (r == -EBADMSG || r == -EPROTOTYPE)
1137                                         log_debug_errno(r, "Ignoring invalid message: %m");
1138                                 else
1139                                         return r;
1140                         }
1141                 } else {
1142                         log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1143                         close_kdbus_msg(bus, k);
1144                 }
1145         }
1146
1147         return 1;
1148 }
1149
1150 static int push_name_owner_changed(
1151                 sd_bus *bus,
1152                 const char *name,
1153                 const char *old_owner,
1154                 const char *new_owner,
1155                 const struct kdbus_timestamp *ts) {
1156
1157         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1158         int r;
1159
1160         assert(bus);
1161
1162         r = sd_bus_message_new_signal(
1163                         bus,
1164                         &m,
1165                         "/org/freedesktop/DBus",
1166                         "org.freedesktop.DBus",
1167                         "NameOwnerChanged");
1168         if (r < 0)
1169                 return r;
1170
1171         r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1172         if (r < 0)
1173                 return r;
1174
1175         bus_message_set_sender_driver(bus, m);
1176         message_set_timestamp(bus, m, ts);
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(
1189                 sd_bus *bus,
1190                 const struct kdbus_msg *k,
1191                 const struct kdbus_item *d,
1192                 const struct kdbus_timestamp *ts) {
1193
1194         char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1195
1196         assert(bus);
1197         assert(k);
1198         assert(d);
1199
1200         if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1201                 old_owner[0] = 0;
1202         else
1203                 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1204
1205         if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1206
1207                 if (isempty(old_owner))
1208                         return 0;
1209
1210                 new_owner[0] = 0;
1211         } else
1212                 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1213
1214         return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner, ts);
1215 }
1216
1217 static int translate_id_change(
1218                 sd_bus *bus,
1219                 const struct kdbus_msg *k,
1220                 const struct kdbus_item *d,
1221                 const struct kdbus_timestamp *ts) {
1222
1223         char owner[UNIQUE_NAME_MAX];
1224
1225         assert(bus);
1226         assert(k);
1227         assert(d);
1228
1229         sprintf(owner, ":1.%llu", d->id_change.id);
1230
1231         return push_name_owner_changed(
1232                         bus, owner,
1233                         d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1234                         d->type == KDBUS_ITEM_ID_ADD ? owner : NULL,
1235                         ts);
1236 }
1237
1238 static int translate_reply(
1239                 sd_bus *bus,
1240                 const struct kdbus_msg *k,
1241                 const struct kdbus_item *d,
1242                 const struct kdbus_timestamp *ts) {
1243
1244         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1245         int r;
1246
1247         assert(bus);
1248         assert(k);
1249         assert(d);
1250
1251         r = bus_message_new_synthetic_error(
1252                         bus,
1253                         k->cookie_reply,
1254                         d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1255                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1256                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1257                         &m);
1258         if (r < 0)
1259                 return r;
1260
1261         message_set_timestamp(bus, m, ts);
1262
1263         r = bus_seal_synthetic_message(bus, m);
1264         if (r < 0)
1265                 return r;
1266
1267         bus->rqueue[bus->rqueue_size++] = m;
1268         m = NULL;
1269
1270         return 1;
1271 }
1272
1273 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1274         static int (* const translate[])(sd_bus *bus, const struct kdbus_msg *k, const struct kdbus_item *d, const struct kdbus_timestamp *ts) = {
1275                 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1276                 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1277                 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1278
1279                 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1280                 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1281
1282                 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1283                 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1284         };
1285
1286         struct kdbus_item *d, *found = NULL;
1287         struct kdbus_timestamp *ts = NULL;
1288
1289         assert(bus);
1290         assert(k);
1291         assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1292
1293         KDBUS_ITEM_FOREACH(d, k, items) {
1294                 if (d->type == KDBUS_ITEM_TIMESTAMP)
1295                         ts = &d->timestamp;
1296
1297                 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1298                         if (found)
1299                                 return -EBADMSG;
1300                         found = d;
1301                 } else
1302                         log_debug("Got unknown field from kernel %llu", d->type);
1303         }
1304
1305         if (!found) {
1306                 log_debug("Didn't find a kernel message to translate.");
1307                 return 0;
1308         }
1309
1310         return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found, ts);
1311 }
1312
1313 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1314         struct kdbus_cmd_recv recv = { .size = sizeof(recv) };
1315         struct kdbus_msg *k;
1316         int r;
1317
1318         assert(bus);
1319
1320         r = bus_rqueue_make_room(bus);
1321         if (r < 0)
1322                 return r;
1323
1324         if (hint_priority) {
1325                 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1326                 recv.priority = priority;
1327         }
1328
1329         r = ioctl(bus->input_fd, KDBUS_CMD_RECV, &recv);
1330         if (r < 0) {
1331                 if (errno == EAGAIN)
1332                         return 0;
1333
1334                 if (errno == EOVERFLOW) {
1335                         log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1336                         return 0;
1337                 }
1338
1339                 return -errno;
1340         }
1341
1342         k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.msg.offset);
1343         if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1344                 r = bus_kernel_make_message(bus, k);
1345
1346                 /* Anybody can send us invalid messages, let's just drop them. */
1347                 if (r == -EBADMSG || r == -EPROTOTYPE) {
1348                         log_debug_errno(r, "Ignoring invalid message: %m");
1349                         r = 0;
1350                 }
1351
1352         } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1353                 r = bus_kernel_translate_message(bus, k);
1354         else {
1355                 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1356                 r = 0;
1357         }
1358
1359         if (r <= 0)
1360                 close_kdbus_msg(bus, k);
1361
1362         return r < 0 ? r : 1;
1363 }
1364
1365 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1366         struct memfd_cache *c;
1367         int fd;
1368
1369         assert(address);
1370         assert(mapped);
1371         assert(allocated);
1372
1373         if (!bus || !bus->is_kernel)
1374                 return -ENOTSUP;
1375
1376         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1377
1378         if (bus->n_memfd_cache <= 0) {
1379                 int r;
1380
1381                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1382
1383                 r = memfd_new(bus->description);
1384                 if (r < 0)
1385                         return r;
1386
1387                 *address = NULL;
1388                 *mapped = 0;
1389                 *allocated = 0;
1390                 return r;
1391         }
1392
1393         c = &bus->memfd_cache[--bus->n_memfd_cache];
1394
1395         assert(c->fd >= 0);
1396         assert(c->mapped == 0 || c->address);
1397
1398         *address = c->address;
1399         *mapped = c->mapped;
1400         *allocated = c->allocated;
1401         fd = c->fd;
1402
1403         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1404
1405         return fd;
1406 }
1407
1408 static void close_and_munmap(int fd, void *address, size_t size) {
1409         if (size > 0)
1410                 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1411
1412         safe_close(fd);
1413 }
1414
1415 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1416         struct memfd_cache *c;
1417         uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1418
1419         assert(fd >= 0);
1420         assert(mapped == 0 || address);
1421
1422         if (!bus || !bus->is_kernel) {
1423                 close_and_munmap(fd, address, mapped);
1424                 return;
1425         }
1426
1427         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1428
1429         if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1430                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1431
1432                 close_and_munmap(fd, address, mapped);
1433                 return;
1434         }
1435
1436         c = &bus->memfd_cache[bus->n_memfd_cache++];
1437         c->fd = fd;
1438         c->address = address;
1439
1440         /* If overly long, let's return a bit to the OS */
1441         if (mapped > max_mapped) {
1442                 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1443                 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1444                 c->mapped = c->allocated = max_mapped;
1445         } else {
1446                 c->mapped = mapped;
1447                 c->allocated = allocated;
1448         }
1449
1450         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1451 }
1452
1453 void bus_kernel_flush_memfd(sd_bus *b) {
1454         unsigned i;
1455
1456         assert(b);
1457
1458         for (i = 0; i < b->n_memfd_cache; i++)
1459                 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1460 }
1461
1462 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1463         uint64_t f = 0;
1464
1465         if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1466                 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1467
1468         if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1469                 f |= KDBUS_NAME_REPLACE_EXISTING;
1470
1471         if (flags & SD_BUS_NAME_QUEUE)
1472                 f |= KDBUS_NAME_QUEUE;
1473
1474         return f;
1475 }
1476
1477 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1478         uint64_t m = 0;
1479
1480         if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1481                     SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1482                 m |= KDBUS_ATTACH_CREDS;
1483
1484         if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_TID))
1485                 m |= KDBUS_ATTACH_PIDS;
1486
1487         if (mask & SD_BUS_CREDS_COMM)
1488                 m |= KDBUS_ATTACH_PID_COMM;
1489
1490         if (mask & SD_BUS_CREDS_TID_COMM)
1491                 m |= KDBUS_ATTACH_TID_COMM;
1492
1493         if (mask & SD_BUS_CREDS_EXE)
1494                 m |= KDBUS_ATTACH_EXE;
1495
1496         if (mask & SD_BUS_CREDS_CMDLINE)
1497                 m |= KDBUS_ATTACH_CMDLINE;
1498
1499         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))
1500                 m |= KDBUS_ATTACH_CGROUP;
1501
1502         if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1503                 m |= KDBUS_ATTACH_CAPS;
1504
1505         if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1506                 m |= KDBUS_ATTACH_SECLABEL;
1507
1508         if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1509                 m |= KDBUS_ATTACH_AUDIT;
1510
1511         if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1512                 m |= KDBUS_ATTACH_NAMES;
1513
1514         if (mask & SD_BUS_CREDS_DESCRIPTION)
1515                 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1516
1517         if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1518                 m |= KDBUS_ATTACH_AUXGROUPS;
1519
1520         return m;
1521 }
1522
1523 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1524         struct kdbus_cmd_make *make;
1525         struct kdbus_item *n;
1526         size_t l;
1527         int fd;
1528
1529         assert(name);
1530         assert(s);
1531
1532         fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1533         if (fd < 0)
1534                 return -errno;
1535
1536         l = strlen(name);
1537         make = alloca0_align(offsetof(struct kdbus_cmd_make, items) +
1538                              ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1539                              ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1540                              ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1541                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1542                              8);
1543
1544         make->size = offsetof(struct kdbus_cmd_make, items);
1545
1546         /* Set the bloom parameters */
1547         n = make->items;
1548         n->size = offsetof(struct kdbus_item, bloom_parameter) +
1549                   sizeof(struct kdbus_bloom_parameter);
1550         n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1551         n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1552         n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1553
1554         assert_cc(DEFAULT_BLOOM_SIZE > 0);
1555         assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1556
1557         make->size += ALIGN8(n->size);
1558
1559         /* The busses we create make no restrictions on what metadata
1560          * peers can read from incoming messages. */
1561         n = KDBUS_ITEM_NEXT(n);
1562         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1563         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1564         n->data64[0] = _KDBUS_ATTACH_ANY;
1565         make->size += ALIGN8(n->size);
1566
1567         /* Provide all metadata via bus-owner queries */
1568         n = KDBUS_ITEM_NEXT(n);
1569         n->type = KDBUS_ITEM_ATTACH_FLAGS_SEND;
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         /* Set the a good name */
1575         n = KDBUS_ITEM_NEXT(n);
1576         sprintf(n->str, UID_FMT "-%s", getuid(), name);
1577         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1578         n->type = KDBUS_ITEM_MAKE_NAME;
1579         make->size += ALIGN8(n->size);
1580
1581         make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1582
1583         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1584                 safe_close(fd);
1585                 return -errno;
1586         }
1587
1588         if (s) {
1589                 char *p;
1590
1591                 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1592                 if (!p) {
1593                         safe_close(fd);
1594                         return -ENOMEM;
1595                 }
1596
1597                 *s = p;
1598         }
1599
1600         return fd;
1601 }
1602
1603 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1604         char *p;
1605         int fd;
1606         size_t len;
1607
1608         assert(bus);
1609
1610         len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1611
1612         if (path) {
1613                 p = new(char, len);
1614                 if (!p)
1615                         return -ENOMEM;
1616         } else
1617                 p = newa(char, len);
1618
1619         sprintf(p, "/sys/fs/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1620
1621         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1622         if (fd < 0) {
1623                 if (path)
1624                         free(p);
1625
1626                 return -errno;
1627         }
1628
1629         if (path)
1630                 *path = p;
1631
1632         return fd;
1633 }
1634
1635 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1636         _cleanup_free_ char *path = NULL;
1637         struct kdbus_cmd_make *make;
1638         struct kdbus_item *n;
1639         const char *name;
1640         int fd;
1641
1642         fd = bus_kernel_open_bus_fd(bus_name, &path);
1643         if (fd < 0)
1644                 return fd;
1645
1646         make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) +
1647                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1648                              8);
1649         make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1650         make->flags = KDBUS_MAKE_ACCESS_WORLD;
1651
1652         n = make->items;
1653         sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1654         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1655         n->type = KDBUS_ITEM_MAKE_NAME;
1656         make->size += ALIGN8(n->size);
1657         name = n->str;
1658
1659         if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1660                 safe_close(fd);
1661                 return -errno;
1662         }
1663
1664         if (ep_path) {
1665                 char *p;
1666
1667                 p = strjoin(dirname(path), "/", name, NULL);
1668                 if (!p) {
1669                         safe_close(fd);
1670                         return -ENOMEM;
1671                 }
1672
1673                 *ep_path = p;
1674         }
1675
1676         return fd;
1677 }
1678
1679 int bus_kernel_try_close(sd_bus *bus) {
1680         assert(bus);
1681         assert(bus->is_kernel);
1682
1683         if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1684                 return -errno;
1685
1686         return 0;
1687 }
1688
1689 int bus_kernel_drop_one(int fd) {
1690         struct kdbus_cmd_recv recv = {
1691                 .size = sizeof(recv),
1692                 .flags = KDBUS_RECV_DROP,
1693         };
1694
1695         assert(fd >= 0);
1696
1697         if (ioctl(fd, KDBUS_CMD_RECV, &recv) < 0)
1698                 return -errno;
1699
1700         return 0;
1701 }
1702
1703 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1704         struct kdbus_cmd_update *update;
1705         struct kdbus_item *n;
1706
1707         assert(bus);
1708         assert(bus->is_kernel);
1709
1710         update = alloca0_align(offsetof(struct kdbus_cmd_update, items) +
1711                                ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1712                                8);
1713
1714         n = update->items;
1715         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1716         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1717         n->data64[0] = bus->attach_flags;
1718
1719         update->size =
1720                 offsetof(struct kdbus_cmd_update, items) +
1721                 ALIGN8(n->size);
1722
1723         if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0)
1724                 return -errno;
1725
1726         return 0;
1727 }
1728
1729 int bus_kernel_fix_attach_mask(void) {
1730         _cleanup_free_ char *mask = NULL;
1731         uint64_t m = (uint64_t) -1;
1732         char buf[2+16+2];
1733         int r;
1734
1735         /* By default we don't want any kdbus metadata fields to be
1736          * suppressed, hence we reset the kernel mask for it to
1737          * (uint64_t) -1. If the module argument was overwritten by
1738          * the kernel cmdline, we leave it as is. */
1739
1740         r = get_proc_cmdline_key("kdbus.attach_flags_mask=", &mask);
1741         if (r < 0)
1742                 return log_warning_errno(r, "Failed to read kernel command line: %m");
1743
1744         if (r == 0) {
1745                 sprintf(buf, "0x%" PRIx64 "\n", m);
1746                 r = write_string_file("/sys/module/kdbus/parameters/attach_flags_mask", buf);
1747                 if (r < 0)
1748                         return log_full_errno(IN_SET(r, -ENOENT, -EROFS) ? LOG_DEBUG : LOG_WARNING, r,
1749                                               "Failed to write kdbus attach mask: %m");
1750         }
1751
1752         return 0;
1753 }
1754
1755 int bus_kernel_get_bus_name(sd_bus *bus, char **name) {
1756         struct kdbus_cmd_info cmd = {
1757                 .size = sizeof(struct kdbus_cmd_info),
1758         };
1759         struct kdbus_info *info;
1760         struct kdbus_item *item;
1761         char *n = NULL;
1762         int r;
1763
1764         assert(bus);
1765         assert(name);
1766         assert(bus->is_kernel);
1767
1768         r = ioctl(bus->input_fd, KDBUS_CMD_BUS_CREATOR_INFO, &cmd);
1769         if (r < 0)
1770                 return -errno;
1771
1772         info = (struct kdbus_info*) ((uint8_t*) bus->kdbus_buffer + cmd.offset);
1773
1774         KDBUS_ITEM_FOREACH(item, info, items)
1775                 if (item->type == KDBUS_ITEM_MAKE_NAME) {
1776                         r = free_and_strdup(&n, item->str);
1777                         break;
1778                 }
1779
1780         bus_kernel_cmd_free(bus, cmd.offset);
1781
1782         if (r < 0)
1783                 return r;
1784         if (!n)
1785                 return -EIO;
1786
1787         *name = n;
1788         return 0;
1789 }