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                                 assert_cc(sizeof(gid_t) == sizeof(uint32_t));
 681
 682                                 m->creds.n_supplementary_gids = (d->size - offsetof(struct kdbus_item, data32)) / sizeof(uint32_t);
 683                                 m->creds.supplementary_gids = (gid_t*) d->data32;
 684                                 m->creds.mask |= SD_BUS_CREDS_SUPPLEMENTARY_GIDS;
 685                         }
 686
 687                         break;
 688
 689                 case KDBUS_ITEM_FDS:
 690                 case KDBUS_ITEM_SECLABEL:
 691                         break;
 692
 693                 default:
 694                         log_debug("Got unknown field from kernel %llu", d->type);
 695                 }
 696         }
 697
 698         r = bus_message_parse_fields(m);
 699         if (r < 0)
 700                 goto fail;
 701
 702         /* Override information from the user header with data from the kernel */
 703         if (k->src_id == KDBUS_SRC_ID_KERNEL)
 704                 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
 705         else {
 706                 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
 707                 m->sender = m->creds.unique_name = m->sender_buffer;
 708         }
 709
 710         if (destination)
 711                 m->destination = destination;
 712         else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
 713                 m->destination = NULL;
 714         else if (k->dst_id == KDBUS_DST_ID_NAME)
 715                 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
 716         else {
 717                 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
 718                 m->destination = m->destination_buffer;
 719         }
 720
 721         /* We take possession of the kmsg struct now */
 722         m->kdbus = k;
 723         m->release_kdbus = true;
 724         m->free_fds = true;
 725         fds = NULL;
 726
 727         bus->rqueue[bus->rqueue_size++] = m;
 728
 729         return 1;
 730
 731 fail:
 732         unset_memfds(m);
 733         sd_bus_message_unref(m);
 734
 735         return r;
 736 }
 737
 738 int bus_kernel_take_fd(sd_bus *b) {
 739         struct kdbus_cmd_hello *hello;
 740         struct kdbus_item *item;
 741         _cleanup_free_ char *g = NULL;
 742         const char *name;
 743         size_t l = 0, m = 0, sz;
 744         int r;
 745
 746         assert(b);
 747
 748         if (b->is_server)
 749                 return -EINVAL;
 750
 751         b->use_memfd = 1;
 752
 753         if (b->description) {
 754                 g = bus_label_escape(b->description);
 755                 if (!g)
 756                         return -ENOMEM;
 757
 758                 name = g;
 759         } else {
 760                 char pr[17] = {};
 761
 762                 /* If no name is explicitly set, we'll include a hint
 763                  * indicating the library implementation, a hint which
 764                  * kind of bus this is and the thread name */
 765
 766                 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
 767
 768                 if (isempty(pr)) {
 769                         name = b->is_system ? "sd-system" :
 770                                 b->is_user ? "sd-user" : "sd";
 771                 } else {
 772                         _cleanup_free_ char *e = NULL;
 773
 774                         e = bus_label_escape(pr);
 775                         if (!e)
 776                                 return -ENOMEM;
 777
 778                         g = strappend(b->is_system ? "sd-system-" :
 779                                       b->is_user ? "sd-user-" : "sd-",
 780                                       e);
 781                         if (!g)
 782                                 return -ENOMEM;
 783
 784                         name = g;
 785                 }
 786
 787                 b->description = bus_label_unescape(name);
 788                 if (!b->description)
 789                         return -ENOMEM;
 790         }
 791
 792         m = strlen(name);
 793
 794         sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
 795                 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
 796
 797         if (b->fake_creds_valid)
 798                 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
 799
 800         if (b->fake_pids_valid)
 801                 sz += ALIGN8(offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids));
 802
 803         if (b->fake_label) {
 804                 l = strlen(b->fake_label);
 805                 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
 806         }
 807
 808         hello = alloca0_align(sz, 8);
 809         hello->size = sz;
 810         hello->flags = b->hello_flags;
 811         hello->attach_flags_send = _KDBUS_ATTACH_ANY;
 812         hello->attach_flags_recv = b->attach_flags;
 813         hello->pool_size = KDBUS_POOL_SIZE;
 814
 815         item = hello->items;
 816
 817         item->size = offsetof(struct kdbus_item, str) + m + 1;
 818         item->type = KDBUS_ITEM_CONN_DESCRIPTION;
 819         memcpy(item->str, name, m + 1);
 820         item = KDBUS_ITEM_NEXT(item);
 821
 822         if (b->fake_creds_valid) {
 823                 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
 824                 item->type = KDBUS_ITEM_CREDS;
 825                 item->creds = b->fake_creds;
 826
 827                 item = KDBUS_ITEM_NEXT(item);
 828         }
 829
 830         if (b->fake_pids_valid) {
 831                 item->size = offsetof(struct kdbus_item, pids) + sizeof(struct kdbus_pids);
 832                 item->type = KDBUS_ITEM_PIDS;
 833                 item->pids = b->fake_pids;
 834
 835                 item = KDBUS_ITEM_NEXT(item);
 836         }
 837
 838         if (b->fake_label) {
 839                 item->size = offsetof(struct kdbus_item, str) + l + 1;
 840                 item->type = KDBUS_ITEM_SECLABEL;
 841                 memcpy(item->str, b->fake_label, l+1);
 842         }
 843
 844         r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
 845         if (r < 0)
 846                 return -errno;
 847
 848         if (!b->kdbus_buffer) {
 849                 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
 850                 if (b->kdbus_buffer == MAP_FAILED) {
 851                         b->kdbus_buffer = NULL;
 852                         return -errno;
 853                 }
 854         }
 855
 856         /* The higher 32bit of the bus_flags fields are considered
 857          * 'incompatible flags'. Refuse them all for now. */
 858         if (hello->bus_flags > 0xFFFFFFFFULL)
 859                 return -ENOTSUP;
 860
 861         if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
 862                 return -ENOTSUP;
 863
 864         b->bloom_size = (size_t) hello->bloom.size;
 865         b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
 866
 867         if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
 868                 return -ENOMEM;
 869
 870         b->unique_id = hello->id;
 871
 872         b->is_kernel = true;
 873         b->bus_client = true;
 874         b->can_fds = !!(hello->flags & KDBUS_HELLO_ACCEPT_FD);
 875         b->message_version = 2;
 876         b->message_endian = BUS_NATIVE_ENDIAN;
 877
 878         /* the kernel told us the UUID of the underlying bus */
 879         memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
 880
 881         return bus_start_running(b);
 882 }
 883
 884 int bus_kernel_connect(sd_bus *b) {
 885         assert(b);
 886         assert(b->input_fd < 0);
 887         assert(b->output_fd < 0);
 888         assert(b->kernel);
 889
 890         if (b->is_server)
 891                 return -EINVAL;
 892
 893         b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
 894         if (b->input_fd < 0)
 895                 return -errno;
 896
 897         b->output_fd = b->input_fd;
 898
 899         return bus_kernel_take_fd(b);
 900 }
 901
 902 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
 903         struct kdbus_cmd_free cmd = {};
 904         struct kdbus_item *d;
 905
 906         assert(bus);
 907         assert(k);
 908
 909         cmd.offset = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
 910
 911         KDBUS_ITEM_FOREACH(d, k, items) {
 912
 913                 if (d->type == KDBUS_ITEM_FDS)
 914                         close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
 915                 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
 916                         safe_close(d->memfd.fd);
 917         }
 918
 919         (void) ioctl(bus->input_fd, KDBUS_CMD_FREE, &cmd);
 920 }
 921
 922 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
 923         int r;
 924
 925         assert(bus);
 926         assert(m);
 927         assert(bus->state == BUS_RUNNING);
 928
 929         /* If we can't deliver, we want room for the error message */
 930         r = bus_rqueue_make_room(bus);
 931         if (r < 0)
 932                 return r;
 933
 934         r = bus_message_setup_kmsg(bus, m);
 935         if (r < 0)
 936                 return r;
 937
 938         /* If this is a synchronous method call, then let's tell the
 939          * kernel, so that it can pass CPU time/scheduling to the
 940          * destination for the time, if it wants to. If we
 941          * synchronously wait for the result anyway, we won't need CPU
 942          * anyway. */
 943         if (hint_sync_call)
 944                 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
 945
 946         r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
 947         if (r < 0) {
 948                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 949                 sd_bus_message *reply;
 950
 951                 if (errno == EAGAIN || errno == EINTR)
 952                         return 0;
 953                 else if (errno == ENXIO || errno == ESRCH) {
 954
 955                         /* ENXIO: unique name not known
 956                          * ESRCH: well-known name not known */
 957
 958                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
 959                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
 960                         else {
 961                                 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
 962                                 return 0;
 963                         }
 964
 965                 } else if (errno == EADDRNOTAVAIL) {
 966
 967                         /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
 968
 969                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
 970                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
 971                         else {
 972                                 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
 973                                 return 0;
 974                         }
 975                 } else
 976                         return -errno;
 977
 978                 r = bus_message_new_synthetic_error(
 979                                 bus,
 980                                 BUS_MESSAGE_COOKIE(m),
 981                                 &error,
 982                                 &reply);
 983
 984                 if (r < 0)
 985                         return r;
 986
 987                 r = bus_seal_synthetic_message(bus, reply);
 988                 if (r < 0)
 989                         return r;
 990
 991                 bus->rqueue[bus->rqueue_size++] = reply;
 992
 993         } else if (hint_sync_call) {
 994                 struct kdbus_msg *k;
 995
 996                 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
 997                 assert(k);
 998
 999                 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1000
1001                         r = bus_kernel_make_message(bus, k);
1002                         if (r < 0) {
1003                                 close_kdbus_msg(bus, k);
1004
1005                                 /* Anybody can send us invalid messages, let's just drop them. */
1006                                 if (r == -EBADMSG || r == -EPROTOTYPE)
1007                                         log_debug("Ignoring invalid message: %s", strerror(-r));
1008                                 else
1009                                         return r;
1010                         }
1011                 } else {
1012                         log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1013                         close_kdbus_msg(bus, k);
1014                 }
1015         }
1016
1017         return 1;
1018 }
1019
1020 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
1021         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1022         int r;
1023
1024         assert(bus);
1025
1026         r = sd_bus_message_new_signal(
1027                         bus,
1028                         &m,
1029                         "/org/freedesktop/DBus",
1030                         "org.freedesktop.DBus",
1031                         "NameOwnerChanged");
1032         if (r < 0)
1033                 return r;
1034
1035         r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
1036         if (r < 0)
1037                 return r;
1038
1039         m->sender = "org.freedesktop.DBus";
1040
1041         r = bus_seal_synthetic_message(bus, m);
1042         if (r < 0)
1043                 return r;
1044
1045         bus->rqueue[bus->rqueue_size++] = m;
1046         m = NULL;
1047
1048         return 1;
1049 }
1050
1051 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1052         char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
1053
1054         assert(bus);
1055         assert(k);
1056         assert(d);
1057
1058         if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
1059                 old_owner[0] = 0;
1060         else
1061                 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id.id);
1062
1063         if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new_id.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
1064
1065                 if (isempty(old_owner))
1066                         return 0;
1067
1068                 new_owner[0] = 0;
1069         } else
1070                 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id.id);
1071
1072         return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
1073 }
1074
1075 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1076         char owner[UNIQUE_NAME_MAX];
1077
1078         assert(bus);
1079         assert(k);
1080         assert(d);
1081
1082         sprintf(owner, ":1.%llu", d->id_change.id);
1083
1084         return push_name_owner_changed(
1085                         bus, owner,
1086                         d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
1087                         d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
1088 }
1089
1090 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
1091         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1092         int r;
1093
1094         assert(bus);
1095         assert(k);
1096         assert(d);
1097
1098         r = bus_message_new_synthetic_error(
1099                         bus,
1100                         k->cookie_reply,
1101                         d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
1102                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
1103                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
1104                         &m);
1105         if (r < 0)
1106                 return r;
1107
1108         m->sender = "org.freedesktop.DBus";
1109
1110         r = bus_seal_synthetic_message(bus, m);
1111         if (r < 0)
1112                 return r;
1113
1114         bus->rqueue[bus->rqueue_size++] = m;
1115         m = NULL;
1116
1117         return 1;
1118 }
1119
1120 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1121         struct kdbus_item *d, *found = NULL;
1122
1123         static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1124                 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1125                 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1126                 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1127
1128                 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1129                 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1130
1131                 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1132                 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1133         };
1134
1135         assert(bus);
1136         assert(k);
1137         assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1138
1139         KDBUS_ITEM_FOREACH(d, k, items) {
1140                 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1141                         if (found)
1142                                 return -EBADMSG;
1143                         found = d;
1144                 } else
1145                         log_debug("Got unknown field from kernel %llu", d->type);
1146         }
1147
1148         if (!found) {
1149                 log_debug("Didn't find a kernel message to translate.");
1150                 return 0;
1151         }
1152
1153         return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1154 }
1155
1156 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1157         struct kdbus_cmd_recv recv = {};
1158         struct kdbus_msg *k;
1159         int r;
1160
1161         assert(bus);
1162
1163         r = bus_rqueue_make_room(bus);
1164         if (r < 0)
1165                 return r;
1166
1167         if (hint_priority) {
1168                 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1169                 recv.priority = priority;
1170         }
1171
1172         r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1173         if (r < 0) {
1174                 if (errno == EAGAIN)
1175                         return 0;
1176
1177                 if (errno == EOVERFLOW) {
1178                         log_debug("%s: kdbus reports %" PRIu64 " dropped broadcast messages, ignoring.", strna(bus->description), (uint64_t) recv.dropped_msgs);
1179                         return 0;
1180                 }
1181
1182                 return -errno;
1183         }
1184
1185         k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1186         if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1187                 r = bus_kernel_make_message(bus, k);
1188
1189                 /* Anybody can send us invalid messages, let's just drop them. */
1190                 if (r == -EBADMSG || r == -EPROTOTYPE) {
1191                         log_debug("Ignoring invalid message: %s", strerror(-r));
1192                         r = 0;
1193                 }
1194
1195         } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1196                 r = bus_kernel_translate_message(bus, k);
1197         else {
1198                 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1199                 r = 0;
1200         }
1201
1202         if (r <= 0)
1203                 close_kdbus_msg(bus, k);
1204
1205         return r < 0 ? r : 1;
1206 }
1207
1208 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1209         struct memfd_cache *c;
1210         int fd;
1211
1212         assert(address);
1213         assert(mapped);
1214         assert(allocated);
1215
1216         if (!bus || !bus->is_kernel)
1217                 return -ENOTSUP;
1218
1219         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1220
1221         if (bus->n_memfd_cache <= 0) {
1222                 int r;
1223
1224                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1225
1226                 r = memfd_new(bus->description);
1227                 if (r < 0)
1228                         return r;
1229
1230                 *address = NULL;
1231                 *mapped = 0;
1232                 *allocated = 0;
1233                 return r;
1234         }
1235
1236         c = &bus->memfd_cache[--bus->n_memfd_cache];
1237
1238         assert(c->fd >= 0);
1239         assert(c->mapped == 0 || c->address);
1240
1241         *address = c->address;
1242         *mapped = c->mapped;
1243         *allocated = c->allocated;
1244         fd = c->fd;
1245
1246         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1247
1248         return fd;
1249 }
1250
1251 static void close_and_munmap(int fd, void *address, size_t size) {
1252         if (size > 0)
1253                 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1254
1255         safe_close(fd);
1256 }
1257
1258 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1259         struct memfd_cache *c;
1260         uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1261
1262         assert(fd >= 0);
1263         assert(mapped == 0 || address);
1264
1265         if (!bus || !bus->is_kernel) {
1266                 close_and_munmap(fd, address, mapped);
1267                 return;
1268         }
1269
1270         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1271
1272         if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1273                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1274
1275                 close_and_munmap(fd, address, mapped);
1276                 return;
1277         }
1278
1279         c = &bus->memfd_cache[bus->n_memfd_cache++];
1280         c->fd = fd;
1281         c->address = address;
1282
1283         /* If overly long, let's return a bit to the OS */
1284         if (mapped > max_mapped) {
1285                 assert_se(memfd_set_size(fd, max_mapped) >= 0);
1286                 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1287                 c->mapped = c->allocated = max_mapped;
1288         } else {
1289                 c->mapped = mapped;
1290                 c->allocated = allocated;
1291         }
1292
1293         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1294 }
1295
1296 void bus_kernel_flush_memfd(sd_bus *b) {
1297         unsigned i;
1298
1299         assert(b);
1300
1301         for (i = 0; i < b->n_memfd_cache; i++)
1302                 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1303 }
1304
1305 uint64_t request_name_flags_to_kdbus(uint64_t flags) {
1306         uint64_t f = 0;
1307
1308         if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1309                 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1310
1311         if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1312                 f |= KDBUS_NAME_REPLACE_EXISTING;
1313
1314         if (flags & SD_BUS_NAME_QUEUE)
1315                 f |= KDBUS_NAME_QUEUE;
1316
1317         return f;
1318 }
1319
1320 uint64_t attach_flags_to_kdbus(uint64_t mask) {
1321         uint64_t m = 0;
1322
1323         if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
1324                     SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID))
1325                 m |= KDBUS_ATTACH_CREDS;
1326
1327         if (mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1328                 m |= KDBUS_ATTACH_PIDS;
1329
1330         if (mask & SD_BUS_CREDS_COMM)
1331                 m |= KDBUS_ATTACH_PID_COMM;
1332
1333         if (mask & SD_BUS_CREDS_TID_COMM)
1334                 m |= KDBUS_ATTACH_TID_COMM;
1335
1336         if (mask & SD_BUS_CREDS_EXE)
1337                 m |= KDBUS_ATTACH_EXE;
1338
1339         if (mask & SD_BUS_CREDS_CMDLINE)
1340                 m |= KDBUS_ATTACH_CMDLINE;
1341
1342         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))
1343                 m |= KDBUS_ATTACH_CGROUP;
1344
1345         if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1346                 m |= KDBUS_ATTACH_CAPS;
1347
1348         if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1349                 m |= KDBUS_ATTACH_SECLABEL;
1350
1351         if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1352                 m |= KDBUS_ATTACH_AUDIT;
1353
1354         if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1355                 m |= KDBUS_ATTACH_NAMES;
1356
1357         if (mask & SD_BUS_CREDS_DESCRIPTION)
1358                 m |= KDBUS_ATTACH_CONN_DESCRIPTION;
1359
1360         if (mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS)
1361                 m |= KDBUS_ATTACH_AUXGROUPS;
1362
1363         return m;
1364 }
1365
1366 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1367         struct kdbus_cmd_make *make;
1368         struct kdbus_item *n;
1369         size_t l;
1370         int fd;
1371
1372         assert(name);
1373         assert(s);
1374
1375         fd = open("/sys/fs/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1376         if (fd < 0)
1377                 return -errno;
1378
1379         l = strlen(name);
1380         make = alloca0_align(offsetof(struct kdbus_cmd_make, items) +
1381                              ALIGN8(offsetof(struct kdbus_item, bloom_parameter) + sizeof(struct kdbus_bloom_parameter)) +
1382                              ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)) +
1383                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1),
1384                              8);
1385
1386         make->size = offsetof(struct kdbus_cmd_make, items);
1387
1388         /* Set the bloom parameters */
1389         n = make->items;
1390         n->size = offsetof(struct kdbus_item, bloom_parameter) +
1391                   sizeof(struct kdbus_bloom_parameter);
1392         n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1393         n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1394         n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1395
1396         assert_cc(DEFAULT_BLOOM_SIZE > 0);
1397         assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1398
1399         make->size += ALIGN8(n->size);
1400
1401         /* The busses we create make no restrictions on what metadata
1402          * peers can read from incoming messages. */
1403         n = KDBUS_ITEM_NEXT(n);
1404         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1405         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1406         n->data64[0] = _KDBUS_ATTACH_ANY;
1407         make->size += ALIGN8(n->size);
1408
1409         /* Set the a good name */
1410         n = KDBUS_ITEM_NEXT(n);
1411         sprintf(n->str, UID_FMT "-%s", getuid(), name);
1412         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1413         n->type = KDBUS_ITEM_MAKE_NAME;
1414         make->size += ALIGN8(n->size);
1415
1416         make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1417
1418         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1419                 safe_close(fd);
1420                 return -errno;
1421         }
1422
1423         if (s) {
1424                 char *p;
1425
1426                 p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
1427                 if (!p) {
1428                         safe_close(fd);
1429                         return -ENOMEM;
1430                 }
1431
1432                 *s = p;
1433         }
1434
1435         return fd;
1436 }
1437
1438 static int bus_kernel_translate_access(BusPolicyAccess access) {
1439         assert(access >= 0);
1440         assert(access < _BUS_POLICY_ACCESS_MAX);
1441
1442         switch (access) {
1443
1444         case BUS_POLICY_ACCESS_SEE:
1445                 return KDBUS_POLICY_SEE;
1446
1447         case BUS_POLICY_ACCESS_TALK:
1448                 return KDBUS_POLICY_TALK;
1449
1450         case BUS_POLICY_ACCESS_OWN:
1451                 return KDBUS_POLICY_OWN;
1452
1453         default:
1454                 assert_not_reached("Unknown policy access");
1455         }
1456 }
1457
1458 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1459         int r;
1460
1461         assert(policy);
1462         assert(item);
1463
1464         switch (policy->type) {
1465
1466         case BUSNAME_POLICY_TYPE_USER: {
1467                 const char *user = policy->name;
1468                 uid_t uid;
1469
1470                 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1471                 if (r < 0)
1472                         return r;
1473
1474                 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1475                 item->policy_access.id = uid;
1476                 break;
1477         }
1478
1479         case BUSNAME_POLICY_TYPE_GROUP: {
1480                 const char *group = policy->name;
1481                 gid_t gid;
1482
1483                 r = get_group_creds(&group, &gid);
1484                 if (r < 0)
1485                         return r;
1486
1487                 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1488                 item->policy_access.id = gid;
1489                 break;
1490         }
1491
1492         default:
1493                 assert_not_reached("Unknown policy type");
1494         }
1495
1496         item->policy_access.access = bus_kernel_translate_access(policy->access);
1497
1498         return 0;
1499 }
1500
1501 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1502         char *p;
1503         int fd;
1504         size_t len;
1505
1506         assert(bus);
1507
1508         len = strlen("/sys/fs/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1509
1510         if (path) {
1511                 p = new(char, len);
1512                 if (!p)
1513                         return -ENOMEM;
1514         } else
1515                 p = newa(char, len);
1516
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                 if (path)
1522                         free(p);
1523
1524                 return -errno;
1525         }
1526
1527         if (path)
1528                 *path = p;
1529
1530         return fd;
1531 }
1532
1533 int bus_kernel_create_endpoint(const char *bus_name, const char *ep_name, char **ep_path) {
1534         _cleanup_free_ char *path = NULL;
1535         struct kdbus_cmd_make *make;
1536         struct kdbus_item *n;
1537         const char *name;
1538         int fd;
1539
1540         fd = bus_kernel_open_bus_fd(bus_name, &path);
1541         if (fd < 0)
1542                 return fd;
1543
1544         make = alloca0_align(ALIGN8(offsetof(struct kdbus_cmd_make, items)) +
1545                              ALIGN8(offsetof(struct kdbus_item, str) + DECIMAL_STR_MAX(uid_t) + 1 + strlen(ep_name) + 1),
1546                              8);
1547         make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items));
1548         make->flags = KDBUS_MAKE_ACCESS_WORLD;
1549
1550         n = make->items;
1551         sprintf(n->str, UID_FMT "-%s", getuid(), ep_name);
1552         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1553         n->type = KDBUS_ITEM_MAKE_NAME;
1554         make->size += ALIGN8(n->size);
1555         name = n->str;
1556
1557         if (ioctl(fd, KDBUS_CMD_ENDPOINT_MAKE, make) < 0) {
1558                 safe_close(fd);
1559                 return -errno;
1560         }
1561
1562         if (ep_path) {
1563                 char *p;
1564
1565                 p = strjoin(dirname(path), "/", name, NULL);
1566                 if (!p) {
1567                         safe_close(fd);
1568                         return -ENOMEM;
1569                 }
1570
1571                 *ep_path = p;
1572         }
1573
1574         return fd;
1575 }
1576
1577 int bus_kernel_set_endpoint_policy(int fd, uid_t uid, BusEndpoint *ep) {
1578
1579         struct kdbus_cmd_update *update;
1580         struct kdbus_item *n;
1581         BusEndpointPolicy *po;
1582         Iterator i;
1583         size_t size;
1584         int r;
1585
1586         size = ALIGN8(offsetof(struct kdbus_cmd_update, items));
1587
1588         HASHMAP_FOREACH(po, ep->policy_hash, i) {
1589                 size += ALIGN8(offsetof(struct kdbus_item, str) + strlen(po->name) + 1);
1590                 size += ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1591         }
1592
1593         update = alloca0_align(size, 8);
1594         update->size = size;
1595
1596         n = update->items;
1597
1598         HASHMAP_FOREACH(po, ep->policy_hash, i) {
1599                 n->type = KDBUS_ITEM_NAME;
1600                 n->size = offsetof(struct kdbus_item, str) + strlen(po->name) + 1;
1601                 strcpy(n->str, po->name);
1602                 n = KDBUS_ITEM_NEXT(n);
1603
1604                 n->type = KDBUS_ITEM_POLICY_ACCESS;
1605                 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1606
1607                 n->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1608                 n->policy_access.access = bus_kernel_translate_access(po->access);
1609                 n->policy_access.id = uid;
1610
1611                 n = KDBUS_ITEM_NEXT(n);
1612         }
1613
1614         r = ioctl(fd, KDBUS_CMD_ENDPOINT_UPDATE, update);
1615         if (r < 0)
1616                 return -errno;
1617
1618         return 0;
1619 }
1620
1621 int bus_kernel_make_starter(
1622                 int fd,
1623                 const char *name,
1624                 bool activating,
1625                 bool accept_fd,
1626                 BusNamePolicy *policy,
1627                 BusPolicyAccess world_policy) {
1628
1629         struct kdbus_cmd_hello *hello;
1630         struct kdbus_item *n;
1631         size_t policy_cnt = 0;
1632         BusNamePolicy *po;
1633         size_t size;
1634         int r;
1635
1636         assert(fd >= 0);
1637         assert(name);
1638
1639         LIST_FOREACH(policy, po, policy)
1640                 policy_cnt++;
1641
1642         if (world_policy >= 0)
1643                 policy_cnt++;
1644
1645         size = offsetof(struct kdbus_cmd_hello, items) +
1646                ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1647                policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1648
1649         hello = alloca0_align(size, 8);
1650
1651         n = hello->items;
1652         strcpy(n->str, name);
1653         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1654         n->type = KDBUS_ITEM_NAME;
1655         n = KDBUS_ITEM_NEXT(n);
1656
1657         LIST_FOREACH(policy, po, policy) {
1658                 n->type = KDBUS_ITEM_POLICY_ACCESS;
1659                 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1660
1661                 r = bus_kernel_translate_policy(po, n);
1662                 if (r < 0)
1663                         return r;
1664
1665                 n = KDBUS_ITEM_NEXT(n);
1666         }
1667
1668         if (world_policy >= 0) {
1669                 n->type = KDBUS_ITEM_POLICY_ACCESS;
1670                 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1671                 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1672                 n->policy_access.access = bus_kernel_translate_access(world_policy);
1673         }
1674
1675         hello->size = size;
1676         hello->flags =
1677                 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1678                 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1679         hello->pool_size = KDBUS_POOL_SIZE;
1680         hello->attach_flags_send = _KDBUS_ATTACH_ANY;
1681         hello->attach_flags_recv = _KDBUS_ATTACH_ANY;
1682
1683         if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1684                 return -errno;
1685
1686         /* The higher 32bit of the bus_flags fields are considered
1687          * 'incompatible flags'. Refuse them all for now. */
1688         if (hello->bus_flags > 0xFFFFFFFFULL)
1689                 return -ENOTSUP;
1690
1691         if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
1692                 return -ENOTSUP;
1693
1694         return fd;
1695 }
1696
1697 int bus_kernel_try_close(sd_bus *bus) {
1698         assert(bus);
1699         assert(bus->is_kernel);
1700
1701         if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1702                 return -errno;
1703
1704         return 0;
1705 }
1706
1707 int bus_kernel_drop_one(int fd) {
1708         struct kdbus_cmd_recv recv = {
1709                 .flags = KDBUS_RECV_DROP
1710         };
1711
1712         assert(fd >= 0);
1713
1714         if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0)
1715                 return -errno;
1716
1717         return 0;
1718 }
1719
1720 int bus_kernel_realize_attach_flags(sd_bus *bus) {
1721         struct kdbus_cmd_update *update;
1722         struct kdbus_item *n;
1723
1724         assert(bus);
1725         assert(bus->is_kernel);
1726
1727         update = alloca0_align(offsetof(struct kdbus_cmd_update, items) +
1728                                ALIGN8(offsetof(struct kdbus_item, data64) + sizeof(uint64_t)),
1729                                8);
1730
1731         n = update->items;
1732         n->type = KDBUS_ITEM_ATTACH_FLAGS_RECV;
1733         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1734         n->data64[0] = bus->attach_flags;
1735
1736         update->size =
1737                 offsetof(struct kdbus_cmd_update, items) +
1738                 ALIGN8(n->size);
1739
1740         if (ioctl(bus->input_fd, KDBUS_CMD_CONN_UPDATE, update) < 0)
1741                 return -errno;
1742
1743         return 0;
1744 }