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