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