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