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