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