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